二叉树四种遍历（递归+非递归）

一、先序遍历

思路：先输出当前节点，前序遍历左子树，前序遍历右子树

 1  //先序遍历
 2     //递归
 3     public static void  preOrder(BitNode root){
 4         root.visitNode();
 5         if(root.lchild != null)
 6             preOrder(root.lchild);
 7         if(root.rchild != null)
 8             preOrder(root.rchild);
 9 
10     }
11 //非递归,先输出再入栈
12     public static void preOrder1(BitNode root){
13         Stack<BitNode> stack = new Stack<BitNode>();
14         while(root != null || !stack.empty()){
15             while(root != null){  //沿左孩子走到底，同时输出
16                 System.out.print(root.data+" ");
17                 stack.push(root);
18                 root = root.lchild;
19             }
20             if(!stack.empty()){  //出栈，并将非空右孩子入栈
21                 root = stack.pop();
22                 root = root.rchild;
23             }
24
25         }
26     }

二、中序遍历

思路：中序遍历左子树，输出当前节点，中序遍历右子树

 1 //中序遍历
 2     //递归
 3     public static void inOrder(BitNode root){
 4         if(root.lchild != null){
 5             inOrder(root.lchild);
 6         }
 7        root.visitNode();
 8         if(root.rchild != null){
 9             inOrder(root.rchild);
10         }
11     }
12     //非递归,先入栈，后面先出栈再输出，出栈后将非空右孩子压入栈，空则继续弹出
13     public static void inOrder1(BitNode root) {
14         Stack<BitNode> stack = new Stack<>();
15         while (root != null || !stack.empty()) {
16             while (root != null) {
17                 stack.push(root);
18                 root = root.lchild;
19             }
20             if (!stack.empty()) {
21                 root = stack.pop();
22                 System.out.print(root.data+" ");
23                 root = root.rchild;
24             }
25         }
26     }

三、后序遍历

思路：后序遍历左子树，后序遍历右子树，输出当前节点

 1 //后序遍历
 2     //递归
 3     public static void postOrder(BitNode root){
 4         if(root.lchild != null){
 5             postOrder(root.lchild);
 6         }
 7         if(root.rchild != null){
 8             postOrder(root.rchild);
 9         }
10         root.visitNode();
11     }
12     //非递归
13     public static void postOrder1(BitNode root){
14         Stack<BitNode> stack = new Stack<>();
15         BitNode pre = null,cur;
16         stack.push(root);
17         while (!stack.empty()){
18             cur = stack.peek();
19             //若栈顶节点当前无左右节点则可输出并出栈，或者其左右节点被访问过（左节点：说明无右节点，右节点：说明有左右节点或者无左节点）
20             if((cur.lchild == null && cur.rchild == null)||(pre != null && (pre == cur.lchild ||pre == cur.rchild))){
21                 cur.visitNode();
22                 stack.pop();
23                 pre = cur;
24             }
25             else {//注意顺序，先放入右节点，再放入左节点，后进先出
26                 if(cur.rchild != null)
27                     stack.push(cur.rchild);
28                 if(cur.lchild != null)
29                     stack.push(cur.lchild);
30             }
31         }
32 
33     }

四、层次遍历

思路：利用队列先进先出，左右孩子进入队列后，当前节点从队列中删除

 1  //层次遍历，根据队列来控制循环，出队并输出，将左右孩子入队
 2     // 首先将根节点入队，队列若不为空则出队一个节点并输出，然后判断其左右节点是否为空，不为空则则入队
 3     public static void levelTraverse(BitNode root){
 4         Queue<BitNode>  queue = new LinkedList<BitNode>();
 5         queue.offer(root);
 6         while(!queue.isEmpty()){
 7             BitNode bitNode = queue.poll();
 8             bitNode.visitNode();
 9             if(bitNode.lchild != null)
10                 queue.offer(bitNode.lchild);
11             if(bitNode.rchild != null)
12                 queue.offer(bitNode.rchild);
13         }
14     }

 

posted @ 2018-04-10 21:13  菩提本无树呀~  阅读(229)  评论(0)  编辑  收藏  举报