代码随想录算法训练营第天十四天丨 二叉树part02

文档讲解：代码随想录

状态：已完成

二叉树层序遍历登场！

思路

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。

需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

使用队列实现二叉树广度优先遍历，动画如下：

这样就实现了层序从左到右遍历二叉树。

代码如下：这份代码也可以作为二叉树层序遍历的模板。

class Solution {
    public List> levelOrder(TreeNode root) {
        //定义一个集合，用于存放结果集
        List> result = new ArrayList<>();
        if (root == null) {return result;}

        //定义一个队列，用于层次遍历树
        LinkedList queue = new LinkedList();
        queue.add(root);

        while(!queue.isEmpty()){
            //用于存放每层的结果集
            List list = new ArrayList<>();
            //用于存储每层需要出队列的个数
            int size = queue.size();
            while (size > 0){
                size--;
                TreeNode cur = queue.peek();//拿到当前队头元素
                queue.pop();//弹出队头元素
                list.add(cur.val);//将当前弹出的结点放入集合中
                //将当前结点的左右子树放入队列中
                if (cur.left != null){
                    queue.add(cur.left);
                }
                if (cur.right != null){
                    queue.add(cur.right);
                }
            }
            //将每层遍历的结果集放入总结果集中
            result.add(list);
        }
        return result;
    }
}

---

226.翻转二叉树

思路

我们之前介绍的都是各种方式遍历二叉树，这次要翻转了，感觉还是有点懵逼。

这得怎么翻转呢？

如果要从整个树来看，翻转还真的挺复杂，整个树以中间分割线进行翻转，如图：

可以发现想要翻转它，其实就把每一个节点的左右孩子交换一下就可以了。

关键在于遍历顺序，前中后序应该选哪一种遍历顺序？ 

遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。

注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

这道题目使用前序遍历和后序遍历都可以，唯独【中序遍历】不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！建议拿纸画一画，就理解了

那么层序遍历也是可以的。

        只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！

#递归法

对于二叉树的递归法的前中后序遍历，卡哥已经在二叉树：前中后序递归遍历 (opens new window)详细讲解了。

我们下文以前序遍历为例，通过动画来看一下翻转的过程:

我们来看一下递归三部曲：

• 1.确定递归函数的参数和返回值

参数就是要传入节点的指针，不需要其他参数了，通常此时定下来主要参数，如果在写递归的逻辑中发现还需要其他参数的时候，随时补充。

返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为TreeNode*。

TreeNode* invertTree(TreeNode* root)

• 2.确定终止条件

当前节点为空的时候，就返回

if (root == NULL) return root;

• 3.确定单层递归的逻辑

因为是先前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树。

swap(root->left, root->right);
invertTree(root->left);
invertTree(root->right);

基于这递归三步法，代码基本写完，Java代码如下：

class Solution {
     public TreeNode invertTree(TreeNode root) {
        
        //reverse(TreeNode cur) 中的遍历顺序为中左右
        
        reverse(root);
        return root;
    }
    public void reverse(TreeNode cur){
        if (cur == null){return;}
        TreeNode temp = cur.left;
        cur.left = cur.right;
        cur.right = temp;
        reverse(cur.left);
        reverse(cur.right);
    }
}

总结

针对二叉树的问题，我们解题之前一定要想清楚究竟是前中后序遍历，还是层序遍历。

二叉树解题的大忌就是自己稀里糊涂的过了（因为这道题相对简单），但是也不知道自己是怎么遍历的。

这也是造成了二叉树的题目“一看就会，一写就废”的原因。

针对翻转二叉树，我给出了一种递归，三种迭代（两种模拟深度优先遍历，一种层序遍历）的写法，都是之前我们讲过的写法，融汇贯通一下而已。

我们一定也有自己的解法，但一定要成方法论，这样才能通用，才能举一反三！

---

101. 对称二叉树

思路

首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。

那么如何比较呢？

比较的是两个子树的里侧和外侧的元素是否相等。如图所示：

动态图如下：

那么遍历的顺序应该是什么样的呢？

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

但都可以理解算是后序遍历，尽管已经不是严格上在一个树上进行遍历的后序遍历了。

其实后序也可以理解为是一种回溯，当然这是题外话，讲回溯的时候会重点讲的。

说到这大家可能感觉我有点啰嗦，哪有这么多道理，上来就干就完事了。别急，我说的这些在下面的代码讲解中都有身影。

那么我们先来看看递归法的代码应该怎么写。

#递归法

递归三部曲

• 1.确定递归函数的参数和返回值

因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。

返回值自然是bool类型。

代码如下：

bool compare(TreeNode* left, TreeNode* right)

• 2.确定终止条件

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。

节点为空的情况有：（注意我们比较的其实不是左孩子和右孩子，所以如下我称之为左节点右节点）

• 左节点为空，右节点不为空，不对称，return false
• 左不为空，右为空，不对称 return false
• 左右都为空，对称，返回true

此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：

• 左右都不为空，比较节点数值，不相同就return false

此时左右节点不为空，且数值也不相同的情况我们也处理了。

代码如下：

if (left == NULL && right != NULL) return false;
else if (left != NULL && right == NULL) return false;
else if (left == NULL && right == NULL) return true;
else if (left->val != right->val) return false; // 注意这里我没有使用else

注意上面最后一种情况，我没有使用else，而是else if， 因为我们把以上情况都排除之后，剩下的就是 左右节点都不为空，且数值相同的情况。

• 3.确定单层递归的逻辑

此时才进入单层递归的逻辑，单层递归的逻辑就是处理 左右节点都不为空，且数值相同的情况。

• 比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
• 比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。
• 如果左右都对称就返回true ，有一侧不对称就返回false 。

代码如下：

bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
bool isSame = outside && inside;                    // 左子树：中、 右子树：中（逻辑处理）
return isSame;

如上代码中，我们可以看出使用的遍历方式，左子树左右中，右子树右左中，所以我把这个遍历顺序也称之为“后序遍历”（尽管不是严格的后序遍历）。

最后递归的Java整体代码如下：

class Solution {
   public boolean isSymmetric(TreeNode root) {
        if (root == null){return true;}
        //调用递归函数，比较左节点，右节点
        return dfs(root.left,root.right);
    }
    boolean dfs(TreeNode left,TreeNode right){
        //递归的终止条件是两个节点都为空
        if (left == null && right == null){
            return true;
        }
        //或者两个节点中有一个为空
        if (left == null || right == null){
            return false;
        }
        //或者两个节点的值不相等
        if (left.val != right.val){
            return false;
        }
        //再递归的比较 左节点的左孩子 和 右节点的右孩子
		//以及比较  左节点的右孩子 和 右节点的左孩子
        // 比较外侧
        boolean compareOutside = dfs(left.left, right.right);
        // 比较内侧
        boolean compareInside = dfs(left.right, right.left);
        return compareOutside && compareInside;
    }
}

---

以上为我做题时候的相关思路，自己的语言组织能力较弱，很多都是直接抄卡哥的，有错误望指正。