训练营练习-Day15&二叉树2

二叉树层序遍历：借助队列实现 讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历_哔哩哔哩_bilibili

Leetcode 102 力扣

解法：迭代遍历，借助队列不断收取各层结果。

class Solution {

    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {

        //递归(root,0);

        迭代(root);

        return resList;

    }

       public void 迭代(TreeNode node) {

        if (node == null) return;

        Queue<TreeNode> que = new LinkedList<TreeNode>();

        que.offer(node);

        while (!que.isEmpty()) {

            List<Integer> itemList = new ArrayList<Integer>();

            int len = que.size();

            while (len > 0) {

                TreeNode tmpNode = que.poll();

                itemList.add(tmpNode.val);

                if (tmpNode.left != null) que.offer(tmpNode.left);

                if (tmpNode.right != null) que.offer(tmpNode.right);

                len--;

            }

            resList.add(itemList);

        }

    }

}

Leetcode 226 力扣

解法：后序或前序遍历。迭代法

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

迭代法

public TreeNode invertTree1(TreeNode root) {
    if (root == null){
        return null;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()){
        int size = queue.size();
        while (size-- >0){
            TreeNode poll = queue.poll();
            swap(poll);
            if (poll.left != null){
                invertTree1(poll.left);
            }
            if (poll.right != null){
                invertTree1(poll.right);
            }
        }
    }
    return root;
}

private void swap(TreeNode root) {
    TreeNode temp = root.left;
    root.left = root.right;
    root.right = temp;
}

Leetcode 101 力扣

解法：递归法

public boolean isSymmetric1(TreeNode root) {
    return compare(root.left, root.right);
}

private boolean compare(TreeNode left, TreeNode right) {
    if (left == null && right != null) {
        return false;
    }
    if (left != null && right == null) {
        return false;
    }
    if (left == null && right == null) {
        return true;
    }
    if (left.val != right.val) {
        return false;
    }
    // 比较外侧
    boolean compareOutside = compare(left.left, right.right);
    // 比较内侧
    boolean compareInside = compare(left.right, right.left);
    return compareOutside && compareInside;
}

迭代法：

public boolean isSymmetric3(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) {
            return false;
        }
        if (leftNode != null && rightNode == null) {
            return false;
        }
        if (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;
}