2022.3.12 力扣144，145，94，102

学习二叉树

follow：代码随想录

---

二叉树的递归遍历

递归三要素：
**1. 确定递归的参数和返回值：**确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
**2. 确定终止条件：**操作系统使用栈的结构来保存每一层递归的信息
**3. 确定单层递归的逻辑：**确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

144.二叉树的前序遍历

递归法：

/**
 * 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> result = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        traversal(root);
        return result;
    }

    public void traversal(TreeNode node){
        if(node != null){
            result.add(node.val);
            traversal(node.left);
            traversal(node.right);
        }
    }
}

迭代法：因为入栈（访问）的顺序就是遍历的顺序，所以可以直接使用栈

/**
 * 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 {
    public List<Integer> postorderTraversal(TreeNode root) {
         List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

统一迭代法：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        //统一迭代法
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        if(root != null) stack.addFirst(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.removeFirst();
            if(node != null){
                if(node.right != null) stack.addFirst(node.right);
                if(node.left != null) stack.addFirst(node.left);
                stack.addFirst(node);
                stack.addFirst(null);
            }else{
                //只有遇到了null 才能输出null下面的元素
                node = stack.removeFirst();
                result.add(node.val);
            }
        }
        return result;

    }
}

145 二叉树的后序遍历

递推法：

/**
 * 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> result = new ArrayList<>();

    public List<Integer> postorderTraversal(TreeNode root) {
        traversal(root);
        return result;
    }

    public void traversal(TreeNode node){
        if(node != null){
            traversal(node.left);
            traversal(node.right);
            result.add(node.val);
        }
    }
}

迭代法：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> myStack = new LinkedList<>();
        TreeNode pre = null;
        while(root != null || !myStack.isEmpty()){
            //遍历左侧
            while(root != null){
                myStack.addFirst(root);
                root = root.left;
            }
            root = myStack.peekFirst();
            //右侧
            if(root.right != null && root.right != pre){
                root = root.right;
            }else{
                //中
                result.add(root.val);
                myStack.removeFirst();
                pre = root;
                root = null;
            }
        }
        return result;
    }
}

统一迭代法

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        //统一迭代法
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        if(root != null) stack.addFirst(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.removeFirst();
            if(node != null){
                stack.addFirst(node);
                stack.addFirst(null);
                if(node.right != null) stack.addFirst(node.right);
                if(node.left != null) stack.addFirst(node.left);   
            }else{
                //只有遇到了null 才能输出null下面的元素
                node = stack.removeFirst();
                result.add(node.val);
            }
        }
        return result;
    }
}

94 二叉树的中序遍历

递归法：

/**
 * 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> result = new ArrayList<>();

    public List<Integer> inorderTraversal(TreeNode root) {
        traversal(root);
        return result;
    }

    public void traversal(TreeNode node){
        if(node != null){
            traversal(node.left);
            result.add(node.val);
            traversal(node.right);
        }
    }
}

迭代法：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        //迭代算法
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> myStack = new LinkedList<>();;
        while(root != null || !myStack.isEmpty()){
            //直到找到最底层的left
            while(root != null){
                myStack.addFirst(root);
                root = root.left;
            }

            //遍历：中->右
            root = myStack.removeFirst();
            result.add(root.val);
            root = root.right;
        }

        return result;
    }
}

统一迭代法

public List<Integer> inorderTraversal(TreeNode root) {
        //统一迭代算法
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        if(root != null) stack.addFirst(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.removeFirst();
            if(node != null){
                if(node.right != null) stack.addFirst(node.right);
                stack.addFirst(node);
                stack.addFirst(null);
                if(node.left != null) stack.addFirst(node.left);
            }else{
                //只有遇到了null 才能输出null下面的元素
                node = stack.removeFirst();
                result.add(node.val);
            }
        }
        return result;
    }

102 二叉树层序遍历

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Deque<TreeNode> queue = new LinkedList<>();
        if(root != null) queue.offerLast(root); 
        while(!queue.isEmpty()){
            int len = queue.size();
            List<Integer> element = new ArrayList<>();
            //每层进行处理
            while(len > 0){
                TreeNode node = queue.pollFirst();
                element.add(node.val);
                if(node.left != null) queue.offerLast(node.left);
                if(node.right != null) queue.offerLast(node.right);
                len--;
            }
            result.add(element);
        } 
        return result;
    }
}