二叉树遍历算法

注：图片摘自flymey的博客，感谢！

二叉树前序遍历

根结点 ---> 左子树 ---> 右子树

二叉树前序遍历实现

定义二叉树(下同)：

1 public class TreeNode {
2     int val;
3     TreeNode left;
4     TreeNode right;
5     TreeNode(int x) 
6     {
7         val = x; 
8     }
9 }
View Code

实现：

 1 import java.util.LinkedList;
 2 
 3 public class PreOrderTree{
 4     /*
 5      * 前序遍历：根节点 —> 左节点 —> 右节点
 6      *       1
 7      *   2       3
 8      * 4   5      6
 9      *    7 8
10      */
11     public void preOrderBinaryTree(TreeNode root){
12         if (null == root) return;
13         
14         //Method One:
15         //System.out.println(root.val+" ");        
16         //preOrderBinaryTree(root.left);
17         //preOrderBinaryTree(root.right);
18         
19         //Method two:
20         LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
21         TreeNode pNode = root;
22         while (null != pNode || !stack.isEmpty()){
23             System.out.println(pNode.val+" ");    
24             if (null != pNode && (null != pNode.left || null != pNode.right)) stack.push(pNode);
25             
26             if (null != pNode && null != pNode.left) {                    
27                 pNode = pNode.left;
28             }
29             else{            
30                 if (stack.isEmpty()) break;
31                 TreeNode tmpNode = stack.pop();
32                 pNode = tmpNode.right;                                
33             }
34         }
35     }
36     
37     public static void main(String args[]){
38         TreeNode t1 = new TreeNode(1);
39         TreeNode t2 = new TreeNode(2);
40         TreeNode t3 = new TreeNode(3);
41         TreeNode t4 = new TreeNode(4);
42         TreeNode t5 = new TreeNode(5);
43         TreeNode t6 = new TreeNode(6);
44         TreeNode t7 = new TreeNode(7);
45         TreeNode t8 = new TreeNode(8);
46         
47         t1.left = t2;
48         t1.right = t3;
49         t2.left = t4;
50         t2.right = t5;
51         t5.left = t7;
52         t5.right = t8;
53         t3.right = t6;
54         
55         PreOrderTree p = new PreOrderTree();
56         p.preOrderBinaryTree(t1);
57     }
58 }
View Code

 

二叉树中序遍历

左子树---> 根结点 ---> 右子树

 二叉树中序遍历实现

 1 import java.util.LinkedList;
 2 
 3 public class MiddleOrderTree{
 4     public void middleOrderBinaryTree(TreeNode root){
 5         if (null == root) return;        
 6         
 7         //Method one:
 8         //middleOrderBinaryTree(root.left);
 9         //System.out.print(root.val+"  ");
10         //middleOrderBinaryTree(root.right);
11         
12         //Method two:
13         LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
14         TreeNode pNode = root;
15         
16         while (null != pNode){                                                
17             if (null != pNode.left){
18                 stack.push(pNode);
19                 pNode = pNode.left;                    
20             }
21             else{
22                 System.out.println(pNode.val);
23                 if (stack.isEmpty()) break;
24                 TreeNode tmp = stack.pop();
25                 System.out.println(tmp.val);
26                 pNode  = tmp.right;
27             }
28         }            
29     }
30     
31     public static void main(String args[]){
32         TreeNode t1 = new TreeNode(1);
33         TreeNode t2 = new TreeNode(2);
34         TreeNode t3 = new TreeNode(3);
35         TreeNode t4 = new TreeNode(4);
36         TreeNode t5 = new TreeNode(5);
37         TreeNode t6 = new TreeNode(6);
38         TreeNode t7 = new TreeNode(7);
39         TreeNode t8 = new TreeNode(8);
40         
41         t1.left = t2;
42         t1.right = t3;
43         t2.left = t4;
44         t2.right = t5;
45         t5.left = t7;
46         t5.right = t8;
47         t3.right = t6;
48         
49         MiddleOrderTree m = new MiddleOrderTree();
50         m.middleOrderBinaryTree(t1);
51     }
52 }
View Code

 

二叉树后序遍历

左子树 ---> 右子树 ---> 根结点

二叉树后序遍历实现

 1 import java.util.LinkedList;
 2 
 3 public class ProOrderTree {
 4     /*
 5      * 前序遍历：根节点 —> 左节点 —> 右节点 
 6      */
 7     public void proOrderBinaryTree(TreeNode root) {
 8         if (null == root)
 9             return;
10 
11         // Method one:
12         // proOrderBinaryTree(root.left);
13         // proOrderBinaryTree(root.right);
14         // System.out.println(root.val);
15 
16         // Method two:
17         LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
18         LinkedList<TreeNode> stack1 = new LinkedList<TreeNode>();
19         TreeNode pNode = root;
20 
21         while (null != pNode) {
22             if (null != pNode.left) {
23                 stack.push(pNode);
24                 pNode = pNode.left;
25             } else {
26                 if (null != pNode.right) {
27                     stack.push(pNode);
28                     pNode = pNode.right;
29                 } else {
30                     int tmpInt = pNode.val;
31                     System.out.println(pNode.val);                                            
32                     TreeNode tmp = stack.pop();
33                     stack1.push(tmp);
34                     pNode = tmp.right;
35                     if (null == pNode.left && null == pNode.right){
36                         if (tmpInt == pNode.val){}
37                         else System.out.println(pNode.val);                        
38                         while (!stack1.isEmpty()) System.out.println(stack1.pop().val);
39                         if (!stack.isEmpty()){
40                             TreeNode temp = stack.pop();
41                             stack1.push(temp);
42                             pNode = temp.right;
43                         } 
44                         else break;
45                     }
46                 }
47             }
48         }
49     }
50 
51     public static void main(String args[]) {
52         TreeNode t1 = new TreeNode(1);
53         TreeNode t2 = new TreeNode(2);
54         TreeNode t3 = new TreeNode(3);
55         TreeNode t4 = new TreeNode(4);
56         TreeNode t5 = new TreeNode(5);
57         TreeNode t6 = new TreeNode(6);
58         TreeNode t7 = new TreeNode(7);
59         TreeNode t8 = new TreeNode(8);
60 
61         t1.left = t2;
62         t1.right = t3;
63         t2.left = t4;
64         t2.right = t5;
65         t5.left = t7;
66         t5.right = t8;
67         t3.right = t6;
68 
69         ProOrderTree p = new ProOrderTree();
70         p.proOrderBinaryTree(t1);
71     }
72 }
View Code

 

二叉树层次遍历

仅仅需按层次遍历就可以

二叉树层次遍历实现

 

posted @ 2018-05-01 15:48  小筝  阅读(154)  评论(0)    收藏  举报