二叉树的先序、中序、后序遍历-递归and非递归版本

package com.gc.study.art;

import java.util.ArrayList;
import java.util.List;

/**
 * 树的前序、中序、后序遍历
 * @author gc
 *      1
 *   2         3
 * 4   5  6   7
 * 
 * 先序遍历：1 2 4 5 3 6 7
 * 中序遍历：4 2 5 1 6 3 7
 * 后序遍历：4 5 2 6 7 3 1
 */
public class TreePost {
    public static void main(String[] args) {
        TreePost tree = new TreePost();

        
        List<Integer> rs = new ArrayList<Integer>();
        tree.pre(tree.getRoot(), rs);
        System.out.println("先序遍历(递归版本)：" + rs);
        
        rs.clear();
        tree.mid(tree.getRoot(), rs);
        System.out.println("中序遍历(递归版本)：" + rs);
        rs.clear();
        tree.post(tree.getRoot(), rs);
        System.out.println("后序遍历(递归版本)：" + rs);
        
        System.out.println("先序遍历：" + tree.preorderTraversal(tree.getRoot()));
        System.out.println("中序遍历：" + tree.inorderTraversal(tree.getRoot()));
        System.out.println("后序遍历：" + tree.postorderTraversal(tree.getRoot()));

    }

    /**
     * 构造测试数据
     * 
     * @return
     */
    public TreeNode getRoot() {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(7);
        return root;
    }

    /**
     * 先序遍历
     * 思想：先左后又，左到低，右取1不丢弃,入队列时取其值（入队列的数据正好符合先序遍历）
     * @param root
     * @return
     */
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> rs = new ArrayList<Integer>();
        if (root == null) {
            return rs;
        }
        List<TreeNode> nodes = new ArrayList<TreeNode>();
        nodes.add(root);
        TreeNode cur = root;
        rs.add(cur.val);
        while (cur != null) {
            //一直遍历，直到把最左边的数据加到数组中（同时打印加入的节点）
            while (cur.left != null) {
                nodes.add(cur.left);
                cur.left = null;
                cur = nodes.get(nodes.size() - 1);
                rs.add(cur.val);
            }
            //将当前节点的右节点加到数组中（并且可以打印当前节点的值）
            if (cur.right != null) {
                nodes.add(cur.right);
                cur.right = null;
                cur = nodes.get(nodes.size() - 1);
                rs.add(cur.val);
            } else {
                //当前节点没有右节点，直接移除
                nodes.remove(cur);
            }
            
            cur = getLast(nodes);

        }
        return rs;
    }

    /**
     * 中序遍历
     * 思想：先左后右，左到低，右取1不丢弃，出队列时取其值（取值并移除）
     * @param root
     * @return
     */
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> rs = new ArrayList();
        if (root == null) {
            return rs;
        }
        List<TreeNode> nodes = new ArrayList<TreeNode>();
        nodes.add(root);
        TreeNode cur = root;
        while (cur != null) {
            while (cur.left != null) {
                nodes.add(cur.left);
                cur.left = null;
                cur = getLast(nodes);
            }

            rs.add(cur.val);
            nodes.remove(cur);

            if (cur.right != null) {
                nodes.add(cur.right);
                cur.right = null;
                cur = getLast(nodes);
            } 
            
            cur = getLast(nodes);
        }
        return rs;
    }

    /**
     * 迭代算法
     * 思想：先左后右，左到低，孩子为空取其值（取值并移除）
     * @param root
     * @return
     */
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> rs = new ArrayList<Integer>();
        if (root == null) {
            return rs;
        }
        List<TreeNode> nodes = new ArrayList<TreeNode>();
        nodes.add(root);
        TreeNode cur = root;

        while (cur != null) {

            while (cur.left != null) {
                nodes.add(cur.left);
                cur.left = null;
                cur = nodes.get(nodes.size() - 1);
            }

            if (cur.right != null) {
                nodes.add(cur.right);
                cur.right = null;
                cur = nodes.get(nodes.size() - 1);
            }

            if (cur.left == null && cur.right == null) {
                rs.add(cur.val);
                nodes.remove(cur);
                cur = getLast(nodes);
            }

        }
        return rs;
    }
    
    /**
     * 先序遍历递归版本
     * @param node
     * @param rs
     */
    public void pre(TreeNode node, List<Integer> rs) {
        if(node == null) {
            return;
        }
        rs.add(node.val);
        pre(node.left, rs);
        pre(node.right, rs);
    }
    /**
     * 中序遍历递归版本
     * @param node
     * @param rs
     */
    public void mid(TreeNode node, List<Integer> rs) {
        if(node == null) {
            return;
        }
        mid(node.left, rs);
        rs.add(node.val);
        mid(node.right, rs);
    }
    /**
     * 后续遍历递归版本
     * @param node
     * @param rs
     */
    public void post(TreeNode node, List<Integer> rs) {
        if(node == null) {
            return;
        }
        post(node.left, rs);
        post(node.right, rs);
        rs.add(node.val);
    }
    /**
     * 获取上一个节点
     * 
     * @param nodes
     * @return
     */
    private TreeNode getLast(List<TreeNode> nodes) {
        if (nodes.size() > 0) {
            return nodes.get(nodes.size() - 1);
        } else {
            return null;
        }
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }

        @Override
        public String toString() {
            // TODO Auto-generated method stub
            return String.valueOf(val);
        }
    }
}