【代码随想录】day15

最新推荐文章于 2024-09-02 16:35:28 发布

weixin_47041555

最新推荐文章于 2024-09-02 16:35:28 发布

阅读量332

点赞数 7

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/weixin_47041555/article/details/136631044

版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

一、102层序遍历
二、107二叉树的层次遍历II
三、199二叉树的右视图
四、637二叉树的层平均值
五、429N叉树的层序遍历
六、515在每个树行中找最大值
七、116填充每个节点的下一个右侧节点指针
八、117填充每个节点的下一个右侧节点指针II
九、104二叉树的最大深度
十、111二叉树的最小深度
十一、226翻转二叉树
十二、101对称二叉树

一、102层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if (root == nullptr) return res;
        queue<TreeNode*> temp;
        temp.push(root);
        while (!temp.empty()) {
            int n = temp.size();
            vector<int> levelRes;
            while(n --) {
                TreeNode* node = temp.front();
                temp.pop();
                levelRes.push_back(node->val);
                if (node->left) temp.push(node->left);
                if (node->right) temp.push(node->right);
            }
            res.push_back(levelRes);
        }
        return res;
    }
};

二、107二叉树的层次遍历II

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> res;
        if (root == nullptr) return res;
        queue<TreeNode*> temp;
        temp.push(root);
        while (!temp.empty()) {
            int n = temp.size();
            vector<int> leverRes;
            while (n --) {
                TreeNode* node = temp.front();
                temp.pop();
                leverRes.push_back(node->val);
                if (node->left) temp.push(node->left);
                if (node->right) temp.push(node->right);
            }
            res.insert(res.begin(), leverRes);
        }
        return res;
    }
};

三、199二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> res;
        if (root == nullptr) return res;
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            int n = q.size();
            while (n --) {
                TreeNode* node = q.front();
                if (n == 0) res.push_back(node->val);
                q.pop();
                if (node->left) {
                    q.push(node->left);
                } 
                if (node->right) {
                    q.push(node->right);
                }
            }
        }
        return res;
    }
};

四、637二叉树的层平均值

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        queue<TreeNode*> q;
        q.push(root);
        while (! q.empty()) {
            int n = q.size();
            double count = 0;
            for (int i = 0; i < n; i ++) {
                TreeNode* node = q.front();
                q.pop();
                count += node->val;
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            res.push_back(count / n);
        }
        return res;
    }
};

五、429N叉树的层序遍历

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

六、515在每个树行中找最大值

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        if (root == nullptr) return res;
        queue<TreeNode*> q;
        q.push(root);
        while (! q.empty()) {
            int n = q.size();
            int num = q.front()->val;
            while (n --) {
                TreeNode* node = q.front();
                q.pop();
                if (node->val > num) num = node->val;
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            res.push_back(num);
        }
        return res;
    }
};

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

class Solution {
public:
    Node* connect(Node* root) {
        if (root == nullptr) return root;
        queue<Node*> q;
        q.push(root);
        while (! q.empty()) {
            int n = q.size();
            Node* node;
            Node* nodePre;
            for (int i = 0; i < n; i ++) {
                if (i == 0) {
                    nodePre = q.front();
                    q.pop();
                    node = nodePre;
                }
                else {
                    node = q.front();
                    q.pop();
                    nodePre->next = node;
                    nodePre = node;
                }
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            node->next = nullptr;
        }
        return root;
    }
};

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

class Solution {
public:
    Node* connect(Node* root) {
        if (root == nullptr) return root;
        queue<Node*> q;
        q.push(root);
        while (!q.empty()) {
            int n = q.size();
            Node* node;
            Node* nodePre;
            for (int i = 0; i < n; i ++) {
                if (i == 0) {
                    nodePre = q.front();
                    q.pop();
                    node = nodePre;
                }
                else {
                    node = q.front();
                    q.pop();
                    nodePre->next = node;
                    nodePre = node;
                }
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            nodePre->next = nullptr;
        }
        return root;
    }
};

九、104二叉树的最大深度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int depth = 0;
        if (root == nullptr) return depth;
        queue<TreeNode*> q;
        q.push(root);
        while (! q.empty()) {
            int n = q.size();
            while (n --) {
                TreeNode* node = q.front();
                q.pop();
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            depth ++;
        }
        return depth;
    }
};

十、111二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        int res = 0;
        if (root == nullptr) return res;
        queue<TreeNode*> q;
        q.push(root);
        while (! q.empty()) {
            int n = q.size();
            while (n --) {
                TreeNode* node = q.front();
                q.pop();
                if (node->left == nullptr && node->right == nullptr) return res + 1;
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            res ++;
        }
        return res;
    }
};

十一、226翻转二叉树

做出来了，但感觉有一定的运气成分在。。。

class Solution {
public:
    TreeNode* invert(TreeNode* node) {
        if (node == nullptr) {
            return node;
        }
        TreeNode* temp = node->left;
        node->left = invert(node->right);
        node->right = invert(temp);
        return node;
    }
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) return root;
        return invert(root);
    }
};

自己写的太复杂了，优化版：

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

迭代法：

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

十二、101对称二叉树

感觉这个recur写的很麻烦。。

class Solution {
public:
    bool recur(TreeNode* left, TreeNode* right) {
        if (left == nullptr && right == nullptr) {
            return true;
        }
        if (left == nullptr || right == nullptr || left->val != right->val) {
            return false;
        }
        if (left->left == nullptr && left->right == nullptr && right->left == nullptr && right->right == nullptr) {
            return true;
        }
        return recur(left->right, right->left) && recur(left->left, right->right);
    }
    bool isSymmetric(TreeNode* root) {
        if (root->left == nullptr && root->right == nullptr) {
            return true;
        }
        return recur(root->left, root->right);
    }
};