我家自动化

这个屌丝很懒，什么也没留下！

热门标签

二叉树的学习_什么是二叉树模型

作者：我家自动化 | 2024-08-03 13:30:33

踩

什么是二叉树模型

学习目标：

二叉树

学习内容：

1.了解二叉树

2.使用Java建立二叉树模型

3.完成二叉树排序

学习时间：

2020-10-24

学习产出：

# 一、什么是树

树是一种数据结构，它是由n（n>=1）个有限结点组成一个具有层次关系的集合。

树具有的特点有：

（1）每个结点有零个或多个子结点

（2）没有父节点的结点称为根节点

（3）每一个非根结点有且只有一个父节点

（4）除了根结点外，每个子结点可以分为多个不相交的子树。

树的基本术语有：

若一个结点有子树，那么该结点称为子树根的“双亲”，子树的根称为该结点的“孩子”。有相同双亲的结点互为“兄弟”。一个结点的所有子树上的任何结点都是该结点的后裔。从根结点到某个结点的路径上的所有结点都是该结点的祖先。

根节点：没有父结点的的结点

结点的度：结点拥有的子树的数目

叶子结点：度为0的结点

分支结点：度不为0的结点

树的度：树中结点的最大的度

层次：根结点的层次为1，其余结点的层次等于该结点的双亲结点的层次加1

树的高度：树中结点的最大层次

森林：0个或多个不相交的树组成。对森林加上一个根，森林即成为树；删去根，树即成为森林。

二、什么是二叉树

二叉树是每个结点最多有两个子树的树结构。它有五种基本形态：二叉树可以是空集；根可以有空的左子树或右子树；或者左、右子树皆为空

即二叉树是度最大为二的树

2、二叉树的性质

性质1：二叉树第i层上的结点数目最多为2^(i-1)(i>=1)

性质2：深度为k的二叉树至多有(2^k)-1个结点（k>=1）

性质3：包含n个结点的二叉树的高度至少为(log2^k)+1（其中k表示不大于n的最大整数）

性质4：在任意一棵二叉树中，若终端结点的个数为n0，度为2的结点数为n2，则n0=n2+1

3、性质4的证明

性质4：在任意一棵二叉树中，若终端结点的个数为n0，度为2的结点数为n2，则n0=n2+1

证明：因为二叉树中所有结点的度数均不大于2，不妨设n0表示度为0的结点个数，n1表示度为1的结点个数，n2表示度为2的结点个数。三类结点加起来为总结点个数，于是便可得到：n=n0+n1+n2 (1)

由度之间的关系可得第二个等式：n=n0*0+n1*1+n2*2+1即n=n1+2n2+1 (2)

将（1）（2）组合在一起可得到n0=n2+1

三、二叉树的类型

1、满二叉树

定义：高度为h，并且由2h-1个结点组成的二叉树，称为满二叉树

2、完全二叉树

定义：一棵二叉树中，只有最下面两层结点的度可以小于2，并且最下层的叶结点集中在靠左的若干位置上，这样的二叉树称为完全二叉树。

特点：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。显然，一棵满二叉树必定是一棵完全二叉树，而完全二叉树未必是满二叉树。

面试题

如果一个完全二叉树的结点总数为768个，求叶子结点的个数。

由二叉树的性质知：n0=n2+1，将之带入768=n0+n1+n2中得：768=n1+2n2+1，因为完全二叉树度为1的结点个数要么为0，要么为1，那么就把n1=0或者1都代入公式中，很容易发现n1=1才符合条件。所以算出来n2=383，所以叶子结点个数n0=n2+1=384。

总结规律：如果一棵完全二叉树的结点总数为n，那么叶子结点等于n/2（当n为偶数时）或者(n+1)/2（当n为奇数时）

3、二叉查找树

定义：二叉查找树又被称为二叉搜索树。设x为二叉查找树中的一个结点，x结点包含关键字key，结点x的key值计为key[x]。如果y是x的左子树中的一个结点，则key[y]<=key[x]；如果y是x的右子树的一个结点，则key[y]>=key[x]

四、建立一个二叉树

1、建立二叉树模型

public class BinaryTree {
    Object data;//数据
    BinaryTree root;//父节点
    BinaryTree left;//左子树
    BinaryTree right;//右子树

    List<BinaryTree> datas;
    public BinaryTree(BinaryTree left,BinaryTree right,Object data){
        this.data=data;
        this.left=left;
        this.right=right;
    }
	//初始化二叉树
    public BinaryTree(Object data){
        this(null,null,data);
    }

    public BinaryTree(){};

    public void createBTree(Object[] obj){
        datas = new ArrayList<BinaryTree>();

        for(Object o:obj){
            datas.add(new BinaryTree(o));
        }
        //设置根节点
        root=datas.get(0);
		//建立二叉树
        for(int i = 0; i < obj.length/2; i++){
            datas.get(i).left = datas.get(i*2+1);//左子树

            if(i*2+2 < datas.size()){//避免偶数的时候 下标越界
                datas.get(i).right = datas.get(i*2+2);//右子树
            }
        }
    }
    public static void main(String[] args) {

        BinaryTree binaryTree = new BinaryTree();

        Object[] a = {1,5,9,3,6,8,4,2,0,7};
        binaryTree.createBTree(a);
        
        int k = 1;   
        for(int i = 1 ;i < a.length+1 ;i++){
            System.out.print(a[i-1]);
            if(i >= Math.pow(2,k)-1){
                System.out.println();
                k++;
            }
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

结果

2、二叉树的遍历

前序遍历/先序遍历

⑴ 访问根结点；⑵ 遍历左子树；⑶ 遍历右子树。

结果是GDAFEMHZ

中序遍历

⑴遍历左子树；⑵访问根结点；⑶遍历右子树。

结果是ADEFGHMZ

后序遍历

⑴遍历左子树；⑵遍历右子树；⑶访问根结点。

结果是AEFDHZMG

面试题

已知前序遍历、中序遍历求后序遍历

前序遍历：ABCDEF

中序遍历：CBDAEF

      A
  B       E 
C   D        F
1
2
3

后序遍历：CDBFEA

注意：已知前序遍历、后序遍历无法求出中序遍历（因为由前序后序重构出来的二叉树不止一种）

实现二叉树遍历

	//先序遍历
    public void preorder(BinaryTree root){
        if(root!=null){
            System.out.print(root.data);
            preorder(root.left);
            preorder(root.right);
        }
    }

    //中序遍历
    public void inorder(BinaryTree root){
        if(root!=null){
            inorder(root.left);
            System.out.print(root.data);
            inorder(root.right);
        }
    }
    //    后序遍历
    public void afterorder(BinaryTree root){
        if(root!=null){
            System.out.print(root.data);
            afterorder(root.left);
            afterorder(root.right);
        }
    }

 public static void main(String[] args) {

        BinaryTree binaryTree = new BinaryTree();
        Object[] a = {1,5,9,3,6,8,4,2,0,7};
        binaryTree.createBTree(a);
        int k = 1;
        for(int i = 1 ;i < a.length+1 ;i++){
            System.out.print(a[i-1]);
            if(i >= Math.pow(2,k)-1){
                System.out.println();
                k++;
            }
        }
        System.out.println();
        System.out.print("先序遍历:");
        binaryTree.preorder(binaryTree.root);
        System.out.println();
        System.out.print("中序遍历:");
        binaryTree.inorder(binaryTree.root);
        System.out.println();
        System.out.print("后序遍历:");
        binaryTree.afterorder(binaryTree.root);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

1
59
3684
207
先序遍历:1532067984
中序遍历:2305761894
后序遍历:1532067984
1
2
3
4
5
6
7

五、二叉查找树

思路：获取第一个数据作为点后，之后每个节点都在插入时与当前父结点比较，小的话左子树结点（大的话右子树结点）作为当前父结点再比较结果，直到结点为空，则插入当前结点。

1.定义一个二叉树容器

class Node{
    //节点值
    int   val;
    //左子节点引用
    Node  leftChild;
    //右子节点引用
    Node  rightChild;
}
1
2
3
4
5
6
7
8

public class BinarySearchTree {
    private Node root;

    //二叉查找树
    public void insert(int data){
        Node node = new Node();
        node.val = data;
        if(root == null){
            //如果是第一个节点，也就是根节点为null,直接创建一个新的节点即可
            root = node;
        }else {
            //定义当前结点
            Node current = root;
            //定义父结点
            Node parent;
            //插入时进行判断
            while(true){
                parent = current;
                //如果比父结点小
                if(data < current.val){
                    //左节点作为当前节点
                    current = current.leftChild;
                    //如果左结点为空，赋值
                    if(current == null){
                        parent.leftChild = node;
                        return;
                    }
                }
                else {//如果比当前结点大
                    //右节点作为当前节点
                    current = current.rightChild;
                    if(current == null){//如果为空，赋值
                        parent.rightChild = node;
                        return;
                    }
                }
            }
        }
    }

    //前序遍历
    public void preOrder(Node node){
        if(node != null){
            System.out.print(node.val);
            preOrder(node.leftChild);
            preOrder(node.rightChild);
        }
    }
    //中序遍历
    public void inOrder(Node node){
        if(node != null){
            inOrder(node.leftChild);
            System.out.print(node.val);
            inOrder(node.rightChild);
        }
    }


    public static void main(String[] args) {

        BinarySearchTree binarySearchTree = new BinarySearchTree();

        int[] arr = {9,6,2,4,7,8,5,1,3};

        for(int i = 0; i < arr.length; i++){

            binarySearchTree.insert(arr[i]);

        }
        binarySearchTree.preOrder(binarySearchTree.root);
        System.out.println();
        binarySearchTree.inOrder(binarySearchTree.root);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

结果

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/923208