Java - 二叉树

二叉树指的是每个节点最多只能有两个子树的有序树。通常左边的子树被称为“左子树”，右边的子树被称为“右子树”。由此可见，二叉树仍然是树，只是一种特殊的树。

二叉树的每个节点最多只有两棵子树（不存在大于2的节点）。二叉树有左、右之分，不能颠倒。

树和二叉树的两个重要区别如下：

1.树中节点的最大度数没有限制，而二叉树节点的最大度数为2，也就是说，二叉树的节点最大度数为2。

2.无序树的节点无左右之分，而二叉树的节点有左右之分，也就是说二叉树是有序树。

一棵深度为K的二叉树，如果它包含了2^K - 1个节点，就把这棵二叉树称为满二叉树。满二叉树的特点是，每一层上的节点数都是最大节点数，即各层节点数分别为1,2,4,8,16，32，……，2^(K-1) 

一棵有n节点的二叉树，按满二叉树的方式对他进行编号，若树中所有节点和满二叉树1~n编号完全一致，则称该树为完全二叉树。也就是说如果一棵二叉树除最后一层外，其余所有的节点都是满的，并且最后一层或者是满的，或者仅在右边缺少若干连续的节点，则此二叉树就是完全二叉树。

注意：满二叉树是一种特殊的完全二叉树。当完全二叉树最后一层的所有节点都是满的情况下，这棵完全二叉树就变成了满二叉树。

综上所述，二叉树大致有如下几个性质：

（1）、二叉树的第 i 层上的节点至多有 2^(i-1)。 （i > 0）

（2）、深度为 k 的二叉树至多有 2^K   -   1 个节点。满二叉树的每层节点的数量依次为1,2,4,8，……，因此深度为 k 的满二叉树包含的节点数为公比为2的等比数列的前k项总合，即2^K   -   1。

（3）、在任何一棵二叉树中，如果其叶子节点的数量为N0，度为2的字节点数量为N2，则N0 = N2 + 1。这是因为：如果为任意叶子节点增加一个子节点，则原有叶子节点变成非叶子节点，新增节点变成叶子节点，上述等式不变；如果为任意叶子节点增加两个子节点，则原有叶子节点变成度为2的非叶子节点，新增的两个节点变成叶子节点，上述等式不变。

（4）、具有n个节点的完全二叉树的深度为log2（n+1）。

对于一棵具有 n 个节点的完全二叉树的节点按层自左向右编号，则对任意编号为 i （n >= i >= 1）的节点具有如下性质：

（1）当 i =1时，节点 i 是二叉树的根；若 i > 1，则节点的父节点是 i/2。

（2）若 2i <= n，则节点 i 有左孩子，左孩子的编号为 2i，否则，节点无左孩子，并且是叶子节点。

（3）若 2i + 1 <= n，则节点 i 有右孩子，右孩子的编号是 2i+ 1；否则节点无右孩子。

（4）1 ~ n/2 范围的节点都是有孩子的非叶子节点，其余的节点全部都是叶子节点，编号为 n/2 的节点可能只有左子节点，也极有可能有左子节点，也有右子节点。

二叉树的基本操作：

二叉树记录其节点之间的父子关系更加简单，因为二叉树中的每个节点最多只能保存两个子节点。接下来，就是需要为二叉树实现如下基本操作：

（1）初始化：通常是有个构造器，用于创建一个空树，或者指定节点为根节点来创建二叉树。

（2）为指定节点添加子节点。

（3）判断二叉树是否为空。

（4）返回根节点。

（5）返回指定节点（非根节点）的父节点

（6）返回指定节点（非叶子节点）的左子节点。

（7）返回指定节点（非叶子节点）的右子节点。

（8）返回该二叉树的深度。

（9）返回指定节点的位置。

要实现二叉树的这种数据结构，有如下三种选择：

（1）顺序存储：采用数组来记录二叉树的所有节点。

（2）二叉链表存储：每个节点保留一个left、right域，分别指向其左、右子节点。

（3）三叉链表存储：每个节点保留一个left、right、parent域，分别指向其左、右子节点和父节点。

• 定义一个节点类，使节点与二叉树操作分离

[java]  view plain  copy

1. class Node {  
2.     int  value;  
3.     Node leftChild;  
4.     Node rightChild;  
5.       
6.     Node(int value) {  
7.         this.value = value;  
8.     }  
9.       
10.     public void display() {  
11.         System.out.print(this.value + "\t");  
12.     }  
13.   
14.     @Override  
15.     public String toString() {  
16.         // TODO Auto-generated method stub  
17.         return String.valueOf(value);  
18.     }  
19. }  

• 需要实现的二叉树操作

[java]  view plain  copy

1. class BinaryTree {  
2.     private Node root = null;  
3.       
4.     BinaryTree(int value) {  
5.         root = new Node(value);  
6.         root.leftChild  = null;  
7.         root.rightChild = null;  
8.     }  
9.     public Node findKey(int value) {}   //查找  
10.         public String insert(int value) {}  //插入  
11.         public void inOrderTraverse() {}    //中序遍历递归操作  
12.         public void inOrderByStack() {}     //中序遍历非递归操作      
13.         public void preOrderTraverse() {}  //前序遍历  
14.         public void preOrderByStack() {}   //前序遍历非递归操作  
15.         public void postOrderTraverse() {} //后序遍历  
16.         public void postOrderByStack() {}  //后序遍历非递归操作  
17.         public int getMinValue() {} //得到最小(大)值  
18.         public boolean delete(int value) {} //删除  
19. }  

• 查找数据：

[java]  view plain  copy

1.  public Node findKey(int value) {  
2.     Node current = root;  
3.     while (true) {  
4.         if (value == current.value) {  
5.             return current;  
6.         } else if (value < current.value) {  
7.             current = current.leftChild;  
8.         } else if (value > current.value) {  
9.             current = current.rightChild;  
10.         }  
11.           
12.         if (current == null) {  
13.             return null;  
14.         }  
15.     }  
16. }  

• 插入数据：与查找数据类似，不同点在于当节点为空时，不是返回而是插入

[java]  view plain  copy

1. public String insert(int value) {  
2. String error = null;  
3.   
4. Node node = new Node(value);  
5. if (root == null) {  
6.     root = node;  
7.     root.leftChild  = null;  
8.     root.rightChild = null;  
9. } else {  
10.     Node current = root;  
11.     Node parent = null;  
12.     while (true) {  
13.         if (value < current.value) {  
14.             parent = current;  
15.             current = current.leftChild;  
16.             if (current == null) {  
17.                 parent.leftChild = node;  
18.                 break;  
19.             }  
20.         } else if (value > current.value) {  
21.             parent = current;  
22.             current = current.rightChild;  
23.             if (current == null) {  
24.                 parent.rightChild = node;  
25.                 break;  
26.             }  
27.         } else {  
28.             error = "having same value in binary tree";  
29.         }     
30.     } // end of while  
31. }  
32. return error;  
33.   }  

• 遍历数据：

            1）中序遍历：最常用的一种遍历方法

[java]  view plain  copy

1.  /** 
2.  * //中序遍历(递归)： 
3.  *    1、调用自身来遍历节点的左子树 
4.  *    2、访问这个节点 
5.  *    3、调用自身来遍历节点的右子树 
6.  */  
7. public void inOrderTraverse() {  
8.     System.out.print("中序遍历:");  
9.     inOrderTraverse(root);  
10.     System.out.println();  
11. }  
12.   
13. private void inOrderTraverse(Node node) {  
14.     if (node == null)   
15.         return ;  
16.       
17.     inOrderTraverse(node.leftChild);  
18.     node.display();  
19.     inOrderTraverse(node.rightChild);  
20. }  

               

[java]  view plain  copy

1. /** 
2.      * 中序非递归遍历： 
3.      *     1）对于任意节点current，若该节点不为空则将该节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
4.      *     2）若左子树为空，栈顶节点出栈，访问节点后将该节点的右子树置为current 
5.      *     3) 重复1、2步操作，直到current为空且栈内节点为空。 
6.      */  
7.     public void inOrderByStack() {  
8.         System.out.print("中序非递归遍历:");  
9.         Stack<Node> stack = new Stack<Node>();  
10.         Node current = root;  
11.         while (current != null || !stack.isEmpty()) {  
12.             while (current != null) {  
13.                 stack.push(current);  
14.                 current = current.leftChild;  
15.             }  
16.               
17.             if (!stack.isEmpty()) {  
18.                 current = stack.pop();  
19.                 current.display();  
20.                 current = current.rightChild;  
21.             }  
22.         }  
23.         System.out.println();  
24.     }  

              2）前序遍历：

[java]  view plain  copy

1.  /** 
2.  * //前序遍历(递归)： 
3.  *    1、访问这个节点 
4.  *    2、调用自身来遍历节点的左子树 
5.  *    3、调用自身来遍历节点的右子树 
6.  */  
7. public void preOrderTraverse() {  
8.     System.out.print("前序遍历:");  
9.     preOrderTraverse(root);  
10.     System.out.println();  
11. }  
12.   
13. private void preOrderTraverse(Node node) {  
14.     if (node == null)   
15.         return ;  
16.       
17.     node.display();  
18.     preOrderTraverse(node.leftChild);  
19.     preOrderTraverse(node.rightChild);  
20. }  

               

[java]  view plain  copy

1. /** 
2.      * 前序非递归遍历： 
3.      *     1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
4.      *     2）若左子树为空，栈顶节点出栈，将该节点的右子树置为current 
5.      *     3) 重复1、2步操作，直到current为空且栈内节点为空。 
6.      */  
7.     public void preOrderByStack() {  
8.         System.out.print("前序非递归遍历:");  
9.         Stack<Node> stack = new Stack<Node>();  
10.         Node current = root;  
11.         while (current != null || !stack.isEmpty()) {  
12.             while (current != null) {  
13.                 stack.push(current);  
14.                 current.display();  
15.                 current = current.leftChild;  
16.             }  
17.               
18.             if (!stack.isEmpty()) {  
19.                 current = stack.pop();  
20.                 current = current.rightChild;  
21.             }  
22.         }  
23.         System.out.println();  
24.     }  

             3）后序遍历：

[java]  view plain  copy

1.  /** 
2.  * //后序遍历(递归)： 
3.  *    1、调用自身来遍历节点的左子树 
4.  *    2、调用自身来遍历节点的右子树 
5.  *    3、访问这个节点 
6.  */  
7. public void postOrderTraverse() {  
8.     System.out.print("后序遍历:");  
9.     postOrderTraverse(root);  
10.     System.out.println();  
11. }  
12.   
13. private void postOrderTraverse(Node node) {  
14.     if (node == null)   
15.         return ;  
16.       
17.     postOrderTraverse(node.leftChild);  
18.     postOrderTraverse(node.rightChild);  
19.     node.display();  
20. }  

[java]  view plain  copy

1. /** 
2.      * 后序非递归遍历： 
3.      *     1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
4.      *     2）若左子树为空，取栈顶节点的右子树，如果右子树为空或右子树刚访问过，则访问该节点，并将preNode置为该节点 
5.      *     3) 重复1、2步操作，直到current为空且栈内节点为空。 
6.      */  
7.     public void postOrderByStack() {  
8.         System.out.print("后序非递归遍历:");  
9.         Stack<Node> stack = new Stack<Node>();  
10.         Node current = root;  
11.         Node preNode = null;  
12.         while (current != null || !stack.isEmpty()) {  
13.             while (current != null) {  
14.                 stack.push(current);  
15.                 current = current.leftChild;  
16.             }  
17.               
18.             if (!stack.isEmpty()) {  
19.                 current = stack.peek().rightChild;  
20.                 if (current == null || current == preNode) {  
21.                     current = stack.pop();  
22.                     current.display();  
23.                     preNode = current;  
24.                     current = null;  
25.                 }  
26.             }  
27.         }  
28.         System.out.println();  
29.     }  

• 得到最小(大)值：依次向左(右)直到空为之

[java]  view plain  copy

1. public int getMinValue() {  
2. Node current = root;  
3. while (true) {  
4.     if (current.leftChild == null)  
5.         return current.value;  
6.       
7.     current = current.leftChild;  
8. }  

• 删除：删除操作很复杂，删除节点大致分为三种情况：

             1）删除节点为叶子节点

               

              2）删除节点只有一个子节点：只有一个左子节点和只有一个右子节点

               

              3）删除节点有两个子节点：这种情况比较复杂，需要寻找后继节点，即比要删除的节点的关键值次高的节点是它的后继节点。

            说得简单一些，后继节点就是比要删除的节点的关键值要大的节点集合中的最小值。

            得到后继节点的代码如下：

[java]  view plain  copy

1.  /** 
2.  *  
3.  * 得到后继节点，即删除节点的左后代 
4.  */  
5. private Node getSuccessor(Node delNode) {  
6.     Node successor = delNode;  
7.     Node successorParent = null;  
8.     Node current = delNode.rightChild;  
9.       
10.     while (current != null) {  
11.         successorParent = successor;  
12.         successor = current;  
13.         current = current.leftChild;  
14.     }  
15.       
16.     //如果后继节点不是删除节点的右子节点时，  
17.     if (successor != delNode.rightChild) {  
18.         //要将后继节点的右子节点指向后继结点父节点的左子节点，  
19.         successorParent.leftChild = successor.rightChild;  
20.         //并将删除节点的右子节点指向后继结点的右子节点  
21.         successor.rightChild = delNode.rightChild;  
22.     }  
23.     //任何情况下，都需要将删除节点的左子节点指向后继节点的左子节点  
24.     successor.leftChild = delNode.leftChild;  
25.       
26.     return successor;  
27. }  

                  a)如果后继节点是刚好是要删除节点的右子节点（此时可以知道，这个右子节点没有左子点，如果有，就不该这个右子节点为后继节点）

          

            

[java]  view plain  copy

1. //删除的节点为父节点的左子节点时：  
2. parent.leftChild = successor;  
3. successor.leftChild = delNode.leftChild;  
4.        
5. //删除的节点为父节点的右子节点时：  
6. parent.rightChild = successor;  
7. successor.leftChild = delNode.leftChild  

             b)如果后继节点为要删除节点的右子节点的左后代：

             

            

[java]  view plain  copy

1. //删除的节点为父节点的左子节点时：  
2.  successorParent.leftChild = successor.rightChild;  
3.  successor.rightChild = delNode.rightChild;  
4.   parent.leftChild = successor;  
5.   successor.leftChild = delNode.leftChild;  
6.         
7.   //删除的节点为父节点的右子节点时：  
8.   successorParent.leftChild = successor.rightChild;  
9.   successor.rightChild = delNode.rightChild;  
10.   parent.rightChild = successor;  
11.   successor.leftChild = delNode.leftChild;  

                综合以上各种情况，删除代码如下：

[java]  view plain  copy

1.  public boolean delete(int value) {  
2.     Node current = root;    //需要删除的节点  
3.     Node parent = null;     //需要删除的节点的父节点  
4.     boolean isLeftChild = true;   //需要删除的节点是否父节点的左子树  
5.       
6.     while (true) {  
7.         if (value == current.value) {  
8.             break;  
9.         } else if (value < current.value) {  
10.             isLeftChild = true;  
11.             parent = current;  
12.             current = current.leftChild;  
13.         } else {  
14.             isLeftChild = false;  
15.             parent = current;  
16.             current = current.rightChild;  
17.         }  
18.           
19.         //找不到需要删除的节点，直接返回  
20.         if (current == null)  
21.             return false;  
22.     }  
23.       
24.     //分情况考虑  
25.     //1、需要删除的节点为叶子节点  
26.     if (current.leftChild == null && current.rightChild == null) {  
27.         //如果该叶节点为根节点，将根节点置为null  
28.         if (current == root) {  
29.             root = null;  
30.         } else {  
31.             //如果该叶节点是父节点的左子节点，将父节点的左子节点置为null  
32.             if (isLeftChild) {  
33.                 parent.leftChild  = null;  
34.             } else { //如果该叶节点是父节点的右子节点，将父节点的右子节点置为null  
35.                 parent.rightChild = null;  
36.             }  
37.         }  
38.     }   
39.     //2、需要删除的节点有一个子节点，且该子节点为左子节点  
40.     else if (current.rightChild == null) {  
41.         //如果该节点为根节点，将根节点的左子节点变为根节点  
42.         if (current == root) {  
43.             root = current.leftChild;  
44.         } else {  
45.             //如果该节点是父节点的左子节点，将该节点的左子节点变为父节点的左子节点  
46.             if (isLeftChild) {  
47.                 parent.leftChild = current.leftChild;  
48.             } else {  //如果该节点是父节点的右子节点，将该节点的左子节点变为父节点的右子节点  
49.                 parent.rightChild = current.leftChild;  
50.             }  
51.         }  
52.     }  
53.     //2、需要删除的节点有一个子节点，且该子节点为右子节点  
54.     else if (current.leftChild == null) {  
55.         //如果该节点为根节点，将根节点的右子节点变为根节点  
56.         if (current == root) {  
57.             root = current.rightChild;  
58.         } else {  
59.             //如果该节点是父节点的左子节点，将该节点的右子节点变为父节点的左子节点  
60.             if (isLeftChild) {  
61.                 parent.leftChild = current.rightChild;  
62.             } else {  //如果该节点是父节点的右子节点，将该节点的右子节点变为父节点的右子节点  
63.                 parent.rightChild = current.rightChild;  
64.             }  
65.         }  
66.     }  
67.     //3、需要删除的节点有两个子节点，需要寻找该节点的后续节点替代删除节点  
68.     else {  
69.         Node successor = getSuccessor(current);  
70.         //如果该节点为根节点，将后继节点变为根节点，并将根节点的左子节点变为后继节点的左子节点  
71.         if (current == root) {  
72.             root = successor;  
73.         } else {  
74.             //如果该节点是父节点的左子节点，将该节点的后继节点变为父节点的左子节点  
75.             if (isLeftChild) {  
76.                 parent.leftChild = successor;  
77.             } else {  //如果该节点是父节点的右子节点，将该节点的后继节点变为父节点的右子节点  
78.                 parent.rightChild = successor;  
79.             }  
80.         }  
81.     }  
82.     current = null;  
83.     return true;  
84. }  

•                测试代码

[java]  view plain  copy

1.     public class BinaryTreeDemo {  
2.         public static void main(String[] args) {  
3.         BinaryTree bt = new BinaryTree(52);  
4.         bt.insert(580);  
5.         bt.insert(12);  
6.         bt.insert(50);  
7.         bt.insert(58);  
8.         bt.insert(9);  
9.         bt.insert(888);  
10.         bt.insert(248);  
11.         bt.insert(32);  
12.         bt.insert(666);  
13.         bt.insert(455);  
14.         bt.insert(777);  
15.         bt.insert(999);  
16.         bt.inOrderTraverse();  
17.         bt.preOrderTraverse();  
18.         bt.postOrderTraverse();  
19.         System.out.println(bt.findKey(32));  
20.         System.out.println(bt.findKey(81));  
21.         System.out.println("最小值:" + bt.getMinValue());  
22. //      bt.delete(32);      //删除叶子节点  
23. //      bt.delete(50);      //删除只有一个左子节点的节点  
24. //      bt.delete(248);      //删除只有一个右子节点的节点  
25. //      bt.delete(248);      //删除只有一个右子节点的节点  
26. //      bt.delete(580);      //删除有两个子节点的节点，且后继节点为删除节点的右子节点的左后代  
27. //      bt.delete(888);      //删除有两个子节点的节点，且后继节点为删除节点的右子节点  
28.         bt.delete(52);       //删除有两个子节点的节点，且删除节点为根节点  
29.           
30.         bt.inOrderTraverse();  
31.         }  
32.     }  

测试结果：

中序遍历:9123250 52  58248455580666777  888999  
中序非递归遍历:9 12  32 50 5258248455580  666777  888999  
前序遍历:52 12  9 50 3258058248 455888 666777 999
前序非递归遍历:52 12  9 50 3258058248 455888 666777 999
后序遍历:9 32  50 12 45524858777 666999 888580 52  
后序非递归遍历:9 32  50 12 45524858777 666999 888580 52  
32
null
最小值:9
中序遍历:9 12  32 50 58248455580666777  888999