代码随想录算法训练营DAY15|C++二叉树Part.2|102.二叉树的层序遍历、226.翻转二叉树、101. 对称二叉树

文章目录

102.二叉树的层序遍历
- 思路
- 伪代码
- - 迭代法
  - 递归法
- CPP代码
- 拓展题
226.翻转二叉树
- 思路
- CPP代码
[101. 对称二叉树](#101. 对称二叉树)
- 伪代码
- CPP代码

102.二叉树的层序遍历

力扣题目链接

文章讲解：102.二叉树的层序遍历

视频讲解：讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历

状态：能够回忆起来层序遍历是利用队列、然后用size来进行每一层应该弹出的元素个数。如果栈空了，循环结束，但是代码上怎么也写不完整；递归法的层序遍历还是有理解难度的，处理逻辑是配合depth的前序遍历。

思路

广度优先搜索来遍历一个二叉树，就是从左到右一层一层得去遍历二叉树。

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

在每个结点进行结果处理，也就是弹出队列放入结果集的时候，把它的左右孩子入栈

伪代码

迭代法

层序遍历的迭代法很简单

cpp 复制代码

queue<TreeNode*> que;//一定要注意这里放入的是结点
vector<vector<int>> res;
if (root) que.push(root);
while (!st.empty()){
  int size = que.size(); //记录本层应该弹出的元素
  vector<int> vec; //用来临时存放该层的结果
  for (int i = 0; i < size; i++){
    TreeNode* node = que.front;
    que,pop();
    res.push_back(node->val);
    if(node->left) que.push(node->left); // 空结点不入队
    if(node->right) que.push(node->right); //空结点不如队
  }
  result.push_back(res);
}
return result;

递归法

由于其并不是把当前层遍历完再去遍历下一层的规则，所以层序遍历的递归法总体还是比较难懂的。

其实递归法本质上还是先一直到底，然后再往上返回，用树结构来理解递归会好很多；

还有一个重点就是它的处理逻辑很像中左右的前序遍历。

确定参数和返回值：传参可以确定三个，结点信息、结果集、当前的深度（用于确定当前节点应该放在结果向量的哪个层次中）。其中结果集用引用传递，这样返回值可以为空。

cpp 复制代码

void order(TreeNode* node, vector<int>& vec, vector<vector<int>>& res){
  
}

确定终止条件：如果遇到结点为空，退出迭代。

cpp 复制代码

if (cur == nullptr) return;	//这是递归的基本情况

单层递归逻辑:将当前节点的值cur->val添加到对应深度的向量中；递归地对左子节点和右子节点调用order函数，深度参数depth加一。

cpp 复制代码

//如果result向量的大小等于当前deth，意味着我们第一次访问这个深度的结点。则在result中添加一个新的空向量，为这个深度的结点做准备
if (result.size() == depth) result.push_back(vector<int>());
result[depth].push_back(cur->val);	//放入当前结点
order(cur->left, result, depth + 1);//往左遍历
order(cur->right, result, depth + 1);//往右遍历

CPP代码

cpp 复制代码

#迭代法
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

#递归法
class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth)
    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

拓展题

226.翻转二叉树

力扣题目链接

文章讲解：226.翻转二叉树

视频讲解：听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树

状态：对于二叉树的题，往往会涉及到遍历顺序，此题要求反转二叉树，也就每个结点的左右孩子进行反转，最直观的应该当属前序遍历或者后序遍历。

思路

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

返回值本来是不需要的，但是题目中要求给出返回root结点的指针，我们就直接使用题目定义好的函数。

cpp 复制代码

TreeNode* invertTree(TreeNode* root)

确定终止条件

当前结点为空就返回即可

cpp 复制代码

if (root == NULL) return root;

确定单层递归的逻辑

前序遍历，先交换左右孩子结点，然后反转左子树和右子树。

cpp 复制代码

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

CPP代码

cpp 复制代码

# 直接使用题目定义好的函数
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};

# 再开一个递归函数
class Solution {
public:
  	void reverse(TreeNode* cur){
      if (cur == NULL) return;
      swap(cur->left, cur->right);
      reverse(cur->left);
      reverse(cur->right);
    }	
  
    TreeNode* invertTree(TreeNode* root) {
        reverse(root) 
        return root;
    }
};

101. 对称二叉树

力扣题目链接

文章讲解：101. 对称二叉树

视频讲解：同时操作两个二叉树 | LeetCode：101. 对称二叉树

状态：只能说大致思路蒙对了，从根结点的左右子树去遍历。但是具体细节压根都想不明白。还是没搞清楚二叉树遍历的本质。

二叉树类的题目，确定遍历深度是非常重要的，决定了我们对题目理解的深度。

这道题目只能使用后序，即左右中，因为我们要不断收集左右孩子的信息，返回给上一个结点，如此循环，我们才能知道以左结点为根结点的树和以右结点为根结点的树是否是相互翻转的。因为只有后序遍历，我们才能把底部孩子是否相等的信息返回给上一层。

使用的遍历方式，左子树左右中，右子树右左中，所以我把这个遍历顺序也称之为"后序遍历"（尽管不是严格的后序遍历）。

这样遍历主要是因为，左子树的左侧对应右子树的右侧，左子树的右侧对应右子树的左侧

直接上伪代码！

伪代码

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

返回值自然是bool类型。

cpp 复制代码

bool compare(TreeNode* left, TreeNode* right){
  
}

确定终止条件：只关注不满足条件的情况

左空，右不空；右空，左不空；左右都空，对称；左右都不空，但是结点数值不相等；

cpp 复制代码

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

确定单层递归逻辑：

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

cpp 复制代码

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

CPP代码

cpp 复制代码

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        // 首先排除空节点的情况
        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;

        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
        bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return isSame;

    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};