二叉树的遍历

二叉树遍历的说明

使用前序，中序和后序对二叉树进行遍历：

1. 前序遍历: 先输出父节点，再遍历左子树和右子树（父左右）

2. 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树（左父右）

3. 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点（左右父）

小结: 看输出父节点的顺序，就确定是前序，中序还是后序

 

根据遍历序列确定二叉树

由二叉树的先序序列和中序序列

1. 在先序序列中，第一个结点一定是二叉树的根结点

2. 在中序序列中，根结点必然将中序序列分割成两个子序列；前一个子序列是根结点的左子树的中序序列，后一个是右子树的

3. 根据这两个子序列，在先序序列中找到对应的左右子序列

4. 在先序序列中，左子序列的第一个结点是左子树的根结点，右子序列同理

5. 如此递归下去

 

 

• 总结：先序配合中序时，中序负责找左右子序列，先序负责找子树的根节点

由二叉树的中序序列和后序序列

1. 在后序序列，根结点在序列尾部

2. 在中序序列，根结点必在其中间，左边是左子树子孙，右边同理

3. 根据这两个子序列，在后序序列找到对应的左右序列

4. 在后序序列中，左子序列的尾结点是左子树的根结点，右子序列同理

5. 如此递归下去

 

 

• 总结：后序配合中序时，中序负责找左右子序列，后序负责找子树的根结点

注意：根据先序序列和后序序列是不能确定一个二叉树的

 

综上所述：

• 配合中序序列时，先序和后序都是确定子树的根结点，区别是根结点在其子序列的位置（先序是子序列的第一个，后序是子序列的最后一个）；
• 而中序序列都是在先或后序序列找到根结点后，找到左右子序列。

 二叉树节点代码实现

1. class Boy {  
2.     private char id;  
3.     private String name;  
4.     private Boy left;  //左子节点，默认为 null 
5.     private Boy right;  //右子节点，默认为 null 
6.   
7.   
8.     public Boy(char id, String name) {  
9.         this.id = id;  
10.        this.name = name;  
11.     }  
12.   
13.     public void setId(char id) {  
14.         this.id = id;  
15.     }  
16.   
17.     public int getId() {  
18.         return id;  
19.     }  
20.   
21.   
22.     public String getName() {  
23.         return name;  
24.     }  
25.   
26.     public void setName(String name) {  
27.         this.name = name;  
28.     }  
29.   
30.     public Boy getLeft() {  
31.         return left;  
32.     }  
33.   
34.     public void setLeft(Boy left) {  
35.         this.left = left;  
36.     }  
37.   
38.     public Boy getRight() {  
39.         return right;  
40.     }  
41.   
42.     public void setRight(Boy right) {  
43.         this.right = right;  
44.     }  
45.   
46.     @Override  
47.     public String toString() {  
48.         return "Boy{" +  
49.                 "id=" + id +  
50.                 ", name='" + name + '\'' +  
51.                 '}';  
52.     }  
53. }  

前序遍历代码实现

1. class PostOrder {  
2.     public static void postOrder(Boy boy) {  
3.         if (boy == null) {  
4.             System.out.println("二叉树为空，无法遍历");  
5.             return;  
6.         }  
7.         System.out.println(boy);//先输出父结点  
8.         if (boy.getLeft() != null) {//递归向左子树前序遍历  
9.             postOrder(boy.getLeft());  
10.         }  
11.         if (boy.getRight() != null) {//递归向右子树中序遍历  
12.             postOrder(boy.getRight());  
13.         }  
14.     }  
15.   
16. }  

中序遍历代码实现

1. class InfixOrder {  
2.     public static void infixOrder(Boy boy) {  
3.         if (boy == null) {  
4.             System.out.println("二叉树为空，无法遍历");  
5.             return;  
6.         }  
7.         if (boy.getLeft() != null) {//递归向左子树中序遍历  
8.             infixOrder(boy.getLeft());  
9.         }  
10.         System.out.println(boy);//输出父结点  
11.         if (boy.getRight() != null) {//递归向右子树中序遍历  
12.             infixOrder(boy.getRight());  
13.         }  
14.     }  
15. }  

后序遍历代码实现

1. class LastOrder {  
2.     public static void lastOrder(Boy boy) {  
3.         if (boy == null) {  
4.             System.out.println("二叉树为空，无法遍历");  
5.             return;  
6.         }  
7.         if (boy.getLeft() != null) {//递归向左子树中序遍历  
8.             lastOrder(boy.getLeft());  
9.         }  
10.         if (boy.getRight() != null) {//递归向右子树中序遍历  
11.             lastOrder(boy.getRight());  
12.         }  
13.         System.out.println(boy);//输出父结点  
14.     }  
15. }