二叉树的遍历

原文出自：http://blog.csdn.net/fantasy_lin_/article/details/52751559#

1、分析

        二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。

        深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下：

• 先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。
• 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树。
• 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。

        广度优先遍历：又叫层次遍历，从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。

深度优先

英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。对于上面的例子来说深度优先遍历的结果就是：A,B,D,E,I,C,F,G,H.(假设先走子节点的的左侧)。

深度优先遍历各个节点，需要使用到堆（Stack）这种数据结构。stack的特点是是先进后出。整个遍历过程如下：

首先将A节点压入堆中，stack（A）;

将A节点弹出，同时将A的子节点C，B压入堆中，此时B在堆的顶部，stack(B,C)；

将B节点弹出，同时将B的子节点E，D压入堆中，此时D在堆的顶部，stack（D,E,C）；

将D节点弹出，没有子节点压入,此时E在堆的顶部，stack（E，C）；

将E节点弹出，同时将E的子节点I压入，stack（I,C）；

...依次往下，最终遍历完成。

广度优先

        英文缩写为BFS即Breadth FirstSearch。其过程检验来说是对每一层节点依次访问，访问完一层进入下一层，而且每个节点只能访问一次。对于上面的例子来说，广度优先遍历的 结果是：A,B,C,D,E,F,G,H,I(假设每层节点从左到右访问)。

       广度优先遍历各个节点，需要使用到队列（Queue）这种数据结构，queue的特点是先进先出，其实也可以使用双端队列，区别就是双端队列首位都可以插入和弹出节点。整个遍历过程如下：

      首先将A节点插入队列中，queue（A）;

      将A节点弹出，同时将A的子节点B，C插入队列中，此时B在队列首，C在队列尾部，queue（B，C）；

      将B节点弹出，同时将B的子节点D，E插入队列中，此时C在队列首，E在队列尾部，queue（C，D，E）;

      将C节点弹出，同时将C的子节点F，G，H插入队列中，此时D在队列首，H在队列尾部，queue（D，E，F，G，H）；

      将D节点弹出，D没有子节点，此时E在队列首，H在队列尾部，queue（E，F，G，H）；

      ...依次往下，最终遍历完成。

package BinaryTreeTraverseTest;  
  
import java.util.LinkedList;  
import java.util.Queue;  
  
/** 
 * 二叉树的深度优先遍历和广度优先遍历 
 * @author Fantasy 
 * @version 1.0 2016/10/05 - 2016/10/07 
 */  
public class BinaryTreeTraverseTest {  
    public static void main(String[] args) {  
          
    BinarySortTree<Integer> tree = new BinarySortTree<Integer>();  
          
        tree.insertNode(35);  
        tree.insertNode(20);  
        tree.insertNode(15);  
        tree.insertNode(16);  
        tree.insertNode(29);  
        tree.insertNode(28);  
        tree.insertNode(30);  
        tree.insertNode(40);  
        tree.insertNode(50);  
        tree.insertNode(45);  
        tree.insertNode(55);  
          
        System.out.print("先序遍历（递归）：");  
        tree.preOrderTraverse(tree.getRoot());  
        System.out.println();  
        System.out.print("中序遍历（递归）：");  
        tree.inOrderTraverse(tree.getRoot());  
        System.out.println();  
        System.out.print("后序遍历（递归）：");  
        tree.postOrderTraverse(tree.getRoot());  
        System.out.println();  
          
        System.out.print("先序遍历（非递归）：");  
        tree.preOrderTraverseNoRecursion(tree.getRoot());  
        System.out.println();  
        System.out.print("中序遍历（非递归）：");  
        tree.inOrderTraverseNoRecursion(tree.getRoot());  
        System.out.println();  
        System.out.print("后序遍历（非递归）：");  
        tree.postOrderTraverseNoRecursion(tree.getRoot());  
        System.out.println();  
          
        System.out.print("广度优先遍历：");  
        tree.breadthFirstTraverse(tree.getRoot());  
    }  
}  
  
/** 
 * 结点 
 */  
class Node<E extends Comparable<E>> {  
      
    E value;  
    Node<E> left;  
    Node<E> right;  
      
    Node(E value) {  
        this.value = value;  
        left = null;  
        right = null;  
    }  
      
}  
  
/** 
 * 使用一个先序序列构建一棵二叉排序树（又称二叉查找树） 
 */  
class BinarySortTree<E extends Comparable<E>> {  
      
    private Node<E> root;  
      
    BinarySortTree() {  
        root = null;  
    }  
      
    public void insertNode(E value) {     
        if (root == null) {  
            root = new Node<E>(value);  
            return;  
        }      
        Node<E> currentNode = root;  
        while (true) {  
            if (value.compareTo(currentNode.value) > 0) {  
                if (currentNode.right == null) {  
                    currentNode.right = new Node<E>(value);  
                    break;  
                }  
                currentNode = currentNode.right;  
            } else {  
                if (currentNode.left == null) {  
                    currentNode.left = new Node<E>(value);  
                    break;  
                }  
                currentNode = currentNode.left;  
            }  
        }  
    }  
      
    public Node<E> getRoot(){  
        return root;  
    }  
  
    /** 
     * 先序遍历二叉树（递归） 
     * @param node 
     */  
    public void preOrderTraverse(Node<E> node) {  
        System.out.print(node.value + " ");  
        if (node.left != null)  
            preOrderTraverse(node.left);  
        if (node.right != null)  
            preOrderTraverse(node.right);  
    }  
      
    /** 
     * 中序遍历二叉树（递归） 
     * @param node 
     */  
    public void inOrderTraverse(Node<E> node) {  
        if (node.left != null)  
            inOrderTraverse(node.left);  
        System.out.print(node.value + " ");  
        if (node.right != null)  
            inOrderTraverse(node.right);  
    }  
      
    /** 
     * 后序遍历二叉树（递归） 
     * @param node 
     */  
    public void postOrderTraverse(Node<E> node) {  
        if (node.left != null)  
            postOrderTraverse(node.left);  
        if (node.right != null)  
            postOrderTraverse(node.right);  
        System.out.print(node.value + " ");  
    }  
      
    /** 
     * 先序遍历二叉树（非递归） 
     * @param root 
     */  
    public void preOrderTraverseNoRecursion(Node<E> root) {  
        LinkedList<Node<E>> stack = new LinkedList<Node<E>>();  
        Node<E> currentNode = null;  
        stack.push(root);  
        while (!stack.isEmpty()) {  
            currentNode = stack.pop();  
            System.out.print(currentNode.value + " ");  
            if (currentNode.right != null)  
                stack.push(currentNode.right);  
            if (currentNode.left != null)  
                stack.push(currentNode.left);  
        }  
    }  
      
    /** 
     * 中序遍历二叉树（非递归） 
     * @param root 
     */  
    public void inOrderTraverseNoRecursion(Node<E> root) {  
        LinkedList<Node<E>> stack = new LinkedList<Node<E>>();  
        Node<E> currentNode = root;  
        while (currentNode != null || !stack.isEmpty()) {  
            // 一直循环到二叉排序树最左端的叶子结点（currentNode是null）  
            while (currentNode != null) {  
                stack.push(currentNode);  
                currentNode = currentNode.left;  
            }  
            currentNode = stack.pop();  
            System.out.print(currentNode.value + " ");  
            currentNode = currentNode.right;  
        }     
    }  
      
    /** 
     * 后序遍历二叉树（非递归） 
     * @param root 
     */  
    public void postOrderTraverseNoRecursion(Node<E> root) {  
        LinkedList<Node<E>> stack = new LinkedList<Node<E>>();  
        Node<E> currentNode = root;  
        Node<E> rightNode = null;  
        while (currentNode != null || !stack.isEmpty()) {  
            // 一直循环到二叉排序树最左端的叶子结点（currentNode是null）  
            while (currentNode != null) {  
                stack.push(currentNode);  
                currentNode = currentNode.left;  
            }  
            currentNode = stack.pop();  
            // 当前结点没有右结点或上一个结点（已经输出的结点）是当前结点的右结点，则输出当前结点  
            while (currentNode.right == null || currentNode.right == rightNode) {  
                System.out.print(currentNode.value + " ");  
                rightNode = currentNode;  
                if (stack.isEmpty()) {  
                    return; //root以输出，则遍历结束  
                }  
                currentNode = stack.pop();  
            }  
            stack.push(currentNode); //还有右结点没有遍历  
            currentNode = currentNode.right;  
        }  
    }  
      
    /** 
     * 广度优先遍历二叉树，又称层次遍历二叉树 
     * @param node 
     */  
    public void breadthFirstTraverse(Node<E> root) {  
        Queue<Node<E>> queue = new LinkedList<Node<E>>();  
        Node<E> currentNode = null;  
        queue.offer(root);  
        while (!queue.isEmpty()) {  
            currentNode = queue.poll();  
            System.out.print(currentNode.value + " ");  
            if (currentNode.left != null)  
                queue.offer(currentNode.left);  
            if (currentNode.right != null)  
                queue.offer(currentNode.right);  
        }  
    }  
      
}