【刷题】代码随想录算法训练营第十五天|层序遍历，226、翻转二叉树（优先掌握递归），101、对称二叉树（优先掌握递归）-优快云博客

本文链接：https://blog.youkuaiyun.com/npu_yuanfang/article/details/137858026

文章目录

层序遍历

讲解：https://programmercarl.com/0102.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86.html

在这里插入图片描述
广度优先遍历，一层一层的遍历输出。

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

二叉树的右视图

在这里插入图片描述
层序遍历每一次，保留最后一个节点。

/**
 * 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();
            TreeNode* tmp;
            for (int i=0;i<size;i++){
                tmp = que.front();
                que.pop();

                if(tmp->left) que.push(tmp->left);
                if(tmp->right) que.push(tmp->right);
            }
            result.push_back(tmp->val);
        }
        return result;
    }
};

N叉树遍历

注意children中是一个vector，看题解方式以后也多用auto和迭代器的写法吧。

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;

        if (!root) return res;

        vector<Node*> myQueue;
        myQueue.push_back(root);
        while (!myQueue.empty()) {
            vector<int> levelVal;
            vector<Node*> level;
            for (auto node : myQueue) {
                levelVal.push_back(node->val);
                for (auto child : node->children) {
                    if (child) {
                        level.push_back(child);
                    }
                }
            }
            res.push_back(levelVal);
            myQueue = level;
        }

        return res;
    }
};

填充每个节点的下一个右侧节点指针I&II

注意这题返回的应该是root节点，不要死记模版！

/*
// 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();
            for(int i=0;i<size;i++){
                Node* cur = que.front();
                que.pop();
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
                if (i==size-1){
                    cur->next = NULL;
                }
                else{
                    cur->next = que.front();
                }
            }
        }
        return root;
    }
};

二叉树的最小深度

注意三个if的关系，并不是if、else的非此即彼的关系。

/**
 * 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 minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if (root!=NULL) que.push(root);
        else return 0;
        int max_depth=10000;
        int min_depth=0;
        while(!que.empty()){
            int size=que.size();
            min_depth+=1;
            int flag = 0;
            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);
                if(!cur->left && !cur->right){flag = 1; break;};
            }
            if(flag==1) break;
        }
        if (min_depth>0) return min_depth;
        else return max_depth;
    }
};

226、翻转二叉树（优先掌握递归）

讲解：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html

在这里插入图片描述
递归yyds，写起来注意前面学的前中后三种顺序逻辑，在这里中序的逻辑有点问题，具体见卡尔哥的视频讲解，亲自画一下就知道了。

再回顾一下递归三部曲：

确定递归函数的参数和返回值
题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为TreeNode*。
确定终止条件
当前节点为空的时候，就返回：

if (root == NULL) return root;

确定单层递归的逻辑

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

下面是前序遍历的递归解法。

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

其余的迭代法（深度优先）、层序遍历（广度优先）见讲解。

101、对称二叉树（优先掌握递归）

讲解：https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html

这里用递归法还是简单，注意处理空的情况，防止空指针情况。

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 oputside = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        bool isSame = oputside && inside;
        return isSame;
    }

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