java实现简单二叉树

我就是我 2023-10-02 10:40 11阅读 0赞

二叉树基本知识：

**一、树的定义**

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

![img][]

树具有的特点有：

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

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

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

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

树的基本术语有：

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

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

**叶子结点**：度为0的结点

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

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

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

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

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

**二、二叉树**

**1、二叉树的定义**

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

![img][img 1]

**2、二叉树的性质**

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

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

性质3：包含n个结点的二叉树的高度至少为(log2n)+1

性质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个结点组成的二叉树，称为满二叉树

![img][img 2]

**2、完全二叉树**

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

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

![img][img 3]

**面试题**：如果一个完全二叉树的结点总数为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\]

![img][img 4]

在二叉查找树种：

（1）若任意结点的左子树不空，则左子树上所有结点的值均小于它的根结点的值。

（2）任意结点的右子树不空，则右子树上所有结点的值均大于它的根结点的值。

（3）任意结点的左、右子树也分别为二叉查找树。

（4）没有键值相等的结点。

要求：将一个数组中的数以二叉树的存储结构存储，并遍历打印。

import java.util.ArrayList;
    import java.util.List;
     
    public class bintree {
        
        public bintree left;
        public bintree right;
        public bintree root;
    //    数据域
        private Object data;
        //    存节点
        public List<bintree> datas;
     
        public bintree(bintree left, bintree right, Object data){
        
            this.left=left;
            this.right=right;
            this.data=data;
        }
    //    将初始的左右孩子值为空
        public bintree(Object data){
        
            this(null,null,data);
        }
     
        public bintree() {
        
     
        }
     
        public void creat(Object[] objs){
        
            datas=new ArrayList<bintree>();
            //        将一个数组的值依次转换为Node节点
            for(Object o:objs){
        
                datas.add(new bintree(o));
            }
    //        第一个数为根节点
            root=datas.get(0);
    //        建立二叉树
            for (int i = 0; i <objs.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 void preorder(bintree root){
        
        if(root!=null){
        
            System.out.println(root.data);
            preorder(root.left);
            preorder(root.right);
        }
    }
    //中序遍历
        public void inorder(bintree root){
        
            if(root!=null){
        
                inorder(root.left);
                System.out.println(root.data);
                inorder(root.right);
            }
        }
    //    后序遍历
        public void afterorder(bintree root){
        
            if(root!=null){
        
                System.out.println(root.data);
                afterorder(root.left);
                afterorder(root.right);
            }
        }
        public static void main(String[] args) {
        
            bintree bintree=new bintree();
            Object []a={
        2,4,5,7,1,6,12,32,51,22};
            bintree.creat(a);
            bintree.preorder(bintree.root);
        }
    }

要求：从键盘输入数，存为二叉树结构并打印。

import java.util.Scanner;
     
    public class btree {
        
        private btree left,right;
        private char data;
        public btree creat(String des){
        
            Scanner scanner=new Scanner(System.in);
            System.out.println("des:"+des);
            String str=scanner.next();
            if(str.charAt(0)<'a')return null;
            btree root=new btree();
            root.data=str.charAt(0);
            root.left=creat(str.charAt(0)+"左子树");
            root.right=creat(str.charAt(0)+"右子树");
            return root;
        }
        public void midprint(btree btree){
        
    //        中序遍历
            if(btree!=null){
        
                midprint(btree.left);
                System.out.print(btree.data+"  ");
                midprint(btree.right);
            }
        }
        public void firprint(btree btree){
        
    //        先序遍历
            if(btree!=null){
        
                System.out.print(btree.data+" ");
                firprint(btree.left);
                firprint(btree.right);
            }
        }
        public void lastprint(btree btree){
        
    //        后序遍历
            if(btree!=null){
        
                lastprint(btree.left);
                lastprint(btree.right);
                System.out.print(btree.data+"  ");
            }
        }
        public static void main(String[] args) {
        
            btree tree = new btree();
            btree newtree=tree.creat("根节点");
            tree.firprint(newtree);
            System.out.println();
            tree.midprint(newtree);
            System.out.println();
            tree.lastprint(newtree);
        }
    }

输出结果：

des:根节点  
a  
des:a左子树  
e  
des:e左子树  
c  
des:c左子树  
1  
des:c右子树  
1  
des:e右子树  
b  
des:b左子树

1  
des:b右子树  
1  
des:a右子树  
d  
des:d左子树  
f  
des:f左子树  
1  
des:f右子树  
1  
des:d右子树  
1  
a e c b d f 先序  
c e b a f d 中序  
c b e f d a 后序

二叉树的遍历次序：

前序顺序是根节点排最先，然后同级先左后右；中序顺序是先左后根最后右；后序顺序是先左后右最后根。

例如：

![img][img 5]

比如上图二叉树遍历结果

前序遍历：ABCDEFGHK

中序遍历：BDCAEHGKF

后序遍历：DCBHKGFEA

分析中序遍历如下图，中序比较重要（java很多树排序是基于中序，后面讲解分析）

![img][img 6]

--------------------

[img]: https://img-blog.csdn.net/20170324154348019
[img 1]: https://img-blog.csdn.net/20170324154426661
[img 2]: https://img-blog.csdn.net/20170324154449411
[img 3]: https://img-blog.csdn.net/20170324154512412
[img 4]: https://img-blog.csdn.net/20170324154539151
[img 5]: https://img-blog.csdn.net/20180507110445948?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMjQzMTg5/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[img 6]: https://img-blog.csdnimg.cn/20210604135358195.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NreWxpYmlhbw==,size_16,color_FFFFFF,t_70