打卡第14天

打卡第14天

递归：

1. 确定递归函数的参数和返回值
2. 确定终止条件
3. 确定单层递归的逻辑

递归遍历

// 前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        preOrder(root,res);
        return res;
    }
    public void preOrder(TreeNode root,List<Integer> res){
        if (root == null) {
            return;
        }
        res.add(root.val);
        preOrder(root.left,res);
        preOrder(root.right,res);
    }
}

//后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        postOrder(root,res);
        return res;
    }

    public void postOrder(TreeNode root,List<Integer> res){
        if(root==null){
            return;
        }
        postOrder(root.left,res);
        postOrder(root.right,res);
        res.add(root.val);
    }
}

//中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root,res);
        return res;
    }

    public void inorder(TreeNode root,List<Integer> res){
        if(root==null){
            return;
        }
        inorder(root.left,res);
        res.add(root.val);
        inorder(root.right,res);
    }
}

迭代遍历

用一个栈实现迭代遍历。

// 前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null){
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        deque.push(root);
        while(!deque.isEmpty()){
            TreeNode temp = deque.pop();
            res.add(temp.val);
            // 先把右子节点加入栈，因为要先弹出左子节点
            if (temp.right != null){
                deque.push(temp.right);
            }
            if (temp.left != null){
                deque.push(temp.left);
            }
        }
        return res;
    }
}

// 后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null){
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        deque.push(root);
        while(!deque.isEmpty()){
            TreeNode temp = deque.pop();
            res.add(temp.val);
            // 前序遍历是中左右，后序遍历是左右中
            // 把前序的变成中右左，然后再反转一下即可得出后序遍历结果
            // 先把左子节点加入栈，因为要先弹出右子节点 
            if (temp.left != null){
                deque.push(temp.left);
            }
            if (temp.right != null){
                deque.push(temp.right);
            }
        }
        Collections.reverse(res);
        return res;
    }
}

//中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()){
           if (cur != null){
               stack.push(cur);
               cur = cur.left;
           }else{
               cur = stack.pop();
               result.add(cur.val);
               cur = cur.right;
           }
        }
        return result;
    }
}