代码随想录打卡Day15| 二叉树 part02

不孑然一身

已于 2023-07-16 16:06:33 修改

阅读量114

点赞数

文章标签：数据结构算法

于 2023-07-14 08:44:59 首次发布

本文链接：https://blog.csdn.net/lionelwhl/article/details/131711480

版权

二叉树第二部分。

心得：层序遍历的各种变体，要灵活思维，翻转答案，保留不同的答案

实现二叉树的层序遍历，即广度优先遍历。

第一题：LeetCode 102 二叉树的层序遍历 https://leetcode.cn/problems/binary-tree-level-order-traversal/

使用层序遍历秒杀10道题：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                //size++; 这里并不需要加size，因为上一个while循环之内循环给size赋值了
                //换言之，size的个数就是本while的循环次数，循环完就应该出while了
                if(node->right) que.push(node->right);
                //size++;
            }
            res.push_back(vec);
        }
        return res;
    }
};

2、二叉树的层序遍历-2 https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/

精髓：将result数组翻转

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> res; //二维数组
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;//保存每一层元素值的一维数组
            while(size--){
                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);
            }
            res.push_back(vec);
        }
        reverse(res.begin(),res.end());
        return res;

    }
};

3、二叉树的右视图 https://leetcode.cn/problems/binary-tree-right-side-view/

精髓：保留每一层的最右边元素。

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        // 错误在于返回的是最右侧的右子节点，而不是站在右侧看得见的元素
        // queue<TreeNode*> que;
        // vector<int> res;
        // if(root != NULL) que.push(root);
        // while(!que.empty()){
        //     TreeNode* node = que.front();
        //     que.pop();
        //     res.push_back(node->val);              
        //     if(node->right) que.push(node->right);
        // }
        // return res;

        vector<int> res;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            //vector<int> vec;
            while(size--){
                TreeNode* node = que.front();
                que.pop();

                //if(size == 1) res.push_back(node->val);是0
                // 将每一层的最后元素放入result数组中
                if(size == 0) res.push_back(node->val);

                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
               
            }
            //res.push_back(vec);
        }
        return res;

    }
};

4、二叉树的层平均值 LeetCode637 https://leetcode.cn/problems/average-of-levels-in-binary-tree/

while里面不能用while，因为size要用来计算，不能变。

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            double sum = 0;
            //不能用while了，因为里面要用size进行计算
            // while(size--){
            //     TreeNode* node = que.front();
            //     que.pop();
            
            //     sum += node->val;

            //     if(node->left) que.push(node->left);            
            //     if(node->right) que.push(node->right);
            // }
            // //double b = a / size;
            // res.push_back(sum / size);
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            res.push_back(sum / size); // 将每一层均值放进结果集
        }
        return res;
    }
};

5、N叉树的层序遍历 LeetCode 429 https://leetcode.cn/problems/n-ary-tree-level-order-traversal/

每一层都遍历一边，用node->children.size()遍历，并注意：

//if(node->children(empty)) vec.push_back()；

//错误一：node不用empty，直接node->...就可以

//错误二：push的是que不是vec

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        //queue<TreeNode*> que;
        queue<Node*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size--){
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for(int i = 0; i < node->children.size(); i++){
                    //if(node->children(empty)) vec.push_back()；
                    //错误一：node不用empty，直接node->...就可以
                    //错误二：push的是que不是vec
                    if(node->children[i]) que.push(node->children[i]);
                }

            }
            res.push_back(vec);
        }
        return res;
    }
};

6、每个树行中找到最大值 LeetCode 515 https://leetcode.cn/problems/find-largest-value-in-each-tree-row/

注意：maxValue初始为INT_MIN

简化写法：maxValue = maxValue > node->val? maxValue : node->val;

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();//注意
            int maxValue = INT_MIN;
            //vector<int> vec;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                maxValue = maxValue > node->val? maxValue : node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);

            }

            res.push_back(maxValue);
        }
        return res;
    }
};

7、填充每一个节点的右侧结点指针 LeetCode116 https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/

在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了

class Solution {
public:
    Node* connect(Node* root) {
        //vector<vector<int>> res;
        queue<Node*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            //vector<int> vec;
            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; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                          
                if(node->left) que.push(node->left);            
                if(node->right) que.push(node->right);

            }
            nodePre->next = NULL;
        }
        return root;
    }
};

8、填充每个节点的右侧节点指针-2 LeetCode117 https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/

完全相同的方法。

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){
                    node = que.front();//这里和上一题的nodePre换一下也无所谓
                    que.pop();
                    nodePre = node;
                }
                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;
    }
};

9、二叉树的最大深度 LeetCode104 https://leetcode.cn/problems/maximum-depth-of-binary-tree/

二叉树的层数就是最大深度，记录一下第一个while的循环次数就可以了。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        int maxDepth = 0;
        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);
                //size++;
            }
            maxDepth++;
        }
        return maxDepth;
    }
};

10、二叉树的最小深度 LeetCode 111 https://leetcode.cn/problems/minimum-depth-of-binary-tree/

判断一个节点的左右孩子都为空的时候直接返回即可。

class Solution {
public:
    int minDepth(TreeNode* root) {       
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        int minDepth = 0;
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            minDepth++;
            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);
                if(node->left == NULL && node->right == NULL){
                    return minDepth;
                }
            }
            
            
        }
        return minDepth;
    }
};

第二题、LeetCode 226 翻转二叉树 https://leetcode.cn/problems/invert-binary-tree/

递归法：

注意，这里用前序后续的区别九十八swap放在前面还是后面，但是中序遍历除了要把swap放中间，还要注意swap完之后 left和right就反了，要把下一句的right改成left

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:
    TreeNode* invertTree(TreeNode* root) {
        //迭代法
        stack<TreeNode*> st;
        //vector<int> res;
        if(root != NULL) 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;
    }
};

统一迭代法：

注意：用迭代法其实都是再pop之后再swap的

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        //统一迭代
        stack<TreeNode* > st;
        //vector<int> res;
        if(root != NULL) st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            if(node != NULL){
                st.pop();
                //swap(node->left, node->right);
                if(node->right) st.push(node->right);//右
                if(node->left) st.push(node->left);//左
 
                st.push(node);//中
                st.push(NULL);             
            }
            else{
                st.pop();
                node = st.top();
                st.pop();
                swap(node->left, node->right);
                //res.push_back(node->val);
            }
        }
        return root; 

    }
};

层序遍历：

也是pop之后swap。

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

第三题、对称二叉树 LeetCode101 https://leetcode.cn/problems/symmetric-tree/

迭代法：使用后序，因为需要知道左右之后再来中，注意，迭代里不用val

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->val, right->right->val);//外侧
        //bool inside = compare(left->right->val, right->left->val);//内侧
        bool outside = compare(left->left, right->right);//外侧（左）
        bool inside = compare(left->right, right->left);//内侧（右）
        bool res = outside && inside;//中
        return res;
        }
    
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        return compare(root->left, root->right);
    
    }
};

不孑然一身

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
代码随想录打卡Day15| 二叉树 part02

心得：层序遍历的各种变体，要灵活思维，翻转答案，保留不同的答案。第一题：LeetCode 102 二叉树的层序遍历。6、每个树行中找到最大值 LeetCode 515。4、二叉树的层平均值 LeetCode637。5、N叉树的层序遍历 LeetCode 429。实现二叉树的层序遍历，即广度优先遍历。2、二叉树的层序遍历-2。
复制链接

扫一扫