LeetCode 每日一题144：二叉树的前序遍历

144.二叉树的前序遍历

给定一个二叉树，返回它的 前序 遍历。

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

前序遍历、中序遍历、后序遍历请参考：https://blog.csdn.net/qq_27007509/article/details/109311381

节点类如下：

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;
    }
}

递归

List<Integer> res = new ArrayList<>();
public List<Integer> preorderTraversal1(TreeNode root) {
    preOrder(root);
    return res;
}
public void preOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    res.add(root.val);
    preOrder(root.left);
    preOrder(root.right);
}

迭代

迭代本质上和递归是一样的，区别在于递归的时候隐式地维护了一个栈，而我们在迭代的时候需要显式地将这个栈模拟出来。

分享2种迭代的写法：

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

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

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：36.3 MB, 在所有 Java 提交中击败了99.36%的用户

递归和迭代的时间复杂度都为：O(N)，空间复杂度都为：O(N)。

有一种进阶的写法：Morris 遍历。时间复杂度O(N)，空间复杂度降为O(1)。
别问怎么写，问就是，还不会！