DAY17 二叉树4

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

110.平衡二叉树

力扣题目链接(opens new window)

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

  • 求高度——》用后序遍历（本节视频重点）

  • 求深度——》用前序遍历

一、递归

此时大家应该明白了既然要求比较高度，必然是要后序遍历。

递归三步曲分析：

1.明确递归函数的参数和返回值

参数：当前传入节点。 返回值：以当前传入节点为根节点的树的高度。

那么如何标记左右子树是否差值大于1呢？

如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了。所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。

代码如下：

 // -1 表示已经不是平衡二叉树了，否则返回值是以该节点为根节点树的高度
 int getHeight(TreeNode* node)

2.明确终止条件

递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0

代码如下：

 if (node == NULL) {
     return 0;
 }

3.明确单层递归的逻辑

如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？当然是其左子树高度和其右子树高度的差值。

分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。

代码如下：

 int leftHeight = getHeight(node->left); // 左
 if (leftHeight == -1) return -1;
 int rightHeight = getHeight(node->right); // 右
 if (rightHeight == -1) return -1;
 ​
 int result;
 if (abs(leftHeight - rightHeight) > 1) {  // 中
     result = -1;
 } else {
     result = 1 + max(leftHeight, rightHeight); // 以当前节点为根节点的树的最大高度
 }
 ​
 return result;

代码精简之后如下：

 int leftHeight = getHeight(node->left); // 左
 if (leftHeight == -1) return -1;
 int rightHeight = getHeight(node->right); // 右
 if (rightHeight == -1) return -1;
 return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight); // 中

此时递归的函数就已经写出来了，这个递归的函数传入节点指针，返回以该节点为根节点的二叉树的高度，如果不是二叉平衡树，则返回-1。

getHeight整体代码如下：

 int getHeight(TreeNode* node) {
     if (node == NULL) {
         return 0;
     }
     int leftHeight = getHeight(node->left);
     if (leftHeight == -1) return -1;
     int rightHeight = getHeight(node->right);
     if (rightHeight == -1) return -1;
     return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight);
 }

最后本题整体递归代码如下：

 class Solution {
 public:
     // 返回以该节点为根节点的二叉树的高度，如果不是平衡二叉树了则返回-1
     int getHeight(TreeNode* node) {
         if (node == NULL) {
             return 0;
         }
         int leftHeight = getHeight(node->left);
         if (leftHeight == -1) return -1;
         int rightHeight = getHeight(node->right);
         if (rightHeight == -1) return -1;
         return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight);
     }
     bool isBalanced(TreeNode* root) {
         return getHeight(root) == -1 ? false : true;
     }
 };

二、迭代（一刷没看）

在104.二叉树的最大深度 (opens new window)中我们可以使用层序遍历来求深度，但是就不能直接用层序遍历来求高度了，这就体现出求高度和求深度的不同。

本题的迭代方式可以先定义一个函数，专门用来求高度。

这个函数通过栈模拟的后序遍历找每一个节点的高度（其实是通过求传入节点为根节点的最大深度来求的高度）

代码如下：

 // cur节点的最大深度，就是cur的高度
 int getDepth(TreeNode* cur) {
     stack<TreeNode*> st;
     if (cur != NULL) st.push(cur);
     int depth = 0; // 记录深度
     int result = 0;
     while (!st.empty()) {
         TreeNode* node = st.top();
         if (node != NULL) {
             st.pop();
             st.push(node);                          // 中
             st.push(NULL);
             depth++;
             if (node->right) st.push(node->right);  // 右
             if (node->left) st.push(node->left);    // 左
 ​
         } else {
             st.pop();
             node = st.top();
             st.pop();
             depth--;
         }
         result = result > depth ? result : depth;
     }
     return result;
 }

然后再用栈来模拟后序遍历，遍历每一个节点的时候，再去判断左右孩子的高度是否符合，代码如下：

 bool isBalanced(TreeNode* root) {
     stack<TreeNode*> st;
     if (root == NULL) return true;
     st.push(root);
     while (!st.empty()) {
         TreeNode* node = st.top();                       // 中
         st.pop();
         if (abs(getDepth(node->left) - getDepth(node->right)) > 1) { // 判断左右孩子高度是否符合
             return false;
         }
         if (node->right) st.push(node->right);           // 右（空节点不入栈）
         if (node->left) st.push(node->left);             // 左（空节点不入栈）
     }
     return true;
 }

整体代码如下：

 class Solution {
 private:
     int getDepth(TreeNode* cur) {
         stack<TreeNode*> st;
         if (cur != NULL) st.push(cur);
         int depth = 0; // 记录深度
         int result = 0;
         while (!st.empty()) {
             TreeNode* node = st.top();
             if (node != NULL) {
                 st.pop();
                 st.push(node);                          // 中
                 st.push(NULL);
                 depth++;
                 if (node->right) st.push(node->right);  // 右
                 if (node->left) st.push(node->left);    // 左
 ​
             } else {
                 st.pop();
                 node = st.top();
                 st.pop();
                 depth--;
             }
             result = result > depth ? result : depth;
         }
         return result;
     }
 ​
 public:
     bool isBalanced(TreeNode* root) {
         stack<TreeNode*> st;
         if (root == NULL) return true;
         st.push(root);
         while (!st.empty()) {
             TreeNode* node = st.top();                       // 中
             st.pop();
             if (abs(getDepth(node->left) - getDepth(node->right)) > 1) {
                 return false;
             }
             if (node->right) st.push(node->right);           // 右（空节点不入栈）
             if (node->left) st.push(node->left);             // 左（空节点不入栈）
         }
         return true;
     }
 };

当然此题用迭代法，其实效率很低，因为没有很好的模拟回溯的过程，所以迭代法有很多重复的计算。

虽然理论上所有的递归都可以用迭代来实现，但是有的场景难度可能比较大。

例如：都知道回溯法其实就是递归，但是很少人用迭代的方式去实现回溯算法！

因为对于回溯算法已经是非常复杂的递归了，如果再用迭代的话，就是自己给自己找麻烦，效率也并不一定高

257.二叉树的所有路径

力扣题目链接(opens new window)

给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

示例:

257.二叉树的所有路径1

先1——》2——》5，然后在把5弹出去，把2弹出去，回到1（这就是回溯的过程）；然后再记录1——》3

回溯：

回溯和递归式相辅相成的，只要有递归，就一定有回溯！回溯和递归是相辅相成的！

这道题是代码随想录里面第一次正式提到“回溯”这个思想！

这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。

前序遍历以及回溯的过程如图：

257.二叉树的所有路径

我们先使用递归的方式，来做前序遍历。要知道递归和回溯就是一家的，本题也需要回溯。

path要pop_back和二叉树3的104题中的depth--的用途是一样的，为了不妨碍其他路径结点的收集。

一、递归

1.递归函数参数以及返回值

要传入根节点，记录每一条路径的path（这个path里面的元素在递归的递过程时会动态存储路径上元素、递归的归过程时会动态的释放刚刚存储的元素），和存放结果集的result，这里递归不需要返回值，代码如下：

 void traversal(TreeNode* cur, vector<int>& path, vector<string>& result)

2.确定递归终止条件

在写递归的时候都习惯了这么写：

 if (cur == NULL) {
     终止处理逻辑
 }

但是本题的终止条件不能这样写，因为本题要找到叶子节点。

那么什么时候算是找到了叶子节点？ 是当 cur不为空，其左右孩子都为空的时候，就找到叶子节点。

所以本题的终止条件是：

 if (cur->left == NULL && cur->right == NULL) {
     终止处理逻辑
 }

为什么没有判断cur是否为空呢，因为下面的逻辑可以控制空节点不入循环。

再来看一下终止处理的逻辑。

这里使用vector 结构path来记录路径，所以要把vector 结构的path转为string格式，再把这个string 放进 result里。

那么为什么使用了vector 结构来记录路径呢？ 因为在下面处理单层递归逻辑的时候，要做回溯，使用vector方便来做回溯。

可能有的同学问了，我看有些人的代码也没有回溯啊。其实是有回溯的，只不过隐藏在函数调用时的参数赋值里，下文我还会提到。

这里我们先使用vector结构的path容器来记录路径，那么终止处理逻辑如下：

 if (cur->left == NULL && cur->right == NULL) { // 遇到叶子节点
     string sPath;
     for (int i = 0; i < path.size() - 1; i++) { // 将path里记录的路径转为string格式
         sPath += to_string(path[i]);
         sPath += "->";//为了符合题目要求的输出格式
     }
     sPath += to_string(path[path.size() - 1]); // 记录最后一个节点（叶子节点）
     result.push_back(sPath); // 收集一个路径
     return;
 }

3.确定单层递归逻辑

因为是前序遍历，需要先处理中间节点，中间节点就是我们要记录路径上的节点，先放进path中。

 path.push_back(cur->val);

然后是递归和回溯的过程，上面说过没有判断cur是否为空，那么在这里递归的时候，如果为空就不进行下一层递归了。

所以递归前要加上判断语句，下面要递归的节点是否为空，如下

 if (cur->left) {
     traversal(cur->left, path, result);
 }
 if (cur->right) {
     traversal(cur->right, path, result);
 }

此时还没完，递归完，要做回溯啊，因为path 不能一直加入节点，它还要删节点，然后才能加入新的节点。

那么回溯要怎么回溯呢，一些同学会这么写，如下：

 if (cur->left) {
     traversal(cur->left, path, result);
 }
 if (cur->right) {
     traversal(cur->right, path, result);
 }
 path.pop_back();

这个回溯就有很大的问题，我们知道，回溯和递归是一一对应的，有一个递归，就要有一个回溯，这么写的话相当于把递归和回溯拆开了， 一个在花括号里，一个在花括号外。

所以回溯要和递归永远在一起，世界上最遥远的距离是你在花括号里，而我在花括号外！

那么代码应该这么写：

 if (cur->left) {
     traversal(cur->left, path, result);//不断进行递过程
     path.pop_back(); // 回溯
 }
 if (cur->right) {
     traversal(cur->right, path, result);//不断进行递过程
     path.pop_back(); // 回溯
 }

那么本题整体代码如下：

 // 版本一
 class Solution {
 private:
 ​
     void traversal(TreeNode* cur, vector<int>& path, vector<string>& result) {
         path.push_back(cur->val); // 中———中为什么写在这里，因为最后一个节点也要加入到path中，才能加入result，所以要写在if (cur->left == NULL && cur->right == NULL) 之前
         // 这才到了叶子节点
         if (cur->left == NULL && cur->right == NULL) {
             string sPath;
             for (int i = 0; i < path.size() - 1; i++) {
                 sPath += to_string(path[i]);
                 sPath += "->";
             }
             sPath += to_string(path[path.size() - 1]);
             result.push_back(sPath);
             return;
         }
         if (cur->left) { // 左 
             traversal(cur->left, path, result);
             path.pop_back(); // 回溯
         }
         if (cur->right) { // 右
             traversal(cur->right, path, result);
             path.pop_back(); // 回溯
         }
     }
 ​
 public:
     vector<string> binaryTreePaths(TreeNode* root) {
         vector<string> result;
         vector<int> path;
         if (root == NULL) return result;
         traversal(root, path, result);
         return result;
     }
 };

如上的C++代码充分体现了回溯。

那么如上代码可以精简成如下代码：把path改为了string类型

 class Solution {
 private:
     void traversal(TreeNode* cur, string path, vector<string>& result) {
         path += to_string(cur->val); // 中
         if (cur->left == NULL && cur->right == NULL) {
             result.push_back(path);
             return;
         }
         if (cur->left) traversal(cur->left, path + "->", result); // 左
         if (cur->right) traversal(cur->right, path + "->", result); // 右
     }
 public:
     vector<string> binaryTreePaths(TreeNode* root) {
         vector<string> result;
         string path;
         if (root == NULL) return result;
         traversal(root, path, result);
         return result;
     }
 };

如上代码精简了不少，也隐藏了不少东西。

注意在函数定义的时候void traversal(TreeNode* cur, string path, vector<string>& result) ，定义的是string path，每次都是复制赋值，不用使用引用，否则就无法做到回溯的效果。（这里涉及到C++语法知识）

那么在如上代码中，貌似没有看到回溯的逻辑，其实不然，回溯就隐藏在traversal(cur->left, path + "->", result);中的 path + "->"。 每次函数调用完，path依然是没有加上"->" 的，这就是回溯了。

为了把这份精简代码的回溯过程展现出来，大家可以试一试把：

 if (cur->left) traversal(cur->left, path + "->", result); // 左  回溯就隐藏在这里

改成如下代码：

 path += "->";
 traversal(cur->left, path, result); // 左

即：

 if (cur->left) {
     path += "->";
     traversal(cur->left, path, result); // 左
 }
 if (cur->right) {
     path += "->";
     traversal(cur->right, path, result); // 右
 }

此时就没有回溯了，这个代码就是通过不了的了。

如果想把回溯加上，就要 在上面代码的基础上，加上回溯，就可以AC了。

 if (cur->left) {
     path += "->";
     traversal(cur->left, path, result); // 左
     path.pop_back(); // 回溯 '>'
     path.pop_back(); // 回溯 '-'
 }
 if (cur->right) {
     path += "->";
     traversal(cur->right, path, result); // 右
     path.pop_back(); // 回溯 '>' 
     path.pop_back(); //  回溯 '-' 
 }

整体代码如下：

 //版本二
 class Solution {
 private:
     void traversal(TreeNode* cur, string path, vector<string>& result) {
         path += to_string(cur->val); // 中，中为什么写在这里，因为最后一个节点也要加入到path中
         if (cur->left == NULL && cur->right == NULL) {
             result.push_back(path);
             return;
         }
         if (cur->left) {
             path += "->";
             traversal(cur->left, path, result); // 左
             path.pop_back(); // 回溯 '>'
             path.pop_back(); // 回溯 '-'
         }
         if (cur->right) {
             path += "->";
             traversal(cur->right, path, result); // 右
             path.pop_back(); // 回溯'>'
             path.pop_back(); // 回溯 '-'
         }
     }
 ​
 public:
     vector<string> binaryTreePaths(TreeNode* root) {
         vector<string> result;
         string path;
         if (root == NULL) return result;
         traversal(root, path, result);
         return result;
 ​
     }
 };

大家应该可以感受出来，如果把 path + "->"作为函数参数就是可以的，因为并没有改变path的数值，执行完递归函数之后，path依然是之前的数值（相当于回溯了）

综合以上，第二种递归的代码虽然精简但把很多重要的点隐藏在了代码细节里，第一种递归写法虽然代码多一些，但是把每一个逻辑处理都完整的展现出来了

重点

这里讲解本题解的写法逻辑以及一些更具体的细节，下面的讲解中，涉及到C++语法特性，如果不是C++的录友，就可以不看了，避免越看越晕。

如果是C++的录友，建议本题独立刷过两遍，再看下面的讲解，同样避免越看越晕，造成不必要的负担。

在第二版本的代码中，其实仅仅是回溯了 -> 部分（调用两次pop_back，一个pop> 一次pop-），大家应该疑惑那么 path += to_string(cur->val); 这一步为什么没有回溯呢？ 一条路径能持续加节点 不做回溯吗？

其实关键还在于 参数，使用的是 string path，这里并没有加上引用& ，即本层递归中，path + 该节点数值，但该层递归结束，上一层path的数值并不会受到任何影响。

二、迭代法（一刷没看）

至于非递归的方式，我们可以依然可以使用前序遍历的迭代方式来模拟遍历路径的过程，对该迭代方式不了解的同学，可以看文章二叉树：听说递归能做的，栈也能做！ (opens new window)和二叉树：前中后序迭代方式统一写法 (opens new window)。

这里除了模拟递归需要一个栈，同时还需要一个栈来存放对应的遍历路径。

C++代码如下：

 class Solution {
 public:
     vector<string> binaryTreePaths(TreeNode* root) {
         stack<TreeNode*> treeSt;// 保存树的遍历节点
         stack<string> pathSt;   // 保存遍历路径的节点
         vector<string> result;  // 保存最终路径集合
         if (root == NULL) return result;
         treeSt.push(root);
         pathSt.push(to_string(root->val));
         while (!treeSt.empty()) {
             TreeNode* node = treeSt.top(); treeSt.pop(); // 取出节点 中
             string path = pathSt.top();pathSt.pop();    // 取出该节点对应的路径
             if (node->left == NULL && node->right == NULL) { // 遇到叶子节点
                 result.push_back(path);
             }
             if (node->right) { // 右
                 treeSt.push(node->right);
                 pathSt.push(path + "->" + to_string(node->right->val));
             }
             if (node->left) { // 左
                 treeSt.push(node->left);
                 pathSt.push(path + "->" + to_string(node->left->val));
             }
         }
         return result;
     }
 };

当然，使用java的同学，可以直接定义一个成员变量为object的栈Stack<Object> stack = new Stack<>();，这样就不用定义两个栈了，都放到一个栈里就可以了

404.左叶子之和

力扣题目链接(opens new window)

计算给定二叉树的所有左叶子之和。

示例：

404.左叶子之和1

思路：

首先要注意是判断左叶子，不是二叉树左侧节点，所以不要上来想着层序遍历。

因为题目中其实没有说清楚左叶子究竟是什么节点，那么我来给出左叶子的明确定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点

大家思考一下如下图中二叉树，左叶子之和究竟是多少？

404.左叶子之和

其实是0，因为这棵树根本没有左叶子！

但看这个图的左叶子之和是多少？

图二

相信通过这两个图，大家对最左叶子的定义有明确理解了。

那么判断当前节点是不是左叶子是无法判断的，必须要通过节点的父节点来判断其左孩子是不是左叶子。（关键）

如果该节点的左节点不为空，并且该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子（关键），判断代码如下：

 if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
     左叶子节点处理逻辑
 }

一、递归法

递归的遍历顺序为后序遍历（左右中），是因为要通过递归函数的返回值来累加求取左叶子数值之和。

递归三部曲：

1.确定递归函数的参数和返回值

判断一个树的左叶子节点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和，所以为int。

使用题目中给出的函数就可以了。

2.确定终止条件

如果遍历到空节点，那么左叶子值一定是0

 if (root == NULL) return 0;

注意，只有当前遍历的节点是父节点，才能判断其子节点是不是左叶子。 所以如果当前遍历的节点是叶子节点，那其左叶子也必定是0，那么终止条件为：

 if (root == NULL) return 0;
 if (root->left == NULL && root->right== NULL) return 0; //其实这个也可以不写，如果不写不影响结果，但就会让递归多进行了一层。

3.确定单层递归的逻辑

当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和，和 右子树左叶子之和，相加便是整个树的左叶子之和。

代码如下：

 int leftValue = sumOfLeftLeaves(root->left);    // 左
 if (root->left && !root->left->left && !root->left->right) 
 {
     leftValue = root->left->val;
 }
 int rightValue = sumOfLeftLeaves(root->right);  // 右
 int sum = leftValue + rightValue;               // 中
 return sum;

整体递归代码如下：

 class Solution {
 public:
     int sumOfLeftLeaves(TreeNode* root) {
         if (root == NULL) return 0;
         if (root->left == NULL && root->right== NULL) return 0;
         int leftValue = sumOfLeftLeaves(root->left);    // 左
         if (root->left && !root->left->left && !root->left->right) // 左子树就是一个左叶子的情况————也就是root->left存在，但是root->left->left和root->left->right不存在
         { 
             leftValue = root->left->val;
         }
         int rightValue = sumOfLeftLeaves(root->right);  // 右
 ​
         int sum = leftValue + rightValue;               // 中
         return sum;
     }
 };

以上代码精简之后如下：

 class Solution {
 public:
     int sumOfLeftLeaves(TreeNode* root) {
         if (root == NULL) return 0;
         int leftValue = 0;
         if (root->left != NULL && root->left->left == NULL && root->left->right == NULL) {
             leftValue = root->left->val;
         }
         return leftValue + sumOfLeftLeaves(root->left) + sumOfLeftLeaves(root->right);
     }
 };

精简之后的代码其实看不出来用的是什么遍历方式了，对于算法初学者以上根据第一个版本来学习。

二、迭代法（一刷没看）

本题迭代法使用前中后序都是可以的，只要把左叶子节点统计出来，就可以了，那么参考文章 二叉树：听说递归能做的，栈也能做！ (opens new window)和二叉树：迭代法统一写法 (opens new window)中的写法，可以写出一个前序遍历的迭代法。

判断条件都是一样的，代码如下：

 class Solution {
 public:
     int sumOfLeftLeaves(TreeNode* root) {
         stack<TreeNode*> st;
         if (root == NULL) return 0;
         st.push(root);
         int result = 0;
         while (!st.empty()) {
             TreeNode* node = st.top();
             st.pop();
             if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
                 result += node->left->val;
             }
             if (node->right) st.push(node->right);
             if (node->left) st.push(node->left);
         }
         return result;
     }
 };

三、总结

这道题目要求左叶子之和，其实是比较绕的，因为不能判断本节点是不是左叶子节点。此时就要通过节点的父节点来判断其左孩子是不是左叶子了。

平时我们解二叉树的题目时，已经习惯了通过节点的左右孩子判断本节点的属性，而本题我们要通过节点的父节点判断本节点的属性。——》通过这道题目，可以扩展大家对二叉树的解题思路

2909438315
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录 Day14 二叉树
02-07
二叉树的原理以及实现代码
我在代码随想录-写代码Day16之二叉树
01-24
二叉树遍历
Day17 二叉树part04
qq_44072579的博客
03-16 370
返回 -1，表示当前子树不是平衡树。这样可以提前终止对右子树高度的计算，节省计算时间，因为只要发现一个子树不是平衡树，整棵树就不可能是平衡树了。当结点为叶子结点时，添加路径。否则进行递归，注意要用new StringBuffer(sB)使得每次迭代都有独立的地址。利用isLeft判断是左节点还是右节点。
day17 构造二叉树
sk142536的博客
06-18 232
leetcode 105 从前序与中序遍历序列构造二叉树 这道题感觉好难，但是通过这道题也学到了好多东西 构成二叉树 中序序列和前、后，层次序列任一组合唯一确定一颗二叉树。前、后，层次序列都是提供根结点的信息，中序序列用来区分左右子树；没有中序遍历是无法构成一棵二叉树的 前序、中序、后续遍历还原二叉树 关于这部分，这个大佬写的很棒 还原二叉树 一、前序+中序 根据前序序列的第一个元素建立根结点； 在中序序列中找到该元素，确定根结点的左右子树的中序序列； 在前序序列中确定左右子树的前序序列； 由左子树的前
代码随想录 Day17 二叉树
2302_77073236的博客
02-17 244
生病了 404并未写完。
DAY17-二叉树递归
u011043417的博客
12-14 117
二叉树
DAY17|二叉树part2
weixin_47963219的博客
05-05 767
一个打十个！
春节7天练丨Day5：二叉树和堆1
08-03
关于二叉树和堆的 7 个必知必会的代码实现二叉树实现一个二叉查找树，并且支持插入、删除、查找操作实现查找二叉查找树中某个节点的后继、前驱节点实现二叉树前、中、后
2-1_二叉树、查找排序算法_Day02_AM.mp4
04-01
2-1_二叉树、查找排序算法_Day02_AM.mp4
ACM算法学习路线、清单
qq_45477639的博客
06-10 2082
算法与数据结构学习路线
C++:十大排序
2301_80418172的博客
06-12 1033
十大排序CPP
【数据结构陈越版笔记】2.1 引子【第2章 数据结构实现基础】
最新发布
随手写写
06-16 965
（2）操作实现：在确定数据的存储方式后，数据结构涉及的另一个问题是相关的操作（运算）如何实现。在程序中，我们可以将程序的某个功能设计为函数，这一方面降低了程序设计的复杂性，另一方面也提高了程序设计的重用性。这个问题当然也可以用排序解决，但还有另一种更巧妙的方法，基本思路是：用一个基准数e将集合S分解为不包含e在内的两个小集合。（1）数据存储：对于上述问题，其数据对象是集合S，这也是最简单的一种数据组织方式。：基于问题分解，求集合中位数的问题实际上就是另一个问题的特殊情况，即求集合中的第K大数问题。
数据结构--第九章--查找
2302_80052051的博客
06-09 731
插入过程：（1）若二叉排序树T为空，则创建一个key域为k的节点，将它作为根节点；（2）否则将k和根节点的关键字比较，若两者相等，则说明树中已有此关键字k，无须插入，直接返回0；（3）若Kkey，则将k插入根节点的左子树中，否则将它插入右子树中。哈希表又称散列表，是除顺序表存储结构，链表存储结构和索引存储结构之外的又一种存储线性表的存储结构。对于n个元素，二分查找成功时最多的关键字比较次数为：log2（n+1）不成功时最多的关键字比较次数为log2（n+1）等概率条件下ASL成功=
【数据结构】双向链表（C语言）
2402_82689232的博客
06-12 557
哈喽铁子们，这里是博主鳄鱼皮坡。这篇文章将分享交流双向链表的相关知识。
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 384
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 555
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
盲盒App开发时有哪些技术框架可以借鉴
bytekj的博客
06-14 652
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 1272
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
4. 完全二叉树的特点
12-20
完全二叉树的特点是： 1. 所有的叶子节点都集中在二叉树的最后两层上，最后一层的叶子节点都靠左排列。 2. 除了最后一层，其他层的节点数都达到最大值，即每一层都是满的。 3. 如果最后一层不满，那么所有的节点都靠左排列。 举个例子，下面是一个完全二叉树的示例： ``` 1 / \ 2 3 / \ / 4 5 6 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值