《录鼎记》第十三章——有史最长篇

本文链接：https://blog.csdn.net/qq_56013387/article/details/129846633

今日内容：

层序遍历 10

226.翻转二叉树

101.对称二叉树 2

一、二叉树的层序遍历

思路一：队列实现，将根节点推入，之后在队列非空时，记录一层中的元素数量，然后遍历将该节点的值记录在vec中，左右子节点送入队列，等待下一次循环，直到队列为空——即层序遍历完毕。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
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;
            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;

    }
};

思路二：递归法,主要还是按之前讲的三步走，确定参数：层级遍历，要有节点，要有存节点的容器，要有层数（用于记录存放在容器的哪一层）

终止条件即为节点为空

中间则为先是在容器大小等于深度时，创建新的一层，然后是将该节点存入对应层，将左右子节点放入函数中。

主函数则是递归函数的入口，最后返回容器result。

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

    }
};
控制台

二、层次遍历II

力扣题目链接 (opens new window)

此题仅为将结果用reverse反转

 reverse(result.begin(), result.end());

三、二叉树的右视图

力扣题目链接 (opens new window)

思路：本体就是一个变形，指在遍历到该层最后一个节点的时候返回到结果中。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        vector<int> result;
        while(!que.empty()){
            int size =que.size();
            for(int i =0;i<size;i++){
               TreeNode* node =que.front();
               que.pop(); 
               if(i==size-1) result.push_back(node->val);
               if(node->left) que.push(node->left);
               if(node->right) que.push(node->right);
            }
            

        }
        return result;

    }
};

四、二叉树的层平均值

力扣题目链接 (opens new window)

思路：此题也是一个变型，就是将一层所有元素相加后除元素数量就可以，但要注意变量类型

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        vector<double> result;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size =que.size();
            double sum =0;
            for(int i=0;i<size;i++){
                TreeNode* cur =que.front();
                que.pop();
                sum+=cur->val;
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            result.push_back(sum/size);
        }
        return result;

    }
};

五、n叉树层序遍历

力扣题目链接 (opens new window)

本题和首题是差不多的，就是需要遍历多个孩子节点

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        if(root!=NULL) que.push(root);
        vector<vector<int>> result;
        while(!que.empty()){
            int size =que.size();
            vector<int> vec;
            for(int i=0;i<size;i++){
                Node* node =que.front();
                que.pop();
                vec.push_back(node->val);
                for(int j=0;j<node->children.size();j++){
                    if(node->children[j]) que.push(node->children[j]);
                }
            }
            result.push_back(vec);
        }
        return result;
        
    }
};

六、在每个树行找最大值

力扣题目链接 (opens new window)

思路：这题也是变形，只需要逐个比较，将最后的值插入。

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> result;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size =que.size();
            int max1 =INT_MIN;
            for(int i=0;i<size;i++){
                TreeNode* cur =que.front();
                que.pop();
                max1 = max(max1,cur->val);
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            result.push_back(max1);
        }
        return result;

    }
};

需要注意max初始值不能取0。

七、填充每个节点的下一个右侧节点指针

力扣题目链接 (opens new window)

思路：需要把每一层的第一个节点拿出做头节点，最后将最后一个节点指向空，中间为前节点的指针指向现节点，现节点变为了前节点。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size =que.size();
            Node* Nodepre;
            Node* node;
            for(int i=0;i<size;i++){
                if(i==0){
                    Nodepre=que.front();
                    que.pop();
                    node=Nodepre;
                }
                else{
                    node =que.front();
                    que.pop();
                    Nodepre->next=node;
                    Nodepre=Nodepre->next;

                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            Nodepre->next=NULL;
            

         }
        return root;
    }
};

八、填充每个节点的下一个右侧节点指针||

力扣题目链接 (opens new window)

虽然由完美二叉树变味了二叉树，但代码和逻辑没有区别

九、二叉树的最大深度

力扣题目链接 (opens new window)

思路：也为变形，每次从队列中取一列的时候深度加一

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int result=0;
        if(root!=NULL){
            que.push(root);
            
        }
        while(!que.empty()){
            int size = que.size();
            result++;
            for(int i=0;i<size;i++){
                TreeNode* cur =que.front();
                que.pop();
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);

            }
        }
        return result;

    }
};

十、二叉树的最小深度

力扣题目链接 (opens new window)

需要注意的是只有左右孩子均为空才为最小

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int result=0;
        if(root!=NULL){
            que.push(root);
            
        }
        while(!que.empty()){
            int size = que.size();
            result++;
            for(int i=0;i<size;i++){
                TreeNode* cur =que.front();
                que.pop();
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);

            }
        }
        return result;

    }
};

十一、翻转二叉树

力扣题目链接 (opens new window)

题目虽然简单但也考基础

递归三部曲：

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

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

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

TreeNode* invertTree(TreeNode* root)

确定终止条件

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

if (root == NULL) return root;

确定单层递归的逻辑

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

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

class Solution {
public:
    void fanzhuan(TreeNode* node){
        if(node==NULL) return;
        swap(node->left,node->right);
        fanzhuan(node->left);
        fanzhuan(node->right);
    }
    TreeNode* invertTree(TreeNode* root) {
        fanzhuan(root);
        return root;

    }

有1说1，我写的比题解复杂多了。其实这道题也可以用深度和广度优先算法做

深度前序（非统一）：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==NULL) return root;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            swap(node->left,node->right);
            if(node->left) st.push(node->left);
            if(node->right) st.push(node->right);
        }
        return root;

    }
};

统一写法前序深度：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root!=NULL) st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            if(node!=NULL){
                st.pop();
                if(node->left) st.push(node->left);
                if(node->right) st.push(node->right);
                st.push(node);
                st.push(NULL);
            }
            else{
                st.pop();
                node = st.top();
                st.pop();
                swap(node->left,node->right);
            }
        }
    return root;
    }
};

广度优先：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0;i<size;i++){
                TreeNode* node = que.front();
                que.pop();
                swap(node->left,node->right);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
 
    }
};

由于迭代中序使用栈处理，左右节点在翻转前压入了栈，所以避免了翻转两次的情况。

而递归需要两次遍历左孩子，为避免翻转两次、

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        invertTree(root->left);         // 左
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 注意 这里依然要遍历左孩子，因为中间节点已经翻转了
        return root;
    }
};

十二、对称二叉树

力扣题目链接 (opens new window)

递归三部曲：

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

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

返回值自然是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;

整体代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool issame(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 =issame(left->left,right->right);
        bool inside =issame(left->right,right->left);
        bool isss =outside&&inside;
        return isss;

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

    }
};

使用队列：是将两侧对称放入队列再取出进行比较，有不一样返回false，到最后都相同返回true

使用栈：和队列相同

东西很多，花了两小时。还是要重视基础啊

题解：代码随想录代码随想录

代码随想录