LeetCode刷题总结C++-树篇（上）

最新推荐文章于 2024-08-11 23:14:44 发布
最新推荐文章于 2024-08-11 23:14:44 发布
阅读量1.3k 收藏 5
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/panxiying1993/article/details/107982825
版权

LeetCode刷题C++总结-树篇（上）

      引子：刷题的过程可能是枯燥的，但程序员们的日常确不乏趣味。分享一则LeetCode上名为《打家劫舍 |||》题目的评论：

      如有兴趣可以从此题为起点，去LeetCode开启刷题之旅，哈哈。该题目是选择一颗二叉树中对应节点的问题，也是本文收录的一道例题（具体请参考例12）。

      本文开始分享作者对于LeetCode上有关树的刷题总结。谈到树，很多初学者会感觉很头疼。头疼的重点是其很多解法都离不开递归（或者说是深度优先搜索）的应用。而递归的难点在于其有很多返回值，对于这些返回值的顺序很难理顺，即代码虽短，但理解很烧脑。因此，对递归思想理解不够深的同学，建议先看作者的另一篇文章《LeetCode刷题总结-递归篇》，然后再开启攻克有关树的相关习题之旅（PS：这样会起到事半功倍的效果噢）。

      在LeetCode的标签分类题库中，和树有关的标签有：树（123道题）、字典树（17道题）、线段树（11道题）、树状数组（6道题）。对于这些题，作者在粗略刷过一遍后，对其中的考点进行了总结，并归纳为以下四大类：

      • 树的自身特性
      • 树的类型
      • 子树问题
      • 新概念定义问题

      对于上述四类考点，作者通过分析对比同类型考点的题目，选取其中比较经典或者有代表性的题目作为例题（共计收录约45道题）。在减少题量的同时，也希望能够全面覆盖LeetCode上关于树的相关习题的考点。作者计划分为三篇文章来讲解，本文是该系列的上篇，讲解考察树的自身特性相关考点的习题。选取的例题共21道，其中简单题5道、中等题13道、困难题3道。

      关于树的自身特性总结归纳为四个问题：基本特性问题、构造问题、节点问题和路径问题，具体如下所示。

 

树基本特性问题：请参考下文例1至例8。

树的构造问题：请参考下文例9、例10。

树的节点问题：请参考下文例11至例16。

树的路径问题：请参考下文例17至例21。

       对于上述四个问题，基本特性和构造问题只需刷过一遍即可理解相关解法。对于树的节点和路径问题，则是本文例题中的相对困难的习题，一般需要重复刷或者深度分析和琢磨，才能感悟普适解法的套路。其中，在有关树的路径问题中，本文未收录树的前、中、后和层次遍历问题的习题，这些题目默认为较为基础的习题。

例1 对称二叉树

题号：101，难度：简单

题目描述：

 

解题思路：

递归思想的一个简单应用，从以树的根节点的左右子节点为根开始进行深度优先搜索，依次判断两颗子树的左子树是否更与其右子树，右子树是否等于其左子树即可。如果采用迭代则只需使用层次遍历，判断每层元素是否满足镜像对称即可。

具体代码：

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {  
        if(root == NULL)
            return true;
        return dfs(root->left, root->right);
    }

    bool dfs(TreeNode* left, TreeNode* right) {
        if(left == NULL && right == NULL) return true;
        if(left == NULL || right == NULL || left->val != right->val) return false;
        return dfs(left->left, right->right) && dfs(left->right, right->left);
    }
};

 

运行结果：

 

例2 翻转二叉树以匹配前序遍历

题号：971，难度：中等（关于翻转类习题，还可以参考题号226和951）

题目描述：

 

解题思路：

该题也是递归思想的应用。按照题目要求进行前序遍历，一旦遇到对应值与目标数组结果不同时，翻转遍历，接着继续遍历，如果最终结果依然不匹配则返回false，否则返回true。

具体代码：

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
    int cur = 0;
    vector<int> flips;
    bool dfs(TreeNode * root, vector<int> & v) {
        if (!root) return true;
        if (root->val != v[cur++])
            return false;

        TreeNode * l = root->left, * r = root->right;
        if (l && r && l->val != v[cur]) {
            swap(l, r);
            flips.push_back(root->val);
        }

        return dfs(l, v) && dfs(r, v);
    }
    vector<int> flipMatchVoyage(TreeNode* root, vector<int>& voyage) {
        bool match = dfs(root, voyage);
        return match && cur == voyage.size() ? flips : vector<int>({-1});
    }
};

 

运行结果：

 

例3 输出二叉树

题号：655，难度：中等

题目描述：

 

解题思路：

此题是要求以二维数组的形式画出给定的二叉树。需要建立一个以根节点为原点的平面直角坐标系，然后依据广度优先搜索（即层次遍历）的思想依次初始化每层数组中元素的值即可，其中应用到了二分查找来确定每个元素的具体坐标，能够有效降低检索时间。

具体代码：

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<string>> printTree(TreeNode* root) {
        bool next = true;
        vector<vector<TreeNode*>> Tree;
        vector<TreeNode*> row;
        vector<TreeNode*> update;
        row.push_back(root);
        while(next) {
            next = false;
            Tree.push_back(row);
            for(int i=0;i<row.size();i++) {
                if(row[i] == NULL) {
                    update.push_back(NULL);
                    update.push_back(NULL);
                } else {
                    next = true;
                    update.push_back(row[i]->left);
                    update.push_back(row[i]->right);
                }
            }
            row = update;
            update.clear();
        }
        Tree.erase(Tree.begin()+Tree.size()-1);
        int s = 2*Tree[Tree.size()-1].size()-1;
        vector<vector<string>> print;
        int b = 0;
        for(int i=0;i<Tree.size();i++) {
            vector<string> p(s,"");
            print.push_back(p);
        }
        for(int i = 0;i<Tree.size();i++) {
            for(int j=0;j<Tree[i].size();j++) {
                b = pow(2,Tree.size()-i-1)-1;
                if(Tree[i][j] != NULL)
                    print[i][b + (b+1)*2*j] = to_string(Tree[i][j]->val);
            }
        }    
        return print;
    }
};
结果：

 

例4 合并二叉树

题号：617，难度：简单

题目描述：

 

解题思路：

此题比较简单，选取其中一个根节点作为返回值的根节点。然后应用深度优先搜索的思想，采用相同顺序同时遍历两棵树，如果当前节点均存在则相加，否则则选取含有值的节点。

具体代码：

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if(t1 == NULL)
            return t2;
        else if(t2 == NULL)
            return t1;
        t1->left = mergeTrees(t1->left, t2->left);
        t1->right = mergeTrees(t1->right, t2->right);
        t1->val = t1->val + t2->val;    
        return t1;
    }
};

 

运行结果:

 

例5 二叉树剪枝

题号：814，难度：中等（另外，还可以参考题号669，修剪二叉搜索树）

题目描述：

 

解题思路：

此题属于二叉树节点删除问题的实际应用，并且结合深度优先搜索（前序遍历的应用）和回溯的思想。具体实现过程请参考下方代码。

具体代码：

 

/**
 * 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:
    TreeNode* pruneTree(TreeNode* root) {
        if(root == nullptr)
            return root;
        if(root->val == 0 && root->left == nullptr && root->right == nullptr)
            root = root->left;
        else {
            root->left = pruneTree(root->left);
            root->right = pruneTree(root->right); 
        }   
        
        if(root != nullptr && root->val == 0 && root->left == nullptr && root->right == nullptr)
            root = root->left;
        return root;
    }       
};

 

运行结果：

 

例6 二叉树的右视图

题号：199，难度：中等

题目描述：

 

解题思路：

层次遍历的实际应用。只需依次保存每层最右边的一个节点即可。

具体代码：

 

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

 

运行结果：

 

例7 二叉树的最小深度

题号：111，难度：简单（最大深度请参考题号：104）

题目描述：

 

解题思路：

深度优先搜索的应用，代码很简洁，这个思想可以借鉴。

具体代码：

 

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == NULL)
            return 0;
        if(root->left != NULL && root->right != NULL)
            return 1 + min(minDepth(root->left), minDepth(root->right));
        else 
            return 1 + minDepth(root->right) + minDepth(root->left);
    }        
};

运行结果：

 

例8 二叉树的最大宽度

题号：662，难度：中等（另外，可参考题号：543，二叉树的直径）

题目描述：

 

解题思路：

层次遍历的实际应用，依次更新每层最大宽度即可。

具体代码：

/**
 * 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 widthOfBinaryTree(TreeNode* root) {
        if (!root) return 0;
        queue<pair<TreeNode*, unsigned long long>> q;
        int ans = 1;
        q.push({root, 1});
        while (!q.empty()) {
            int sz = q.size();
            ans = max(int(q.back().second - q.front().second + 1), ans);
            for (int i=0; i < sz; i++) {
                TreeNode *node = q.front().first;
                unsigned long long pos = q.front().second;
                q.pop();
                if (node->left) q.push({node->left, 2 * pos});
                if (node->right) q.push({node->right, 2 * pos + 1});
            }
        }
        return ans;
    }
};

 

 

 

运行结果：

 

例9 依据前序和后序遍历构造二叉树

题号：889，难度：中等（另外，可参考同类型习题，题号：105，106，1008）

题目描述：

 

解题思路：

可以先手动构造画以下，体会其中的构造规则，然后采用深度优先搜索的思想来实现。每次找到当前子树的根节点，并确定左右子树的长度，并不断递归遍历构造即可。

具体代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int preIndex = 0, posIndex = 0;
    TreeNode* constructFromPrePost(vector<int>& pre, vector<int>& post) {
        TreeNode* root = new TreeNode(pre[preIndex++]);
        if (root->val != post[posIndex])
            root->left = constructFromPrePost(pre, post);
        if (root->val != post[posIndex])
            root->right = constructFromPrePost(pre, post);
        posIndex++;
        return root;
    }
};

 

 

 

运行结果：

 

例10 从先序遍历还原二叉树

题号：1028，难度：困难

题目描述：

 

解题思路：

定义一个全局变量用于确定当前深度优先遍历元素处在左子树还是右子树，能够有效减少代码量，并提高代码的可阅读性。

具体代码：

 

class Solution {
    int i = 0;  // 神来之笔， 定义全局变量i，可以有效区分左子树和右子树
    
    public TreeNode recoverFromPreorder(String s) {
        return buildtree(s,0);
    }

    public TreeNode buildtree(String s,int depth){
        if(i == s.length()) return null;
        TreeNode cur = null; 
        int begin = i;
        while(s.charAt(begin) == '-')  begin ++;
        int end = begin;
        while(end < s.length() && s.charAt(end) - '0' >= 0 && s.charAt(end) - '0' < 10) end ++;
        if(begin - i == depth){
            cur = new TreeNode(Integer.valueOf(s.substring(begin,end)));
            i = end;
        }
        if(cur != null){
            // System.out.println("dep = "+depth+", cur = "+cur.val);
            cur.left = buildtree(s,depth + 1);
            cur.right = buildtree(s,depth + 1); // 通过全局变量i，可以在同一层深度找到右子树
        }
        return cur;
    }
}

 

 

运行结果：

 

例11 二叉树的最近公共祖先

题号：236，难度：中等

题目描述：

 

解题思路：

此题一道和经典的面试题，代码量很少，但是对于很多初学者来说比较难以理解。采用深度优先搜索的思想，搜索目标节点。具体解题思路请参考代码。

具体代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == NULL) return root;
        if (root == p || root == q) return root;
        TreeNode* left =  lowestCommonAncestor(root->left, p, q);
        TreeNode* right =  lowestCommonAncestor(root->right, p, q);
        if (left != NULL && right != NULL) {
            return root; 
        } else if (left != NULL) {
            return left;
        } else if (right != NULL) {
            return right;
        } 
        return NULL;
    }
   
};

 

 

运行结果：

 

例12 打家劫舍 III

题号：337，难度：中等

题目描述：

 

解题思路：

本题考察后序遍历思想的应用，感觉外加了一点动态规划的思维。题目要求是寻找一个想加和较大的节点集。具体实现思路请参考代码。

具体代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int rob(TreeNode* root) {
        return postorder(root);
    }
    int postorder(TreeNode* root){
        if(root == NULL)
            return 0;
        postorder(root->left);
        postorder(root->right);
        int res1 = 0;  // 左右
        int res2 = root->val;  //根
        if (root->left != NULL){
            res1 += root->left->val;
            if (root->left->left != NULL)
                res2 += root->left->left->val;
            if (root->left->right != NULL)
                res2 += root->left->right->val;
        }
        if (root->right != NULL){
            res1 += root->right->val;
            if (root->right->left != NULL)
                res2 += root->right->left->val;
            if (root->right->right!=NULL)
                res2 += root->right->right->val;
        }
        root->val = max(res1, res2);
        return root->val;
    }
};

 

 

运行结果：

 

例13 在二叉树中增加一行

题号：623，难度：中等

题目描述：

 

解题思路：

此题考察二叉树的添加节点的问题。并且保持原有节点的相对顺序不断，具体解题思路可参考代码。

具体代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* addOneRow(TreeNode* root, int v, int d) {
     if (d == 0 || d == 1) {
         TreeNode* t = new TreeNode(v);
         if (d == 1) t->left = root;
         else t->right = root;
         return t;
     }
     if (root != NULL && d > 1) {
         root->left = addOneRow(root->left, v, d > 2 ? d - 1 : 1);
         root->right = addOneRow(root->right, v, d > 2 ? d - 1 : 0);
     }
     return root;
  }
};

 

 

运行结果：

 

例14 二叉树中所有距离为K的节点

题号：863，难度：中等

题目描述：

 

解题思路：

保存从根节点开始到叶子节点的每个路径，然后找到目标节点的位置，按照距离大小采用哈希定位的思想找到对应节点。

具体代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    map<TreeNode*,string> map;
    string path;
    vector<int> distanceK(TreeNode* root, TreeNode* target, int K) {
        vector<int> list;
        getNodeDist(root,target,"");
        int i;
        for(auto key:map){
            string s = key.second;
            for(i=0; i<s.length()&&i<path.length()&&s[i]==path[i];i++);
            if(s.length()-i + path.length()-i == K)
                list.push_back(key.first->val);
        }
        return list;
    }
    void getNodeDist(TreeNode* root,TreeNode* target,string p){
        if(root != NULL){
            path = root == target ? p : path;
            map.insert({root, p});
            getNodeDist(root->left,target,p+"0");
            getNodeDist(root->right,target,p+"1");
        }
    }
};

 

 

运行结果：

 

例15 监控二叉树

题号：968，难度：困难

题目描述：

 

解题思路：

此题也是选取一个符合题目要求的节点子集，但是取的要求是间隔化取点，并且需要满足数量最小。具体实现可参考下方代码。

具体代码：

 

class Solution {
    private int ans = 0;
    
    public int minCameraCover(TreeNode root) {
        if (root == null) return 0;
        if (dfs(root) == 2) ans++;
        return ans;
    }
    
    // 1：该节点安装了监视器 2：该节点可观，但没有安装监视器 3：该节点不可观
    private int dfs(TreeNode node) {
        if (node == null)
            return 1;       
        int left = dfs(node.left), right = dfs(node.right);        
        if (left == 2 || right == 2) {
            ans++;
            return 0;
        } else if (left == 0 || right == 0){            
            return 1;
        } else 
            return 2;
    }
}

 

运行结果：

 

例16 二叉树着色游戏

题号：1145，难度：中等

题目描述：

 

解题思路：

此题也是一道节点选择的问题，但是涉及到了博弈论。按照题目的要求我们会发现选择一个节点后正常情况下会把整棵树分为三个部分，只需要获胜者能够访问的一部分节点个数大于另一方即可确保最终获胜。

具体代码：

 

class Solution {
   //极客1选的起始点有多少个左节点
    private int left = 0;
    //极客1选的起始点有多少个右节点
    private int right = 0;

    public boolean btreeGameWinningMove(TreeNode root, int n, int x) {
        //极客1选了第一个节点后，将树划分为了三个部分（可能为空）
        //第一部分：left 第二部分：right 第三部分：n - (left + right) - 1
        //只需要总结点的数的一半 < 三个部分中的最大值，极客2就可以获胜
        return getNum(root, x) / 2 < Math.max(Math.max(left, right), n - (left + right) - 1);
    }

    private int getNum(TreeNode node, int x) {
        if (node == null) {
            return 0;
        }
        int r = getNum(node.right, x);
        int l = getNum(node.left, x);
        if (node.val == x) {
            left = l;
            right = r;
        }
        return l + r + 1;
    }
}

 

运行结果:

 

例17 二叉树的所有路径

题号：257，难度：简单

题目描述：

 

解题思路：

此题是路径选择的一个基本习题，是解决路径相关问题的必须掌握的一道题。采用深度优先搜索保存每条路径即可。

具体代码：

 

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> ret;
        if(root == NULL) return ret;
        solve(root, "", ret);
        return ret;
    }
    
    void solve(TreeNode* root, string cur, vector<string>& ret) {
        if(root != NULL) {
            cur += to_string(root->val); // 将数值转换为字符串
            if(root->left == NULL && root->right == NULL) {
                ret.push_back(cur);
            } else {
                solve(root->left, cur+"->", ret);
                solve(root->right, cur+"->", ret);
            }
        }
    }           
};

运行结果：

  

例18 二叉树中分配硬币

题号：979，难度：中等

题目描述：

 

解题思路：

本题考察我们采用前序遍历，并抽象为本题解答的过程。具体原理请参考代码。

具体代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
    /**
     * 从后序遍历的第一个叶子节点开始，假设自己有x个金币，剩余x-1个金币都还给父节点，x-1可能为负数、0、正数
     * x-1 < 0说明不够金币，需要从父节点获得，因此子节点有|x-1|个入方向的操作，次数加上|x-1|
     * x-1 == 0说明刚好，无需与父节点有金币的交换，次数加0
     * x-1 > 0 说明有多余的金币，需要交给父节点，因此子节点有x-1个出方向的操作，次数加上|x-1|
     */
public: 
    int ans = 0;// 移动次数
    int distributeCoins(TreeNode* root) {
        lrd(root);
        return ans;
    }
    int lrd(TreeNode* root){
        if(root == NULL){
            return 0;
        }
        if(root->left != NULL){
            root->val += lrd(root->left);
        }
        if(root->right != NULL){
            root->val += lrd(root->right);
        }
        ans += abs(root->val - 1);
        return root->val - 1;
    }
};

 

 

运行结果：

 

例19 二叉树的垂序遍历

题号：987，难度：中等

题目描述：

 

解题思路：

通过给每个节点定制编号的思路，采用前序遍历的思想来完成本题要求的垂序遍历。

具体代码：

 

class Solution {
    private Map<Integer, List<List<Integer>>> map = new HashMap<>();
    private int depth;
    
    public List<List<Integer>> verticalTraversal(TreeNode root) {
        depth = getDepth(root);
        dfs(root, 0, 0);
        List<List<Integer>> result = new ArrayList<>();
        int min = 0;
        for(Integer key: map.keySet()){
            min = Math.min(min, key);
            result.add(new ArrayList<Integer>());
        }
        for(Integer key: map.keySet()){
            for(int i = 0;i < depth;i++) {
                List<Integer> temp = map.get(key).get(i);
                if(temp.size() == 1)
                    result.get(key-min).add(temp.get(0));
                else if(temp.size() > 1) {  // 同层同列的元素，按照从小到大排序
                    Collections.sort(temp);
                    for(Integer t: temp)
                        result.get(key-min).add(t);
                }
            }
        }
        return result;
    }
    
    public int getDepth(TreeNode root) {
        if(root == null)
            return 0;
        return 1 + Math.max(getDepth(root.left), getDepth(root.right));
    }
    
    public void dfs(TreeNode root, int x, int y) {
        if(root == null)
            return;
        List<List<Integer>> temp;
        if(map.containsKey(x))
            temp = map.get(x);
        else {
            temp = new ArrayList<>();
            for(int i = 0;i < depth;i++)
                temp.add(new ArrayList<Integer>());
        }
        temp.get(y).add(root.val);
        map.put(x, temp);
        dfs(root.left, x-1, y+1);
        dfs(root.right, x+1, y+1);
    }
} 

 

运行结果：

 

例20 二叉树中的最大路径和

题号：124，难度：困难

题目描述：

 

解题思路：

这道题的解题思路和例11 二叉树的最近公共祖先比较相似，都是采用深度优先搜索的思想，并分别寻找左右子树的结果，最后和根节点进行比较。具体实现的思路请参考下方代码。

具体代码：

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int ret = INT_MIN;
    int maxPathSum(TreeNode* root) {
        /**
        对于任意一个节点, 如果最大和路径包含该节点, 那么只可能是两种情况:
        1. 其左右子树中所构成的和路径值较大的那个加上该节点的值后向父节点回溯构成最大路径
        2. 左右子树都在最大路径中, 加上该节点的值构成了最终的最大路径
        **/
        getMax(root);
        return ret;
    }
    
    int getMax(TreeNode* r) {
        if(r == NULL) return 0;
        int left = max(0, getMax(r->left)); // 如果子树路径和为负则应当置0表示最大路径不包含子树
        int right = max(0, getMax(r->right));
        ret = max(ret, r->val + left + right); // 判断在该节点包含左右子树的路径和是否大于当前最大路径和
        return max(left, right) + r->val;
    }
};

 

 

运行结果：

 

例21 路径总和 |||

题号：437，难度：简单

题目描述：

 

解题思路：

首先，此题并不简单。其次，本题是二叉树路径问题中一个很有代表性的问题。采用前序遍历的思想，以及根节点和子树的关系，不断更新最终结果。

具体代码：

/**
 * 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 pathnumber;
    int pathSum(TreeNode* root, int sum) {
            if(root == nullptr) return 0;            
            Sum(root,sum);
            pathSum(root->left,sum);
            pathSum(root->right,sum); 
            return pathnumber;
    }    
    
    void Sum(TreeNode* root, int sum){
        if(root == nullptr) return;
        sum-=root->val;
        if(sum == 0){
            pathnumber++;           
        }
        Sum(root->left,sum);
        Sum(root->right,sum);
    } 
};

 

 

运行结果：

 

Pancy93
关注
leetcode刷题（C++版本）
PeterAndersen86的博客
05-30 1391
参考书籍：labuladong算法小抄 一、常见函数：1 accumulate 常用用途：可以用 + 运算符求出元素序列的和。前两个参数是定义序列的输入迭代器，第三个参数是和的初值； 示例：力扣413题 class Solution { public: int numberOfArithmeticSlices(vector<int>& nums) { int n = nums.size(); if(n < 3) return 0; ...
Leetcode刷题方法总结---字符串全解
修行的凡人的博客
08-23 1191
Leetcode刷题方法总结---字符串全解
LeetCode刷题之c++方法记录
dream161110的博客
02-11 422
主要是STL方法的记录 遍历vector for (auto mn : nums) { if (mn <= first) first = mn; else if (mn <= second) second = mn; else if (first < second && second < mn) return true; } ...
LeetCode 算法：字符串解码 c++
最新发布
想都是问题，做才有答案～～
08-11 541
LeetCode 算法：字符串解码 c++
LeetCode刷题C++
猫猫头的博客
03-12 1769
5.最长回文字符串 给你一个字符串 s，找到 s 中最长的回文子串。 划定步长，遍历判断 class Solution { public: string longestPalindrome(string s) { if(s.size() < 2){ return s; } int maxlen = 1; int begin = 0; int dp[s.size()][s.size()];
leetCode刷题技巧总结（C++篇）
Accept1234的博客
03-15 2789
C++/C语言编程技巧 C++的STL库总结 字符串STL总结之string C++结构体定义 C++/C输入输出定义 专栏文章 挑战程序设计竞赛（经验篇）刷题记录索引 挑战程序设计竞赛（算法和数据结构）专栏 算法竞赛入门经典（第2版）刷题记录索引 王道计算机考研-机试指南 专栏 ...
LeetCode刷题(简单)笔记C++
一路嵌行的博客
10-28 276
1、给定一个整数数组 nums和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 答案：...
C++leetcode刷题c-c-master.zip
03-18
本资料“C++leetcode刷题c-c-master.zip”正是围绕C++语言，针对LeetCode平台进行深入学习和实践的资源集合。 首先，让我们来了解一下C++。C++是一种静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化...
leetcode刷题全刷-Leetcode-cheatsheet:Leetcode备忘单
06-30
刷题全刷备忘单 动机 这是为了帮助我在刷 leetcode 时重新认识一些语法和概念。 C++ 句法技巧 STL & 数组相关 List< int []> p1 = new ArrayList< int []>(); p1.add( new int []{a,b,c}); vector<vector>> C ...
leetcode刷题，C++刷题技巧
11-08
《LeetCode刷题，C++刷题技巧》是一本针对有C++编程基础，希望通过LeetCode平台提升算法和数据结构能力的读者所编写的指南。作者高畅在准备实习秋招的过程中，积累了大量的LeetCode刷题经验，并在书中分享了这些宝贵...
leetcode刷题技巧-Leetcode:一些leetcode挑战的Python/C++/Go解决方案
07-06
leetcode 刷题技巧力码解决方案 介绍 在男人的生活中，有这些时刻是您做出承诺的时刻。 5 月 18 日，我承诺在接下来的 11 个月内，我将刷我的技能： Python、Go、C++ 算法 我是一个言出必行的人。 这个存储库是我...
C++ LeetCode刷题班.zip
04-22
将算法与数据结构的知识进行精简与归纳，快速掌握相应知识要点。以leetcode.com、codeforces.com中的题目为例题，利用OJ刷题的方式提升编码能力与解决算法面试题的能力。
leetcode c++程序
03-20
leetcode上C++版本资源，完整的C++代码，包括数据结构、算法等。
LeetCode:用 C++ 编写 Leetcode
06-18
leetcode 的代码
LeetCode---C++实现
07-21
本书包含了 LeetCode Online Judge所有题目的答案，所有代码经过精心编写，编码规范良好，适合读者反复揣摩，模仿，甚至在纸上默写
LeetCode刷题（C++）——Integer to Roman（Medium）
YF_Li123的博客
05-02 346
Given an integer, convert it to a roman numeral. Input is guaranteed to be within the range from 1 to 3999. 罗马数字： 1-9：{"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX" } 10-90：{"X", "XX
leetcode 刷题笔记&心得【c++】【每日一题】
guangjie2333的博客
06-07 180
第一题 vector 是一个int向量，添加元素： 向量名.push_back(被添加的元素) c++ 获取数组元素数量用nums.size() 用 sizeof(nums)/sizeof(int) leetcode报错说内存消耗 map.count(Key)返回值为1或者0，1返回存在，0返回不存在 方法1：两个嵌套for 方法2：先将key-value 存入map （一个for），用targrt-nums[i]去判断该值是否在key中可以被找到（map.count,其实应该也是相当于一个for）。个人
leetcode刷题系列C++-candy
码厦（微信号）
02-22 1021
There are N children standing in a line. Each child is assigned a rating value. You are giving candies to these children subjected to the following requirements: Each child must have at least on
leetcode刷题笔记(C++)
Robin思源的博客
01-18 353
记录下刷题的心得以及过程中用到的知识点 vector的创建方式及基本用法https://blog.csdn.net/wkq0825/article/details/82255984 字符串与字符数组之间的转换https://blog.csdn.net/ksws0292756/article/details/79432329
leetcode刷题手册c++版
09-07
LeetCode刷题手册C版是一本针对程序员刷题的教材，旨在帮助他们提高编程能力、学习算法和数据结构。C语言作为一门广泛应用于系统编程和嵌入式开发的语言，在LeetCode刷题中也是非常重要的一种编程语言。 这本手册主要包括了LeetCode网站上的题目分类和解题思路。它以系统的方式组织了数百道LeetCode题目，并提供了针对每道题目的解题思路和详细的C语言代码实现。通过这本手册，程序员可以快速了解各种算法和数据结构的特点，掌握它们在解决实际问题中的应用。 LeetCode刷题手册C版的优势在于它提供了C语言的实现和相关的技巧。C语言是一种高效、灵活且广泛使用的编程语言，掌握C语言的编程技巧能够帮助程序员更好地理解算法和数据结构的原理，并设计出高质量的代码。此外，C语言也是很多面试中常见的编程语言，因此掌握LeetCode刷题手册C版可以帮助程序员在面试中更好地展示自己的技术能力。 总之，LeetCode刷题手册C版是一个针对C语言程序员的宝贵资源，它可以帮助程序员提升编程能力、学习算法和数据结构，并在面试中展现自己的优势。通过刷题手册C版的学习，程序员可以更好地理解LeetCode题目，提高解题效率，进一步提升自己的技术水平。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值