二叉树的四种遍历方式（前序、中序、后序、层序）

二叉树的定义(LeetCode给出)

144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历
102. 二叉树的层序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

前序遍历（根、左、右）

• 递归方式前序遍历，第一次碰到树的根节点，首先将根节点的值添加到结果中，然后递归调用前序遍历左子树，最后递归调用右子树。

class Solution {
    List<Integer> ans = new LinkedList();
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root==null)  return ans;
        ans.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        return ans;
    }
}

• 迭代方式前序遍历，

  初始化堆栈

  1. 将root入栈，将值添加到结果中；
  2. 如果 node 的左子树非空，将左子树赋给root,重复步骤1直至左子树为空；
  3. 若堆栈非空，弹出最上面的节点赋值给root，若root右子树非空，将右子树赋给root，重复步骤1，2；
  4. 若root为空且堆栈为空结束循环

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new LinkedList();
        Deque<TreeNode> Tree = new LinkedList();
        while(root!=null||!Tree.isEmpty()){
            while(root!=null){
                ans.add(root.val);
                Tree.addFirst(root);
                root=root.left;
            }
            if(!Tree.isEmpty()){
                root = Tree.removeFirst();
                root = root.right;
            }
        }
        return ans;
    }
}

中序遍历（左、根、右）

• 递归方式同前序，仅调整添加结果的顺序

class Solution {
    List<Integer> result = new LinkedList();
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root!=null){
            inorderTraversal(root.left);
            result.add(root.val);
            inorderTraversal(root.right);
        }
        return result;
    }
}

• 迭代方式同前序，仅调整添加结果的顺序

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new LinkedList();
        Deque<TreeNode> deque = new LinkedList();
        while(root!=null||!deque.isEmpty()){
            while(root!=null){
                deque.addFirst(root);
                root=root.left;
            }
            if(!deque.isEmpty()){
                root = deque.removeFirst();
                ans.add(root.val);
                root = root.right;
            }
        }
        return ans;
    }
}

后序遍历（左、右、根）

• 递归方式同前序，仅调整添加结果的顺序

class Solution {
    List<Integer> ans = new LinkedList();
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root!=null){
            postorderTraversal(root.left);
            postorderTraversal(root.right);
            ans.add(root.val);
        }
        return ans;
    }
}

• 迭代方式

初始化堆栈，初始化一个prev节点

1. 将root入栈
2. 若root左子树非空，将左子树赋给root，重复步骤1
3. 弹出栈顶节点赋值给root，若子树右节点为空或右节点为prev（说明此节点的右节点已被遍历），将此节点的值添加到结果中。否则将此节点压回堆栈（因为此节点的右节点还未遍历到，不能添加到结果中），并将root的右节点赋给root
4. 重复步骤1，2，3

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList();
        Deque<TreeNode> stack = new LinkedList();
        TreeNode prev = null;
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            root=stack.pop();
            if(root.right==null||root.right==prev){
                ans.add(root.val);
                prev = root;
                root=null;
            }else{
                stack.push(root);
                root=root.right;
            }
        }
        return ans;
    }
}

层序遍历

层序遍历使用队列，初始化队列

1. 首先获取队列的长度，此长度为这一层的节点数
2. 循环长度次，取出这一层的所有节点，将这些节点的值添加到temp中（这一层的所有节点值），每取出一个节点，将其非空子节点添加到队列中，最后将temp添加到ans中（所有层的结果）

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new LinkedList();
        if(root==null)  return ans;
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int queueSize = queue.size();
            List<Integer> temp = new LinkedList();
            for(int i=0;i<queueSize;i++){
                TreeNode node = queue.poll();
                temp.add(node.val);
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            ans.add(temp);
        }
        return ans;
    }
}