二叉树的认识 及 遍历(Java)

概念（认识树）：

• 除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个集合 Ti (1 <= i <= m) 又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继 。
• 树形结构中，子树之间不能有交集，否则就不是树形结构。
• 树是递归定义的。 （很多题是由递归实现）

 

• 除了根节点外，每个结点有且仅有一个父节点。
• 一颗N个结点的树有N-1条边。

 重点概念：

 

 

结点的度：一个结点含有子树的个数称为该结点的度； 如上图：A的度为6

树的度：一棵树中，所有结点度的最大值称为树的度； 如上图：树的度为6

叶子结点或终端结点：度为0的结点称为叶子结点； 如上图：B、C、H、I...等节点为叶结点

双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点

孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点

根结点：一棵树中，没有双亲结点的结点；如上图：A

结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推

树的高度：树中结点的最大层次； 如上图：树的高度为4

树的深度：是树的最大高度。图里是4。

树的以下概念只需了解，在看书时只要知道是什么意思即可：

非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G...等节点为分支结点

兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点

堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点

结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先

子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙

森林：由m（m>=0）棵互不相交的树组成的集合称为森林

 

  树的表示形式（了解）

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，实际中树有很多种表示方式，如： 双亲表示法， 孩子表示法、 孩子双亲表示法、 孩子兄弟表示法等等。我们这里就简单的了解其中最常用的 孩子兄弟表示法。

 

二叉树（重点）

 1. 二叉树不存在度大于2 的结点

2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

一棵二叉树是结点的一个有限集合，该集合：

1. 或者为空

2. 或者是由 一个根节点加上两棵别称为 左子树和 右子树的二叉树组成。

 

两种特殊的二叉树

 

1. 满二叉树 : 一棵二叉树，如果 每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是

说， 如果一棵二叉树的层数为 K ，且结点总数是 ( 2^k) - 1，则它就是满二叉树。

 

2. 完全二叉树 : 叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。

 

 

二叉树的性质

1. 若规定 根结点的层数为 1，则一棵 非空二叉树的第 i 层上最多有2^(i-1) (i>0) 个结点

2. 若规定只有 根结点的二叉树的深度为 1，则 深度为 K的二叉树的最大结点数是 ( 2^k) - 1(k>=0)

3. 对任何一棵二叉树, 如果其 叶结点个数为 n0, 度为 2 的非叶结点个数为 n2, 则有 n0 ＝ n2 ＋ 1

4. 具有 n 个结点的完全二叉树的深度k为log₂ (n+1)向上取整

 

 用到上面性质来做题

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（B）

A 不存在这样的二叉树

B 200

C 198

D 199

2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（A）

A n

B n+1

C n-1

D n/2

 n0=n2+1

2n=n0+n1+n2   2n=n0+1+n0-1   n0=n

3.一个具有767个节点的完全二叉树，其叶子节点个数为（A）

A 383

B 384

C 385

D 386

 

767=n0+n1+n2

=n0+n0-1

=766/2=383

4.一棵完全二叉树的节点数为531个，那么这棵树的高度为（B）

A 11

B 10

C 8

D 12

 2^9 = 512    2^10 = 1024（向上取整）

5. 对于具有 n 个结点的完全二叉树，如果按照 从上至下从左至右的顺序对所有节点从 0 开始编号，则对于 序号为 i 的结点有：

●若i>0， 双亲序号： (i-1)/2； i=0 ， i 为根结点编号，无双亲结点

● 若2 i+1<n ，左孩子序号： 2 i+1 ，否则无左孩子

● 若2 i+2<n ，右孩子序号： 2 i+2 ，否则无右孩子

已知孩子节点为i，求双亲节点的下标：（i -1）/2（向下取整）

已知父亲节点为i，求孩子下标：左孩子：2*i +1    右孩子：2*i + 2

---

二叉树的存储

二叉树的存储结构分为： 顺序存储和 类似于链表的链式存储。

顺序存储在下节介绍。

二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式，这种表示方法叫孩子表示法如下：

                    

还有一种叫孩子双亲表示法（和上面不同的是，可以访问父母的地址）如下图：

 

 

---

下面学习二叉树的基本操作

此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，便于对二叉树的理解。不是真正二叉树。

           public class BinaryTree{
                static class BTNode{
                 BTNode left;
                 BTNode right;
                 int value;
                 BTNode(int value){
                 this.value = value;
                }
              }
          private BTNode root;
        
         public void createBinaryTree(){
              BTNode node1 = new BTNode(1);
              BTNode node2 = new BTNode(2);
              BTNode node3 = new BTNode(3);
              BTNode node4 = new BTNode(4);
              BTNode node5 = new BTNode(5);
              BTNode node6 = new BTNode(6);
               root = node1;
               node1.left = node2;
               node2.left = node3;
               node1.right = node4;
               node4.left = node5;
               node5.right = node6;
                returnA;
          }
            
}

 

 

 前中后序遍历

NLR：前序遍历(Preorder Traversal 亦称先序遍历)——根--->左--->右

LNR：中序遍历(Inorder Traversal)——左--->根--->右

LRN：后序遍历(Postorder Traversal)——左--->右--->根

 

 

层序遍历：是一层一层的遍历。第一层遍历完，遍历第二层……

下面一个例题：

 

1.某完全二叉树按层次输出（同一层从左到右）的序列为 ABCDEFGH 。该完全二叉树的前序序列为()

A: ABDHECFG B: ABCDEFGH C: HDBEAFCG D: HDEBFGCA

2.二叉树的先序遍历和中序遍历如下：先序遍历：EFHIGJK;中序遍历：HFIEJKG.则二叉树根结点为()

A: E B: F C: G D: H

3.设一课二叉树的中序遍历序列：badce，后序遍历序列：bdeca，则二叉树前序遍历序列为()

A: adbce B: decab C: debac D: abcde

4.某二叉树的后序遍历序列与中序遍历序列相同，均为 ABCDEF ，则按层次输出(同一层从左到右)的序列为()

A: FEDCBA B: CBAFED C: DEFCBA D: ABCDEF

【参考答案】 1.A 2.A 3.D 4.A

 

 下面是前序遍历的代码图解

对前序遍历，中序遍历，后序遍历写代码。

public class BinaryTree {
  
        static class TreeNode{
            TreeNode left;
            TreeNode right;
            char val;
            TreeNode(char value){
                this.val= value;
            }
        }

        public TreeNode createTree(){
            TreeNode A = new TreeNode('A');
            TreeNode B = new TreeNode('B');
            TreeNode C = new TreeNode('C');
            TreeNode D = new TreeNode('D');
            TreeNode E = new TreeNode('E');
            TreeNode F = new TreeNode('F');
            TreeNode G = new TreeNode('G');
            TreeNode H = new TreeNode('H');

            A.left  = B;
            A.right = C;
            B.left  = D;
            B.right = E;
            C.left  = F;
            C.right = G;
            E.right = H;
            return A;
        }
        //前序遍历
        void preOrder(TreeNode root){
            if(root==null)return;
            System.out.println(root.val+" ");
            preOrder(root.left);
            preOrder(root.right);

        }
        //中序遍历
        void inOrder(TreeNode root){
            if(root==null)return;
            inOrder(root.left);
            System.out.println(root.val+" ");
            inOrder(root.right);
        }
        //后序遍历
        void postOrder(TreeNode root){
            if(root==null)return;
            inOrder(root.left);
            inOrder(root.right);
            System.out.println(root.val+" ");
        }