【代码随想录训练营】Day15-二叉树

代码随想录训练营 Day15

今日任务

102.二叉树的层序遍历
226.翻转二叉树
101.对称二叉树

102. 二叉树的层序遍历

链接：https://leetcode.cn/problems/binary-tree-level-order-traversal/
迭代（借助队列）

/**
 * 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<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if(root == null){
            return result;
        }
        queue.offer(root);
        int size = queue.size();
        while(!queue.isEmpty()){
            List<Integer> temp = new ArrayList<Integer>();
            size = queue.size();
            while(size-- > 0){
                TreeNode cur = queue.poll();
                temp.add(cur.val);
                if(cur.left != null){
                    queue.offer(cur.left);
                }
                if(cur.right != null){
                    queue.offer(cur.right);
                }
            }
            result.add(temp);
        }
        return result;
    }
}

递归

class Solution {
    public void order(TreeNode cur, List<List<Integer>> result, int depth){
        if(cur == null){
            return;
        }
        depth++;
        //避免使用get函数时出现越界错误
        if(result.size() < depth){
           List<Integer> temp = new ArrayList<Integer>();
           result.add(temp); 
        }
        result.get(depth - 1).add(cur.val);
        order(cur.left, result, depth);
        order(cur.right, result, depth);
    }
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if(root == null){
            return result;
        }
        order(root, result, 0);
        return result;
    }
}

226. 翻转二叉树

链接：https://leetcode.cn/problems/invert-binary-tree/
递归

/**
 * 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 void invert(TreeNode cur){
        if(cur == null){
            return;
        }
        TreeNode temp = cur.left;
        cur.left = cur.right;
        cur.right = temp;
        invert(cur.left);
        invert(cur.right);
    }
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return root;
        }
        invert(root);
        return root;
    }
}

深度优先遍历（中序遍历的统一迭代法）

class Solution {
    public TreeNode invertTree(TreeNode root) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        if(root == null){
            return root;
        }
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode cur = stack.peek();
            if(cur != null){
                stack.pop();
                if(cur.right != null){
                    stack.push(cur.right); //右
                }
                stack.push(cur); //根
                stack.push(null);
                if(cur.left != null){
                    stack.push(cur.left); //左
                }
            }
            //遍历到根节点，就交换左右孩子
            //从下到上交换
            else{
                stack.pop();
                cur = stack.pop();
                TreeNode temp = cur.left;
                cur.left = cur.right;
                cur.right = temp;
            }
        }
        return root;
    }
}

广度优先遍历（层序遍历）

class Solution {
    public TreeNode invertTree(TreeNode root) {
        //每一层反转每个节点的左右孩子
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null){
            return root;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode cur = queue.poll();
            TreeNode temp = cur.left;
            cur.left = cur.right;
            cur.right = temp;
            if(cur.left != null){
                queue.offer(cur.left);
            }
            if(cur.right != null){
                queue.offer(cur.right);
            }
        }
        return root;
    }
}

101. 对称二叉树

链接：https://leetcode.cn/problems/symmetric-tree/
递归

/**
 * 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 {
    //直接用传进来的节点比较，因为要比较val，所以要保证不会传入两个null
    public boolean mySymmetric(TreeNode node1, TreeNode node2){
        if(node1 == null && node2 != null){
            return false;
        }
        else if(node1 != null && node2 == null){
            return false;
        }
        else if(node1 == null && node2 == null){
            return true;
        }
        else if(node1.val != node2.val){
            return false;
        }
        boolean b1 = mySymmetric(node1.left, node2.right);
        boolean b2 = mySymmetric(node1.right, node2.left);
        if(b1 == false || b2 == false){
            return false;
        }
        return true;
    }
    public boolean isSymmetric(TreeNode root) {
        //[1, 1000]
        if(root.left == null && root.right == null){
            return true;
        }
        return mySymmetric(root.left, root.right);
    }
}

迭代法（队列）
按层遍历，非层序遍历

class Solution {
    public boolean isSymmetric(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root.left);
        queue.offer(root.right);
        while(!queue.isEmpty()){
            TreeNode node1 = queue.poll();
            TreeNode node2 = queue.poll();
            //遍历到最下面一层，略过此次循环
            if(node1 == null && node2 == null){
                continue;
            }
            //只有一个节点为null or 值不相等
            if(node1 == null || node2 == null || (node1.val != node2.val)){
                return false;
            }
            queue.offer(node1.left);
            queue.offer(node2.right);
            queue.offer(node1.right);
            queue.offer(node2.left);
        }
        return true;
    }
}

迭代法（栈）
和队列一个思路，就是入栈顺序和入队列顺序不同

class Solution {
    public boolean isSymmetric(TreeNode root) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root.left);
        stack.push(root.right);
        while(!stack.isEmpty()){
            TreeNode node1 = stack.pop();
            TreeNode node2 = stack.pop();
            //遍历到最下面一层，略过此次循环
            if(node1 == null && node2 == null){
                continue;
            }
            //只有一个节点为null or 值不相等
            if(node1 == null || node2 == null || (node1.val != node2.val)){
                return false;
            }
            //和队列相比就是颠倒了下顺序
            stack.push(node2.left);
            stack.push(node1.right);
            stack.push(node2.right);
            stack.push(node1.left);
        }
        return true;
    }
}