寒假算法打卡第十六天-CSDN博客

本文链接：https://blog.csdn.net/kavel_/article/details/136055060

学习目标：

第六章二叉树

层序遍历（自底向上）
翻转二叉树
对称二叉树

学习内容：

层序遍历二叉树（自底向上）

思路：采用层序遍历将结果存入数组最终将数组翻转即可

    /**
     * 解法：队列，迭代。
     * 层序遍历，再翻转数组即可。
     */
    //二叉树层序遍历自底向上
    public List<List<Integer>> solution1(TreeNode root) {
        List<List<Integer>> list = new ArrayList<>();
        Deque<TreeNode> que = new LinkedList<>();

        if (root == null) {
            return list;
        }

        que.offerLast(root);
        while (!que.isEmpty()) {
            List<Integer> levelList = new ArrayList<>();

            int levelSize = que.size();
            for (int i = 0; i < levelSize; i++) {
                TreeNode peek = que.peekFirst();
                levelList.add(que.pollFirst().val);

                if (peek.left != null) {
                    que.offerLast(peek.left);
                }
                if (peek.right != null) {
                    que.offerLast(peek.right);
                }
            }
            list.add(levelList);
        }

        List<List<Integer>> result = new ArrayList<>();
        for (int i = list.size() - 1; i >= 0; i-- ) {
            result.add(list.get(i));
        }

        return result;
    }

思路：采用层序遍历将结果存入链表，根节点最先插入链表，其他左右孩子依次插到其前面，也可以使用虚拟头结点做不断更新头结点的操作完成自底向上的层序遍历，无需翻转。

public List<List<Integer>> levelOrderBottom(TreeNode root) {
        // 利用链表可以进行 O(1) 头部插入, 这样最后答案不需要再反转
        LinkedList<List<Integer>> ans = new LinkedList<>();

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

        if (root != null) q.offer(root);

        while (!q.isEmpty()) {
            int size = q.size();

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

            for (int i = 0; i < size; i ++) {
                TreeNode node = q.poll();

                temp.add(node.val);

                if (node.left != null) q.offer(node.left);

                if (node.right != null) q.offer(node.right);
            }

            // 新遍历到的层插到头部, 这样就满足按照层次反序的要求
            ans.addFirst(temp);
        }

        return ans;
    }

翻转二叉树

思路：交换左右孩子的指针以完成翻转操作，可以采用前序和后序遍历，中序不行，因为先左孩子交换孩子，再根交换孩子（做完后，右孩子已经变成了原来的左孩子），再右孩子交换孩子（此时其实是对原来的左孩子做交换），也就是说一直操作的是原来的左孩子，原来的右孩子根本没有改变

   
public TreeNode invertTree(TreeNode root) {
        //思路：交换左右孩子的指针以完成翻转操作，可以采用前序和后序遍历
        //中序不行，因为先左孩子交换孩子，再根交换孩子（做完后，右孩子已经变成了原来的左孩子），再右孩子交换孩子（此时其实是对原来的左孩子做交换），也就是说一直操作的是原来的左孩子，原来的右孩子根本没有改变
        if (root == null) {
            return null;
        }
        invertTree(root.left);
        invertTree(root.right);
        swapChildren(root);
        return root;
    }

    private void swapChildren(TreeNode root) {
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }

对称二叉树

（1）递归法思路：通过翻转二叉树，比较左右指针对应的数值是否相同，外侧对外侧，内侧对内侧进行比较，若都相等则说明是对称二叉树采用后序遍历，因为是通过判断某一结点的左右子树是否相等才能比较数值的，若采用前序和中序遍历那么就会造成外侧或者内侧没有比较完成就得出结果的bug

（2）迭代法思路：利用双端队列，将左子树和右子树分别存在队列前头和队列后头，然后一一拿出数据进行比较

   
 /**
     * 递归法
     */
    public boolean isSymmetric1(TreeNode root) {
        //思路：通过翻转二叉树，比较左右指针对应的数值是否相同，外侧对外侧，内侧对内侧进行比较，若都相等则说明是对称二叉树
        //采用后序遍历，因为是通过判断某一结点的左右子树是否相等才能比较数值的，若采用前序和中序遍历那么就会造成外侧或者内侧没有比较完成就得出结果的bug
        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 isSymmetric2(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) {
//                return false;
//            }
//            if (leftNode != null && rightNode == null) {
//                return false;
//            }
//            if (leftNode.val != rightNode.val) {
//                return false;
//            }
            // 以上三个判断条件合并
            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;
    }