LeetCode 二叉树的遍历

LeetCode 二叉树的遍历

树的定义：

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

迭代

前序遍历的顺序是根左右，所以每经过一个根节点，就要将其加入结果中，同时前序遍历的遍历顺序是先走左子树，直到走到NULL，这时需要利用栈，将栈顶元素弹出，遍历栈顶元素的右子树。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stk = new ArrayDeque<>();
        
        while (!stk.isEmpty() || root != null) {
            while (root != null) {
                res.add(root.val);
                stk.addFirst(root);
                root = root.left;
            }
            root = stk.removeFirst().right;
        }
        return res;
    }
}

中序遍历

递归

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

迭代

一直向二叉树的左子树遍历，每经过一个节点就将其入栈，直到走到NULL的时候停止循环。

之后就是出栈操作，将出栈的元素的值加入到结果中，同时去遍历出栈的这个元素的右子树。

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stk = new ArrayDeque<>();
        while (!stk.isEmpty() || root != null) {
            while (root != null) {
                stk.addFirst(root);
                root = root.left;
            }
            TreeNode tmp = stk.removeFirst();
            res.add(tmp.val);
            root = tmp.right;
        }
        return res;
    }
}

后序遍历

递归

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

迭代

这里是一个投机取巧的方法，与前序遍历迭代时类似，最后反转list集合即可。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stk = new ArrayDeque<>();
        while (!stk.isEmpty() || root != null) {
            while (root != null) {
                res.add(root.val);
                stk.addFirst(root);
                root = root.right;
            }
            root = stk.removeFirst().left;
        }
        Collections.reverse(res);
        return res;
    }
}