DAY20 二叉树7

最新推荐文章于 2024-06-19 18:36:28 发布
最新推荐文章于 2024-06-19 18:36:28 发布
阅读量24 收藏
点赞数
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yk2909438315/article/details/131789341
版权

530.二叉搜索树的最小绝对差 （双指针）

力扣题目链接(opens new window)

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

示例：

530二叉搜索树的最小绝对差

提示：树中至少有 2 个节点

思路

题目中要求在二叉搜索树上任意两节点的差的绝对值的最小值。

注意是二叉搜索树，二叉搜索树可是有序的。（我一开始没有立马想到！！！说明对二叉树的性质还不够了解！）

遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值，这样就简单多了

一、递归

1.转化为数组

那么二叉搜索树采用中序遍历，其实就是一个有序数组。

在一个有序数组上求两个数最小差值，这是不是就是一道送分题了。

最直观的想法，就是把二叉搜索树转换成有序数组，然后遍历一遍数组，就统计出来最小差值了（我看完卡子哥思路发现就是利用二叉树性质时，我也是这么想的）。

代码如下：

 class Solution {
 private:
 vector<int> vec;
 void traversal(TreeNode* root) {
     if (root == NULL) return;
     traversal(root->left);//--左
     vec.push_back(root->val); // 将二叉搜索树转换为有序数组--中
     traversal(root->right);//--右
 }
 public:
     int getMinimumDifference(TreeNode* root) {
         vec.clear();
         traversal(root);
         if (vec.size() < 2) return 0;
         int result = INT_MAX;//先初始化为最大值
         for (int i = 1; i < vec.size(); i++) { // 统计有序数组的最小差值
             result = min(result, vec[i] - vec[i-1]);//善用min和max函数真的可以简化代码（我的弱点）
         }
         return result;
     }
 };

以上代码是把二叉搜索树转化为有序数组了

2.双指针

其实在二叉搜素树中序遍历的过程中，我们就可以直接计算了。

需要用一个pre节点记录一下cur节点的前一个节点。

如图：

530.二叉搜索树的最小绝对差

一些同学不知道在递归中如何记录前一个节点的指针，其实实现起来是很简单的，大家只要看过一次，写过一次，就掌握了。

代码如下：

 class Solution {
 private:
 int result = INT_MAX;
 TreeNode* pre = NULL;
 void traversal(TreeNode* cur) {
     if (cur == NULL) return;
     traversal(cur->left);   // 左
     if (pre != NULL){       // 中，并且排除了cur刚刚走到二叉搜索树最小值结点时pre还等于NULL的情况
         result = min(result, cur->val - pre->val);
     }
     pre = cur; // 记录前一个
     traversal(cur->right);  // 右
 }
 public:
     int getMinimumDifference(TreeNode* root) {
         traversal(root);
         return result;
     }
 };

是不是看上去也并不复杂。

二、迭代

看过这两篇二叉树：听说递归能做的，栈也能做！ (opens new window)，二叉树：前中后序迭代方式的写法就不能统一一下么？ (opens new window)文章之后，不难写出两种中序遍历的迭代法。

因为递归的本质就是栈，所以其实用栈能解决所有需要使用递归的问题；递归最重要的特性就是可以先遍历到最后的结点，然后再回溯处理——栈因为有先进后出、后进先出的性质，所以也可以实现“先遍历到最后的结点，然后再回溯处理”

下面我给出其中的一种中序遍历的迭代法，代码如下：

 class Solution {
 public:
     int getMinimumDifference(TreeNode* root) {
         stack<TreeNode*> st;
         TreeNode* cur = root;
         TreeNode* pre = NULL;
         int result = INT_MAX;
         while (cur != NULL || !st.empty()) 
         {
             if (cur != NULL) { // 指针来访问节点，访问到最底层
                 st.push(cur); // 将访问的节点放进栈
                 cur = cur->left;                // 左
             } 
             else {
                 cur = st.top();
                 st.pop();
                 if (pre != NULL) {              // 中
                     result = min(result, cur->val - pre->val);
                 }
                 pre = cur;
                 cur = cur->right;               // 右
             }
         }
         return result;
     }
 };

总结

遇到在二叉搜索树上求什么最值，求差值之类的，都要思考一下二叉搜索树可是有序的，要利用好这一特点。

501.二叉搜索树中的众数

力扣题目链接(opens new window)

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

假定 BST 有如下定义：

  • 结点左子树中所含结点的值小于等于当前结点的值

  • 结点右子树中所含结点的值大于等于当前结点的值

  • 左子树和右子树都是二叉搜索树

例如：

给定 BST [1,null,2,2],

501. 二叉搜索树中的众数

返回[2].

提示：如果众数超过1个，不需考虑输出顺序

进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）

我的思路：用一个数组或者哈希表来存储每个出现过的数值的出现次数，但是这个好像空间开销蛮大的。（看完卡子哥思路后，我发现卡子哥说的不是二叉搜索树的情况的解决办法——》但是这是个二叉搜索树，所以我在中序遍历的时候只要用一个变量来记录相邻项出现相同数值的次数，并且用一个数组来动态存储当前出现频率最高的数值（用数组是因为可能有几个数值出现的频率相同）——看完卡子哥的思路以后，我发现卡子哥的思路和我的一样

卡子哥思路

这道题目呢，递归法我从两个维度来讲。

首先如果不是二叉搜索树的话，应该怎么解题，是二叉搜索树，又应该如何解题，两种方式做一个比较，可以加深大家对二叉树的理解。

一、迭代法

1.不是二叉搜索树

如果不是二叉搜索树，最直观的方法一定是把这个树都遍历了，用map统计频率，把频率排个序，最后取前面高频的元素的集合。

具体步骤如下：

（1）这个树都遍历了，用map统计频率

至于用前中后序哪种遍历也不重要，因为就是要全遍历一遍，怎么个遍历法都行，层序遍历都没毛病！

这里采用前序遍历，代码如下：

 // map<int, int> key:元素，value:出现频率
 void searchBST(TreeNode* cur, unordered_map<int, int>& map) { // 前序遍历
     if (cur == NULL) return ;
     map[cur->val]++; // 统计元素频率
     searchBST(cur->left, map);
     searchBST(cur->right, map);
     return ;
 }

（2）把统计的出来的出现频率（即map中的value）排个序

有的同学可能可以想直接对map中的value排序，还真做不到，C++中如果使用std::map或者std::multimap可以对key排序，但不能对value排序（知识漏洞）。

所以要把map转化数组即vector，再进行排序，当然vector里面放的也是pair<int, int>类型的数据，第一个int为元素，第二个int为出现频率。

代码如下：

 bool static cmp (const pair<int, int>& a, const pair<int, int>& b) 
 {
     return a.second > b.second; // 按照频率从大到小排序
 }
 ​
 vector<pair<int, int>> vec(map.begin(), map.end());
 sort(vec.begin(), vec.end(), cmp); // 给频率排个序

（3）取前面高频的元素

此时数组vector中已经是存放着按照频率排好序的pair，那么把数组最前面的元素取出来就可以了。

代码如下：

 result.push_back(vec[0].first);
 for (int i = 1; i < vec.size(); i++) 
 {
     // 取最高的放到result数组中
     if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
     else break;
 }
 return result;

整体C++代码如下：

 class Solution {
 private:
 ​
 void searchBST(TreeNode* cur, unordered_map<int, int>& map) { // 前序遍历
     if (cur == NULL) return ;
     map[cur->val]++; // 统计元素频率
     searchBST(cur->left, map);
     searchBST(cur->right, map);
     return ;
 }
 bool static cmp (const pair<int, int>& a, const pair<int, int>& b) {
     return a.second > b.second;
 }
 public:
     vector<int> findMode(TreeNode* root) {
         unordered_map<int, int> map; // key:元素，value:出现频率
         vector<int> result;
         if (root == NULL) return result;
         searchBST(root, map);
         vector<pair<int, int>> vec(map.begin(), map.end());
         sort(vec.begin(), vec.end(), cmp); // 给频率排个序
         result.push_back(vec[0].first);
         for (int i = 1; i < vec.size(); i++) {
             // 取最高的放到result数组中
             if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
             else break;
         }
         return result;
     }
 };

所以如果本题没有说是二叉搜索树的话，那么就按照上面的思路写

2.是二叉搜索树

既然是搜索树，它中序遍历就是有序的。

如图：

501.二叉搜索树中的众数1

中序遍历代码如下：

 void searchBST(TreeNode* cur) {
     if (cur == NULL) return ;
     searchBST(cur->left);       // 左
     （处理节点）                // 中
     searchBST(cur->right);      // 右
     return ;
 }

遍历有序数组的元素出现频率，从头遍历，那么一定是相邻两个元素作比较，然后就把出现频率最高的元素输出就可以了。

关键是在有序数组上的话，好搞，在树上怎么搞呢？

在二叉树：搜索树的最小绝对差 (opens new window)中我们就使用了pre指针和cur指针的技巧，这次又用上了。

弄一个指针指向前一个节点，这样每次cur（当前节点）才能和pre（前一个节点）作比较。

而且初始化的时候pre = NULL，这样当pre为NULL时候，我们就知道这是比较的第一个元素。

代码如下：

 if (pre == NULL) { // 第一个节点
     count = 1; // 频率为1
 } else if (pre->val == cur->val) { // 与前一个节点数值相同
     count++;
 } else { // 与前一个节点数值不同
     count = 1;
 }
 pre = cur; // 更新上一个节点

此时又有问题了，因为要求最大频率的元素集合（注意是集合，不是一个元素，可以有多个众数），如果是数组上大家一般怎么办？

应该是先遍历一遍数组，找出最大频率（maxCount），然后再重新遍历一遍数组把出现频率为maxCount的元素放进集合。（因为众数有多个）

这种方式遍历了两遍数组。

那么我们遍历两遍二叉搜索树，把众数集合算出来也是可以的。

但这里其实只需要遍历一次就可以找到所有的众数。

那么如何只遍历一遍呢？

如果 频率count 等于 maxCount（最大频率），当然要把这个元素加入到结果集中（以下代码为result数组），代码如下：

 if (count == maxCount) { // 如果和最大值相同，放进result中
     result.push_back(cur->val);
 }

问题：result怎么能轻易就把元素放进去了呢，万一，这个maxCount此时还不是真正最大频率呢？

所以下面要做如下操作：

频率count 大于 maxCount的时候，不仅要更新maxCount，而且要清空结果集（以下代码为result数组），因为结果集之前的元素都失效了。

 if (count > maxCount) { // 如果计数大于最大值
     maxCount = count;   // 更新最大频率
     result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
     result.push_back(cur->val);
 }

关键代码都讲完了，完整代码如下：（只需要遍历一遍二叉搜索树，就求出了众数的集合）

 class Solution {
 private:
     int maxCount = 0; // 最大频率
     int count = 0; // 统计频率
     TreeNode* pre = NULL;
     vector<int> result;
     void searchBST(TreeNode* cur) {
         if (cur == NULL) return ;
 ​
         searchBST(cur->left);       // 左
                                     // 中
         if (pre == NULL) { // 第一个节点
             count = 1;
         } else if (pre->val == cur->val) { // 与前一个节点数值相同
             count++;
         } else { // 与前一个节点数值不同
             count = 1;
         }
         pre = cur; // 更新上一个节点
 ​
         if (count == maxCount) { // 如果和最大值相同，放进result中
             result.push_back(cur->val);
         }
 ​
         if (count > maxCount) { // 如果计数大于最大值频率
             maxCount = count;   // 更新最大频率
             result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
             result.push_back(cur->val);
         }
 ​
         searchBST(cur->right);      // 右
         return ;
     }
 ​
 public:
     vector<int> findMode(TreeNode* root) {
         count = 0;
         maxCount = 0;
         TreeNode* pre = NULL; // 记录前一个节点
         result.clear();
 ​
         searchBST(root);
         return result;
     }
 };

二、迭代法（一刷没看）

只要把中序遍历转成迭代，中间节点的处理逻辑完全一样。

二叉树前中后序转迭代，传送门：

下面我给出其中的一种中序遍历的迭代法，其中间处理逻辑一点都没有变（我从递归法直接粘过来的代码，连注释都没改，哈哈）

代码如下：

 class Solution {
 public:
     vector<int> findMode(TreeNode* root) {
         stack<TreeNode*> st;
         TreeNode* cur = root;
         TreeNode* pre = NULL;
         int maxCount = 0; // 最大频率
         int count = 0; // 统计频率
         vector<int> result;
         while (cur != NULL || !st.empty()) {
             if (cur != NULL) { // 指针来访问节点，访问到最底层
                 st.push(cur); // 将访问的节点放进栈
                 cur = cur->left;                // 左
             } else {
                 cur = st.top();
                 st.pop();                       // 中
                 if (pre == NULL) { // 第一个节点
                     count = 1;
                 } else if (pre->val == cur->val) { // 与前一个节点数值相同
                     count++;
                 } else { // 与前一个节点数值不同
                     count = 1;
                 }
                 if (count == maxCount) { // 如果和最大值相同，放进result中
                     result.push_back(cur->val);
                 }
 ​
                 if (count > maxCount) { // 如果计数大于最大值频率
                     maxCount = count;   // 更新最大频率
                     result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
                     result.push_back(cur->val);
                 }
                 pre = cur;
                 cur = cur->right;               // 右
             }
         }
         return result;
     }
 };

236. 二叉树的最近公共祖先

力扣题目链接(opens new window)

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

236. 二叉树的最近公共祖先

示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

说明:

  • 所有节点的值都是唯一的。

  • p、q 为不同节点且均存在于给定的二叉树中

思路

遇到这个题目首先想的是要是能自底向上查找就好了，这样就可以找到公共祖先了。

那么二叉树如何可以自底向上查找呢？

回溯啊，二叉树回溯的过程就是从低到上。

后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。

接下来就看如何判断一个节点是节点q和节点p的公共祖先呢。

首先最容易想到的一个情况：如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者 左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。 即情况一：

img

判断逻辑是 如果递归遍历遇到q，就将q返回，遇到p 就将p返回，那么如果 左右子树的返回值都不为空，说明此时的中节点，一定是q 和 p 的最近祖先。

那么有录友可能疑惑，会不会左子树 遇到q 返回，右子树也遇到q返回，这样并没有找到 q 和p的最近祖先。

这么想的录友，要审题了，题目强调：二叉树节点数值是不重复的，而且一定存在 q 和 p。

但是很多人容易忽略一个情况，就是节点本身p(q)，它拥有一个子孙节点q(p)。

情况二：

img

其实情况一 和 情况二 代码实现过程都是一样的，也可以说，实现情况一的逻辑，顺便包含了情况二。

因为遇到 q 或者 p 就返回，这样也包含了 q 或者 p 本身就是 公共祖先的情况。

这一点是很多录友容易忽略的，在下面的代码讲解中，可以再去体会。

递归三部曲：

  • 确定递归函数返回值以及参数

需要递归函数返回值，来告诉我们是否找到节点q或者p，那么返回值为bool类型就可以了。

但我们还要返回最近公共节点，可以利用上题目中返回值是TreeNode * ，那么如果遇到p或者q，就把q或者p返回，返回值不为空，就说明找到了q或者p。

代码如下：

 TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)

  • 确定终止条件

遇到空的话，因为树都是空了，所以返回空。

那么我们来说一说，如果 root == q，或者 root == p，说明找到 q p ，则将其返回，这个返回值，后面在中节点的处理过程中会用到，那么中节点的处理逻辑，下面讲解。

代码如下：

 if (root == q || root == p || root == NULL) return root;

  • 确定单层递归逻辑

值得注意的是 本题函数有返回值，是因为回溯的过程需要递归函数的返回值做判断，但本题我们依然要遍历树的所有节点。

我们在二叉树：递归函数究竟什么时候需要返回值，什么时候不要返回值？ (opens new window)中说了 递归函数有返回值就是要遍历某一条边，但有返回值也要看如何处理返回值！

如果递归函数有返回值，如何区分要搜索一条边，还是搜索整个树呢？

搜索一条边的写法：

 if (递归函数(root->left)) return ;
 ​
 if (递归函数(root->right)) return ;

搜索整个树写法：

 left = 递归函数(root->left);  // 左
 right = 递归函数(root->right); // 右
 left与right的逻辑处理;         // 中

看出区别了没？

在递归函数有返回值的情况下：如果要搜索一条边，递归函数返回值不为空的时候，立刻返回，如果搜索整个树，直接用一个变量left、right接住返回值，这个left、right后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）。

那么为什么要遍历整棵树呢？直观上来看，找到最近公共祖先，直接一路返回就可以了。

如图：

236.二叉树的最近公共祖先

就像图中一样直接返回7，多美滋滋。

但事实上还要遍历根节点右子树（即使此时已经找到了目标节点了），也就是图中的节点4、15、20。

因为在如下代码的后序遍历中，如果想利用left和right做逻辑处理， 不能立刻返回，而是要等left与right逻辑处理完之后才能返回。

 left = 递归函数(root->left);  // 左
 right = 递归函数(root->right); // 右
 left与right的逻辑处理;         // 中

所以此时大家要知道我们要遍历整棵树。知道这一点，对本题就有一定深度的理解了。

那么先用left和right接住左子树和右子树的返回值，代码如下：

 TreeNode* left = lowestCommonAncestor(root->left, p, q);
 TreeNode* right = lowestCommonAncestor(root->right, p, q);

如果left 和 right都不为空，说明此时root就是最近公共节点。这个比较好理解

如果left为空，right不为空，就返回right，说明目标节点是通过right返回的，反之依然。

这里有的同学就理解不了了，为什么left为空，right不为空，目标节点通过right返回呢？

如图：

236.二叉树的最近公共祖先1

图中节点10的左子树返回null，右子树返回目标值7，那么此时节点10的处理逻辑就是把右子树的返回值（最近公共祖先7）返回上去！

这里也很重要，可能刷过这道题目的同学，都不清楚结果究竟是如何从底层一层一层传到头结点的。

那么如果left和right都为空，则返回left或者right都是可以的，也就是返回空。

代码如下：

 if (left == NULL && right != NULL) return right;
 else if (left != NULL && right == NULL) return left;
 else  { //  (left == NULL && right == NULL)
     return NULL;
 }

那么寻找最小公共祖先，完整流程图如下：

236.二叉树的最近公共祖先2

从图中，大家可以看到，我们是如何回溯遍历整棵二叉树，将结果返回给头结点的！

整体代码如下：

 class Solution {
 public:
     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
         if (root == q || root == p || root == NULL) return root;
         TreeNode* left = lowestCommonAncestor(root->left, p, q);
         TreeNode* right = lowestCommonAncestor(root->right, p, q);
         if (left != NULL && right != NULL) return root;
 ​
         if (left == NULL && right != NULL) return right;
         else if (left != NULL && right == NULL) return left;
         else  { //  (left == NULL && right == NULL)
             return NULL;
         }
 ​
     }
 };

稍加精简，代码如下：

 class Solution {
 public:
     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
         if (root == q || root == p || root == NULL) return root;
         TreeNode* left = lowestCommonAncestor(root->left, p, q);
         TreeNode* right = lowestCommonAncestor(root->right, p, q);
         if (left != NULL && right != NULL) return root;
         if (left == NULL) return right;
         return left;
     }
 };

2909438315
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录 Day14 二叉树
02-07
二叉树的原理以及实现代码
春节7天练丨Day5：二叉树和堆1
08-03
关于二叉树和堆的 7 个必知必会的代码实现二叉树实现一个二叉查找树，并且支持插入、删除、查找操作实现查找二叉查找树中某个节点的后继、前驱节点实现二叉树前、中、后
Day20 二叉树 part06
xiaoantu的博客
11-27 402
Day20 二叉树 part06
Day 20 二叉树补补补
ty_aa9910的博客
06-01 775
当我们从栈顶取出一个节点时，如果这个节点是NULL，那么我们知道下一个节点就是需要处理的节点，因为其左右子节点都已经被处理过了。我们再次进入while循环，取出栈顶元素NULL，然后进入else分支，弹出NULL，取出栈顶元素2，并将其弹出，然后交换2的左右子节点。在这个代码中，NULL在栈中的作用主要是作为一个标记，用来表示当前节点的左右子节点都已经被访问过了，下一步需要处理当前节点（交换其左右子节点）。如果栈顶的节点为空，那么将其弹出，然后再次取出栈顶的节点，并将其弹出，然后交换这个节点的左右子节点。
代码随想录day20 二叉树
shiliuhua05的博客
12-27 151
代码随想录day 20
代码随想录 Day20 二叉树
2302_77073236的博客
02-19 228
对递归的细节了解后，做题更清晰了，对于最近公共祖先问题在理解和写代码上都有很多困难，而且资源有限，建议看这个视频比较直白清晰，但有些点子是很模糊。
Day 20 对称二叉树
Lester18的博客
03-19 91
对称二叉树 给定一个二叉树，检查它是否是镜像对称的。 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 1 / \ 2 2 / \ / \ 3 4 4 3 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 1 / \ 2 2 \ \ 3 3 说明: 如果你可以运用递归和迭代两种方法解决这...
day 7二叉树练习
weixin_45544618的博客
03-21 39
每日学习
Day 6 二叉树
你们的伟仔的博客
12-17 171
二叉树的(层序)遍历相当于广度优先遍历，(前序)遍历相当于深度优先遍历。
DAY20|二叉树part4
weixin_47963219的博客
05-10 765
思路：可以两棵树同时遍历，比较节点。可以递归可以迭代。* };if(p!return;if(p->val!迭代，对层序遍历比较熟练，写一下：/*** int val;* };pst.pop();qst.pop();* };*/
Day15 二叉树
SuperSwaggy的博客
03-20 435
感想：二叉树之前没怎么做过，给我感觉挺灵活的，有时候没想到可以这样子做，而且很多数据结构也用到了二叉树，比如堆，周末我想总结一下java各个常用的数据结构的方法的时间复杂度。思路：层序遍历就是从层的两侧向中间去遍历，如果两侧的值不一样或者有空的值就肯定不是对称的。思路：我这样写也可以做出来，最方便的办法肯定就是正向的层序遍历之后把答案翻转，还有一种不用翻转用LinkedList这个链表添加到头就行了。思路：其实这题就是层序遍历的最后一个值的集合，所以只要把每一层的最后一个节点写进结果数组中就可以。
刷题笔记day20-二叉树
西园公子
11-13 81
【代码】刷题笔记day18-二叉树。
我在代码随想录-写代码Day16之二叉树
01-24
二叉树遍历
2-1_二叉树、查找排序算法_Day02_AM.mp4
04-01
2-1_二叉树、查找排序算法_Day02_AM.mp4
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 452
【代码】力扣LCP 08.剧情触发时间。
算法训练营day60
stmfresher的博客
06-16 220
【代码】算法训练营day60。
P1656 炸铁路
最新发布
STY_fish_2012的博客
06-19 333
如果y的追溯值大于了x的时间戳，也就是y的追溯值在x之后，并且，y追溯到的这个点与x一定不连通，因为如果连通，那么y就会顺着这个点追溯到时间戳更小的点x，到这里，我们不难推出：x与y之间直接连通的边，只有这一条，并且没有间接联通的边。炸毁一条路对于一张图来说，本质上就是去掉一条边，不能通过铁路到达就代表这张图不连通了，对于这种去掉之后就可以使整张图不再连通的边，我们称之为割边。第一行 n,m (1≤n≤150，1≤m≤5000)，分别表示有 n 个城市，总共 m 条铁路。里面里面讲过，这里就不多说了。
华为OD机试C卷（100分）-最大N个数与最小N个数的和（C语言）
欢迎来到我的博客~
06-16 195
给定一个数组，编写一个函数来计算它的最大N个数与最小N个数的和。你需要对数组进行去重。说明 最大2个数[100,95],最小2个数[83,64], 输出为342。说明 最大2个数[4,3],最小2个数[3,2], 有重叠输出为-1。最大N个数与最小N个数不能有重叠，如有重叠，输入非法返回-1。第三行输入N，N表达需要计算的最大、最小N个数。数组中数字范围[0, 1000]第一行输入M， M标识数组大小。第二行输入M个数，标识数组内容。输出最大N个数与最小N个数的和。
7-2 完全二叉树权值
04-24
完全二叉树是一种特殊的...例如，对于一个完全二叉树，其节点编号为1、2、3、4、5、6、7，对应的权值分别为10、20、30、40、50、60、70，那么可以使用一个长度为7的数组来存储这些权值：[10, 20, 30, 40, 50, 60, 70]。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值