万人千题计划 - 38

推荐社区：万人千题

前言

已经按照英雄哥给的路子走了有差不多两个月了，可以自己上路了，所以在为自己查漏补缺，如果英雄哥给的题目是我之前做过的，搞懂了的，我就不会再写题解了，我需要刷一些我还不太熟练的。下面的题目除了最后一题，都是有模板的，你们仔细看就能找出模板，我不贴出来，你们自己找

二叉树的前序遍历

思路：递归+深度优先遍历

class Solution {
public:
    void dfs(TreeNode* cur, vector<int>& vec) {
        if(cur == nullptr) {
            return;
        }
        vec.push_back(cur->val);//中
        dfs(cur->left, vec);//左
        dfs(cur->right, vec);//右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        dfs(root, res);
        return res;
    }
};

二叉树的中序遍历

class Solution {
public:
    void dfs(TreeNode* cur, vector<int>& vec) {
        if(cur == nullptr) return;
        dfs(cur->left, vec);
        vec.push_back(cur->val);
        dfs(cur->right, vec);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        dfs(root, res);
        return res;
    }
};

二叉树的后序遍历

class Solution {
public:
    void dfs(TreeNode* cur, vector<int>& vec) {
        if(cur == nullptr) return;
        dfs(cur->left, vec);
        dfs(cur->right, vec);
        vec.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        dfs(root, res);
        return res;
    }
};

二叉树的层序遍历

思路：队列+广度优先

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != nullptr) que.push(root);
        vector<vector<int>> res;
        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);
            }
            res.push_back(vec);
        }
        return res;
    }
};

二叉树的右视图
递归：先交换左右孩子节点，再反转左子树，反转右子树

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

迭代法

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

二叉树的最大深度

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

翻转二叉树

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

划分字母区间

思路：找到每个字符最后一次出现位置的下标，并将它们存储起来
后面再找到尽可能多的最大不相交的子区间，返回每个区间的长度即可
刚做这题，我是真看不懂题目的意思，我看了半天别人的题解，还是没看懂啥意思，最后我去B站找，看有没有人录制他们解题的全过程，我好看懂题目的意思，最后找到了一个up主，要是你们还是没看懂题目意思的话，可以去看他的视频，只要能把题目意思搞懂，写起来也就不难了

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int last[26] = {0};//存储26个字母
        int size = s.size();
        vector<int> res;//存储长度

        for(int i=0; i<size; ++i) {
        	//存储每个字符最后一次出现的下标
            last[s[i] - 'a'] = i;
        }

        int start = 0, end = 0;
        for(int i=0; i<size; ++i) {
            end = max(end , last[s[i] - 'a']);
            if(i == end) {
                res.push_back(end - start +1);
                start = end + 1;
            }
        }
        return res;
    }
};

结语

这些题目有的是我之前尝试过，但是没做出来的；有的是我查漏补缺时发现我不会做的，总之是我自己不太会的题目，之所以刷二叉树系列，是因为，他能很好的建立一个知识体系，前中后的遍历，层次遍历等等…一次只做一件事，把它弄懂，做好，今天的收获就有了，这些题目我都是错了又错，写了再写，写的时候真的很绝望，但是你要当程序员，总归是要面对这些挫折和挑战的，你总要去把它们解决的，不要推迟时间，说什么下次一定，我们要的就是当前，要做就是这次一定，不要等到真正需要你这门能力去养家糊口的时候，你还在那里hello,world!，那我就真没话讲了