Leecode.102 二叉树的层序遍历、Leecode.226 翻转二叉树、Leecode.101 对称二叉树 | 代码随想录训练营第15天

Leecode.102 二叉树的层序遍历

这里将代码随想录上的10道相同类型题在力扣上都做完了，没有写题解，大同小异。

题目链接：二叉树的层序遍历

思路

两种方法：递归和迭代法，递归法要用到树的高度，迭代法要用到队列。

复杂度

• 时间复杂度:

O(n)

• 空间复杂度:

O(n)

Code

//迭代法
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            List<Integer> list = new ArrayList<>();
            int len = queue.size();
            while(len > 0){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
                len--;
            }
            result.add(list);
        }
        return result;
    }
}
//递归法
class Solution {
    List<List<Integer>> result = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        recurse(root, 0);
        return result;
    }
    private void recurse(TreeNode root, int deep){
        if(root == null){
            return;
        }
        deep++;
        if(result.size() < deep){
            List<Integer> list = new ArrayList<>();
            result.add(list);
        }
        result.get(deep-1).add(root.val);
        recurse(root.left, deep);
        recurse(root.right, deep);
    }
}

Leecode.226 翻转二叉树

题目链接：翻转二叉树

思路

这道题在遍历顺序的选择上十分多样，遍历顺序分为前、中、后序遍历和层序遍历，此题的中序遍历不能直接用，否则会翻转多次同一个节点造成错误。
前序和后序遍历道理是一样的，分为递归法和迭代法，还有层序遍历法。

复杂度

• 时间复杂度:

O(n)

• 空间复杂度:

O(n)

Code

//前序遍历的递归法
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        swap(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
    private void swap(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}
//前序遍历的迭代法
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            swap(node);
            if(node.right != null){
                stack.push(node.right);
            }
            if(node.left != null){
                stack.push(node.left);
            }
        }
        return root;
    }
    private void swap(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}
//层序遍历
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int len = queue.size();
            while(len > 0){
                TreeNode node = queue.poll();
                swap(node);
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
                len--;
            }
        }
        return root;
    }
    private void swap(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

Leecode.101 对称二叉树

题目链接：对称二叉树

思路

这道题用三种解法
一、第一种是递归法，判断一棵树是否为对称二叉树，就看树节点的左右节点是否对称，所以递归的参数是左右子节点，这种递归的关键在于如何判断终止条件，有四种终止状态：
1.两节点都为空，返回true；
2.左节点为空，右节点不为空，返回false；
3.右节点为空，左节点不为空，返回false；
4.在判断完上述条件后，只能是两节点都不为空，此时判断节点值是否相等，不相等返回false；
做完这些工作后开始理顺单层递归的逻辑，要用左节点的左子节点和右节点的右子节点比较，用左节点的右子节点和右节点的左子节点比较，最终返回这两个比较的与值。
二、第二、三种是使用队列来比较两个树（根节点的左右子树）是否相互翻转，即迭代法：
首先是用双端队列，从队列的两头同时使用，相当于用了两个栈，将左右子节点分别两头放入队列中，再弹出，判断刚才的那四种终止状态，若没有终止，则将左右节点的四个子节点放入队列，关键在于放入的顺序，因为每次循环是从左右分别 拿出一个节点，所以要将左节点的左子节点和右节点的右子节点同时两端放入，左节点的右子节点和右节点的左子节点同时两端放入。
其次是使用普通队列，区别在于一次取出两个值，因此不同点在于四个子节点的放入顺序，要将左节点的左子节点和右节点的右子节点同时一起放入，左节点的右子节点和右节点的左子节点同时一起放入。

复杂度

• 时间复杂度:

O(n)

• 空间复杂度:

O(n)

Code

//递归法
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return isSym(root.left, root.right);
    }
    private boolean isSym(TreeNode nodeA, TreeNode nodeB){
        if(nodeA == null && nodeB != null){
            return false;
        }
        if(nodeA != null && nodeB == null){
            return false;
        }
        if(nodeA == null && nodeB == null){
            return true;
        }
        if(nodeA.val != nodeB.val){
            return false;
        }
        return isSym(nodeA.left, nodeB.right) && isSym(nodeA.right, nodeB.left);
    }
}
//双端队列的迭代法
class Solution {
    public boolean isSymmetric(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offerFirst(root.left);
        deque.offerLast(root.right);
        while (!deque.isEmpty()) {
            TreeNode leftNode = deque.pollFirst();
            TreeNode rightNode = deque.pollLast();
            if (leftNode == null && rightNode == null) {
                continue;
            }
            if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
                return false;
            }
            deque.offerFirst(leftNode.left);
            deque.offerFirst(leftNode.right);
            deque.offerLast(rightNode.right);
            deque.offerLast(rightNode.left);
        }
        return true;
    }
}
//普通队列的迭代法
class Solution {
    public boolean isSymmetric(TreeNode root) {
        Queue<TreeNode> deque = new LinkedList<>();
        deque.offer(root.left);
        deque.offer(root.right);
        while (!deque.isEmpty()) {
            TreeNode leftNode = deque.poll();
            TreeNode rightNode = deque.poll();
            if (leftNode == null && rightNode == null) {
                continue;
            }
            if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
                return false;
            }
            // 这里顺序与使用Deque不同
            deque.offer(leftNode.left);
            deque.offer(rightNode.right);
            deque.offer(leftNode.right);
            deque.offer(rightNode.left);
        }
        return true;
    }
}