二叉树的遍历

二叉树的类定义如下：

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> res = new ArrayList<>();
    public List<Interger> preorderTraversal(TreeNode root) {
        traversal(root);
        return res;
    }
    
    public void traversal(TreeNode root){
        if(root!=null){
            res.add(root.val);
            traversal(root.left);
            traversal(root.right);
        }
    }
}

非递归实现

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

步骤：首先将根节点加入List，然后不断向左遍历，同时将每一步的根节点都入栈，直到遍历空结点。然后调用stack.pop()将之前遍历的根节点弹出，同时然后找到弹出的根节点的右子结点，然后对其进行先序遍历。以此类推。

中序遍历

递归实现

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Interger> preorderTraversal(TreeNode root) {
        traversal(root);
        return res;
    }
    
    public void traversal(TreeNode root){
        if(root!=null){
            traversal(root.left);
            res.add(root.val);
            traversal(root.right);
        }
    }
}

非递归实现

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

步骤：这里与先序遍历不同的是，在根节点从栈中弹出时，才将其值加入到List。

后序遍历

递归实现

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Interger> preorderTraversal(TreeNode root) {
        traversal(root);
        return res;
    }
    
    public void traversal(TreeNode root){
        if(root!=null){
            traversal(root.left);
            traversal(root.right);
            res.add(root.val);
        }
    }
}

非递归实现

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

思路：后序遍历是先遍历左子树和右子树，再遍历中间节点。因此在stack.pop()时有两种情况：

• 访问完了右子树，所以需要将中间结点加入List。（包括右子树为空的情况）
• 还没有访问完右子树，而是在深度优先进入左子树时返回，因此下一步需要遍历右子树。

因此，需要使用一个lastVisit来指示上一个访问的结点。每次查看栈顶元素，如果其右子树和上一个访问的结点相同，即node.right == null|| node.right == lastVisit时，输出node。否则进入右子树。即，每次进入if这个代码块时，都是要输出某个子树的中间结点。