数据结构之二叉树的遍历

二叉树的遍历是指按照某条搜索路径访问树中的每个节点，使得每个节点的均只被访问一次。由二叉树的递归定义，遍历一棵二叉树便要决定对根节点、左子树和右子树的访问顺序。常见的遍历次序有先序遍历、中序遍历和后序遍历。其中序指的是根节点在何时被访问。

1. 先序遍历(PreOrder)：若二叉树非空，则先访问根节点，再访问左子树，最后访问右子树。

2. 中序遍历(InOrder)：若二叉树非空，则先访问左子树，再访问根节点，最后访问右子树。

3. 后序遍历(PostOder)：若二叉树非空，则先访问左子树，再访问右子树，最后访问根节点。

节点结构如下：

/**
 * 二叉树节点结构
 * Created by Administrator on 2017/5/2 0002.
 */
public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int x){
        this.val = x;
    }
}

自定义节点处理函数：

/*对每个节点进行处理*/
public static void process(int v){
    System.out.println(v);
}

先序遍历

/*递归形式*/
public static void preOrder(TreeNode root){
        if(root == null){
            return;
        }
        process(root.val);
        preOrder(root.left);
        preOrder(root.right);
    }

//非递归形式，借助栈
    public static void preOrder2(TreeNode root) {

        if (root == null) {
            return;
        }

        Stack<TreeNode> stack = new Stack<>();

        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                print(root.val);
                stack.push(root);
                root = root.left;
            }

            if (!stack.isEmpty()) {
                root = stack.peek();
                stack.pop();
                root = root.right;
            }
        }
    }

中序遍历

/*递归形式*/
public static void inOrder(TreeNode root){
    if(root == null){
        return;
    }
    if(root.left != null){
        inOrder(root.left);
    }
    process(root.val);
    if(root.right != null){
        inOrder(root.right);
    }    
}

/*非递归形式*/
public static void inOrder(TreeNode root){
    if(root == null){
        return;
    }
    Stack<TreeNode> st = new Stack<TreeNode>();
    st.push(root);
    TreeNode tmp;
    while (!st.empty()){
        tmp = st.peek();
        while (tmp != null){
            st.push(tmp.left);
            tmp = tmp.left;
        }
        if(tmp == null){
            st.pop();
        }
        if(!st.empty()) {
            tmp = st.pop();
            process(tmp.val);
            st.push(tmp.right);
        }
    }
}

后序遍历

/*递归形式*/
public static void postOrder(TreeNode root){
    if(root == null){
        return;
    }
    if(root.left != null){
        postOrder(root.left);
    }
    if(root.right != null){
        postOrder(root.right);
    }
    process(root.val);
}

/*后序非递归形式*/
public static void postOrder(TreeNode root){
   if (root == null) {
            return;
        }

        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = root;
        //最后访问的节点
        TreeNode lastVisit = root;
        while (node != null || !stack.isEmpty()) {

            //左子树入栈
            while (node != null) {
                stack.push(node);
                node = node.left;
            }

            //查看当前栈顶元素
            node = stack.peek();

            //如果其右子树也为空，或者右子树已经访问
            //则可以直接输出当前节点的值
            if (node.right == null || node.right == lastVisit) {
                print(node.val);
                stack.pop();
                lastVisit = node;
                node = null;
            } else {
                //否则遍历右子树
                node = node.right;
            }
        }
}