二叉树的遍历总结

二叉树的遍历

之前总结了leetcode上的一道中序遍历二叉树问题：
http://blog.csdn.net/xiaoxiaoxuanao/article/details/53113234

索性想了想不如直接将二叉树的所有遍历方式都总结一下，以便日后查看方便。递归方式不用过多说明，非递归方式除了层次遍历使用队列以外，其三种方式使用栈。

1 先序遍历
先序遍历是按照 根左右的顺序遍历二叉树

1.1 递归先序遍历

  public List<Integer> preOrderTraversalRecursion(TreeNode root) {
        if (root == null) {
            return result;
        }
        result.add(root.val);
        preOrderTraversalRecursion(root.left);
        preOrderTraversalRecursion(root.right);
        return result;
    }

1.2 非递归先序遍历

 public List<Integer> preOrderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                result.add(root.val);
                stack.push(root);
                root = root.left;
            }
            TreeNode treeNode = stack.pop();
            root = treeNode.right;
        }
        return result;
    }

2 中序遍历

2.1 递归中序遍历

   public List<Integer> inorderTraversalRecursion(TreeNode root) {
        if (root == null) {
            return result;
        }
        inorderTraversalRecursion(root.left);
        result.add(root.val);
        inorderTraversalRecursion(root.right);
        return result;
    }

2.2 非递归中序遍历

 public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            TreeNode treeNode = stack.pop();
            result.add(treeNode.val);
            root = treeNode.right;
        }
        return result;
    }

3 后序遍历

3.1 递归后序遍历

   public List<Integer> postOrderTraversalRecursion(TreeNode root) {
        if (root == null) {
            return result;
        }
        postOrderTraversalRecursion(root.left);
        postOrderTraversalRecursion(root.right);
        result.add(root.val);
        return result;
    }

3.2 非递归后序遍历

public static List<Integer> postOrderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            TreeNode node = stack.peek();
            TreeNode right = node.right;
            if (right == null) {
                stack.pop();
                result.add(node.val);
            }
            root = right;
        }
        return result;
    }

4 层次遍历

 public static List<Integer> levelTraversal(TreeNode root){
        List<Integer> result = Lists.newArrayList();
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null){
            return result;
        }
        queue.add(root);
        queue.add(null);
        TreeNode node = queue.poll();
        while(!queue.isEmpty()){
            if(node == null){
                queue.add(null);
                node = queue.poll();
                continue;
            }
            result.add(node.val);
            if(node.left != null){
                queue.add(node.left);
            }
            if(node.right != null){
                queue.add(node.right);
            }
            node = queue.poll();
        }
        return result;
    }