二叉树：leetcode 110.平衡二叉树、257.二叉树的所有路径、404.左叶子之和

最新推荐文章于 2024-07-24 22:14:23 发布
最新推荐文章于 2024-07-24 22:14:23 发布
阅读量30 收藏
点赞数
文章标签： leetcode 算法 数据结构 c++ Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52097561/article/details/128811576
版权

leetcode 110.平衡二叉树

leetcode 257.二叉树的所有路径

leetcode 404.左叶子之和

leetcode 110.平衡二叉树

回顾一下二叉树高度和深度的概念：

  • 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。

  • 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。

递归法

求高度，我们用的是后序遍历，求子节点的高度并层层向上返回。而求深度，我们用的是前序遍历，层层向下遍历统计节点的深度。

递归三部曲：

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

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

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

如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了。

所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。

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

  1. 确定终止条件

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

if(node == NULL) return 0;

  1. 确定单层递归的逻辑

判断当前节点的左子树和右子树高度的差值与1的关系，如果差值小于等于1，则返回当前二叉树的高度。如果差值大于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;

整体代码如下：

/**
 * 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 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;
        int result;
        if(abs(leftHeight - rightHeight) > 1)
            result = -1;
        else
            result = 1 + max(leftHeight, rightHeight);
        return result;
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root) == -1 ? false : true;
    }
};

迭代法

可以使用层序遍历来求深度，但是就不能直接用层序遍历来求高度了，这就体现出求高度和求深度的不同。

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

这个函数通过栈模拟的后序遍历（统一遍历方式）找每一个节点的高度（其实是通过求传入节点为根节点的最大深度来求的高度）。代码如下：

int getDepth(TreeNode* cur){
        stack<TreeNode*> st;
        if(cur != NULL) st.push(cur);
        int depth = 0, 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;
    }

总体代码：

/**
 * 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 getDepth(TreeNode* cur){
        stack<TreeNode*> st;
        if(cur != NULL) st.push(cur);
        int depth = 0, 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;
    }
};

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

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

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

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

leetcode 257.二叉树的所有路径

这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。在这道题目中将涉及到回溯，因为我们要把路径记录下来，需要回溯来回退一个路径再进入另一个路径。

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

要记住：递归和回溯是一家

递归法

递归三部曲：

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

传入根节点，传入一个用于记录单条路径的path数组和存放结果集的result数组，题目要求返回结果是一个string类型的数组，故result的类型是vector<string>。

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

  1. 确定终止条件

本题的终止条件是找到了叶子节点就相当于找到了一条路径的终点，即某节点的左右孩子均为空。

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

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

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

  1. 确定单层递归的逻辑

我们使用的是前序遍历（中左右），其中的“中”就是处理过程，本题中就是将节点添加到vector<int> path中，每遍历一个节点，就要把节点添加进来。

path.push_back(cur->val);    // 中
// 终止条件处理逻辑
// 左
// 右

这里有一个细节，我们需要把“中”的处理过程写到终止条件判断的前面。因为对于叶子节点来说，如果写到后面的话，在终止条件判断的if中就直接return了，那么叶子节点的值将不会被放到path中。

然后是递归和回溯的过程，上面的终止条件判断中没有判断cur是否为空，可能会出现对空指针进行操作的异常情况，那么在这里递归的时候，如果为空就不进行下一层递归了。

/****

所以递归前要加上判断语句，下面要递归的节点是否为空。递归完，还要做回溯，因为path不能一直加入节点，它还要删节点，然后才能加入新的节点。回溯和递归是一一对应的，有一个递归，就要有一个回溯，递归和回溯要写到同一个花括号里面才可以。

/****

代码如下：

path.push(cur->val);
// ...
if(cur->left){    // 花括号不能去，否则函数执行顺序会不对
    traversal(cur->left, path, result);
    path.pop_back();    // 回溯
}
if(cur->right){
    traversal(cur->right, path, result);
    path.pop_back();    // 回溯
}

总体代码如下：

/**
 * 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 {
private:
    void traversal(TreeNode* cur, vector<int>& path, vector<string>& result) {  
        path.push_back(cur->val); // 中，中为什么写在这里，因为最后一个节点也要加入到path中 
        // 这才到了叶子节点
        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;
    }
};

代码的精简版如下：

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) {
    path += "->";
    traversal(cur->left, path, result); // 左
}
if (cur->right) {
    path += "->";
    traversal(cur->right, path, result); // 右
}

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

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

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(); // 回溯 '-'
        }
    }

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

迭代法

非递归的方式，我们可以依然可以使用前序遍历的迭代方式来模拟遍历路径的过程，这里除了模拟递归需要一个栈，同时还需要一个栈来存放对应的遍历路径。使得保存路径的栈跟随模拟递归的栈同步进行操作，要注意在更新路径时要带上之前已经存储的路径。

/**
 * 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:
    vector<string> binaryTreePaths(TreeNode* root) {
        stack<TreeNode*> st;    // 保持遍历节点的栈 TreeNode
        stack<string> pa;       // 保持路径的栈 string
        vector<string> result;
        if(root == NULL) return result;
        st.push(root);
        pa.push(to_string(root->val));
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            string path = pa.top();
            pa.pop();
            if(node->right){
                st.push(node->right);
                pa.push(path + "->" + to_string(node->right->val));
            }
            if(node->left){
                st.push(node->left);
                pa.push(path + "->" + to_string(node->left->val));
            }
            if(node->left == NULL && node->right == NULL)
                result.push_back(path);
        }
        return result;
    }
};

leetcode 404.左叶子之和

给出左叶子的明确定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点。

我们从左叶子的定义中可以知道，无法根据当前节点的信息及其孩子信息来判断该节点是不是左叶子，一定要通过其父节点才知道。所以我们不能直接遍历到叶子节点进行判断，而是要在其上一层进行判断，其判断逻辑如下：

if(node->left != NULL && node->left->left == NULL && node->left->right ==NULL)

递归法

递归的遍历顺序为后序遍历（左右中），是因为要通过递归函数的返回值来累加求取左叶子数值之和，层层向上返回给根节点，最终得到整一棵二叉树的左叶子之和。

递归三部曲

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

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

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

int sumOfLeftLeaves(TreeNode* root)

  1. 确定终止条件

如果遇到空节点，那么左叶子之和一定为0；如果遇到叶子节点，那么其左叶子之和也为0。

if(root == NULL) return 0;
if(root->left == NULL && root->right == NULL) return 0;
// 注意这里的root不是指的根节点，而是遍历到的每一个节点，因为这里使用的是主函数进行遍历。

  1. 确定单层递归的逻辑

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

int leftValue = sumOfLeftLeaves(root->left);    // 左
// 若当前节点的左孩子就是左叶子，此种情况特别考虑，若进入递归中，则会返回0而不是左叶子的值。
if (root->left && !root->left->left && !root->left->right) {
    leftValue = root->left->val;
}
int rightValue = sumOfLeftLeaves(root->right);  // 右

int sum = leftValue + rightValue;               // 中
return sum;

整体代码如下：

/**
 * 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 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 != NULL && root->left->left == NULL && root->left->right == NULL){
            leftValue = root->left->val;
        }
        int rightValue = sumOfLeftLeaves(root->right);    // 右
        return leftValue + rightValue;        // 中
    }
};

迭代法

本题迭代法使用前中后序都是可以的，只要把左叶子节点统计出来，就可以了。

可以写出一个前序遍历的迭代法，与上题迭代法类似。判断条件都是一样的，代码如下：

/**
 * 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 sumOfLeftLeaves(TreeNode* root) {
        stack<TreeNode*> st;
        int result = 0;
        if(root == NULL) return 0;
        st.push(root);
        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;
    }
};
clementines_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python-leetcode面试题解之第257题二叉树的所有路径.zip
06-19
在本压缩包中，我们关注的是LeetCode面试题的第257题——"二叉树的所有路径"。这道题目主要考察了Python编程语言以及数据结构中的二叉树概念，特别是遍历二叉树的方法。LeetCode是一个非常流行的在线平台，它提供了...
Java面试-leetcode题解之第257题二叉树的所有路径.zip
07-24
java Java面试_leetcode题解之第257题二叉树的所有路径
算法学习|Day17-二叉树|Leetcode110.平衡二叉树，Leetcode257. 二叉树的所有路径，Leetcode404.左叶子之和
WR_mmc的博客
01-16 470
leetcode一刷，day17-二叉树，春招加油！
Day20_二叉树：Leetcode_110.平衡二叉树 + 257. 二叉树的所有路径 + 404.左叶子之和
qq_43506087的博客
05-15 208
【代码】Day20_二叉树：Leetcode_110.平衡二叉树 + 257. 二叉树的所有路径 + 404.左叶子之和。
代码随想录-Day17 | LeetCode110. 平衡二叉树、LeetCode257. 二叉树的所有路径、LeetCode404.左叶子之和
最新发布
weixin_45923460的博客
07-24 631
题目链接：110. 平衡二叉树题目描述：给定一个二叉树，判断它是否是高度平衡的二叉树（一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1）。回顾：高度是从叶子节点开始向上层层遍历加1，所以对于求高度采用后序遍历（左右中：先遍历左右孩子，然后返回给中间节点1）而深度是从根节点开始向下层层加1，所以对于求深度采用前序遍历（中左右：从中间节点向下去遍历节点，统计节点的深度，而不是向上去返回） 思路：了解上面思路之后本题求解非常简单清晰（递归法）： LeetCode257. 二叉树的所有路径 题目链接：2
代码随想录算法训练营第十七天| LeetCode110. 平衡二叉树、LeetCode257. 二叉树的所有路径、LeetCode404. 左叶子之和
weixin_48323589的博客
10-28 656
代码随想录算法训练营第十七天| LeetCode110. 平衡二叉树、LeetCode257. 二叉树的所有路径、LeetCode404. 左叶子之和
leetcode110.平衡二叉树、257.二叉树的所有路径、404.左叶子之和
qq_68664071的博客
05-18 767
关于根节点的深度究竟是1 还是 0，不同的地方有不一样的标准，leetcode的题目中都是以节点为一度，即根节点深度是1。这个回溯就有很大的问题，我们知道，回溯和递归是一一对应的，有一个递归，就要有一个回溯，这么写的话相当于把递归和回溯拆开了， 一个在花括号里，一个在花括号外。当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和，和 右子树左叶子之和，相加便是整个树的左叶子之和。判断一个树的左叶子节点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和，所以为int。
Day17|leetcode 110.平衡二叉树、257.二叉树的所有路径、404.左叶子之和
m0_74583479的博客
07-29 1078
因为高度是从下到上去查，所以要左右中的依次往上遍历，而求深度是从上到下去查，所以先中间，再左右，要中左右依次往下遍历。所以左叶子的定义为：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点。这道题需要找路径，自然是从上往下找，所以说要用前序（中左右），但是这道题也需要用到回溯，要知道回溯递归是一家。平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。需要注意的是，想要判断子节点是不是左叶子，必须是遍历到父节点的时候才能判断！
代码随想录算法训练营（23/5/25）二叉树，LeetCode 110.平衡二叉树，LeetCode.257二叉树的所有的路径，LeetCode 4044.左子树之和
m0_65169469的博客
06-14 165
这道题是判断高度平衡的二叉树，深度可以从上到下去查，所以需要前序遍历，而高度是只能从到下到上查，只能是后序遍历，要多看看题目，理解透题目的意思。LeetCode 257二叉树的所有的路径。LeetCode 110.平衡二叉树。LeetCode 404.左子树之和。我不是能理解回溯，这道题半懂。判断左节点是最重要的。
算法打卡day15|二叉树篇04|Leetcode 110.平衡二叉树、257. 二叉树的所有路径、404.左叶子之和
改变从现在开始
03-12 1109
JAVA算法|二叉树篇04|Leetcode 110.平衡二叉树、257. 二叉树的所有路径、404.左叶子之和
算法刷题-二叉树-Leetcode-110.平衡二叉树,257. 二叉树的所有路径 ,404.左叶子之和(python)
2401_83128121的博客
04-19 116
257. 二叉树的所有路径。
leetcode 110. 平衡二叉树
行走巨人国
05-21 614
题目描述： 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1。 示例 1: 给定二叉树[3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7 返回true。示例 2: 给定二叉树[1,2,2,3,3...
LeetCode 331. 验证二叉树的前序序列化
12-21
在计算机科学中，二叉树是一种常见的数据结构，它由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。前序遍历是一种访问二叉树节点的方法，顺序为：根节点 -> 左子树 -> 右子树。在前序遍历过程中...
java-leetcode题解之第110题平衡二叉树.zip
06-18
在本压缩包中，我们关注的是Java编程语言与LeetCode平台上的第110题——“判断一棵二叉树是否是平衡二叉树”。平衡二叉树是一种特殊的二叉树结构，它的左右两个子树的高度差不超过1，并且左右两个子树都是一棵平衡...
python-leetcode面试题解之第110题平衡二叉树-题解.zip
04-29
本压缩包文件聚焦于Python语言和LeetCode上的第110题——“平衡二叉树”（Balanced Binary Tree）。平衡二叉树是一种特殊的二叉树结构，它的左子树和右子树的高度差不超过1，并且左右子树都是平衡二叉树。 首先，...
力扣 102题 二叉树的层次遍历 记录
m0_49800270的博客
07-22 645
队列是一种先进先出（FIFO）的数据结构，非常适合于层序遍历，因为我们总是希望按照从树的上层到下层的顺序处理节点。队列操作：使用一个队列来管理待处理的树节点。队列的先进先出特性保证了树的每一层都按照从左到右的顺序被处理。
【LeetCode】分隔链表
qq_26521261的博客
07-20 428
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
Java | Leetcode Java题解之第273题整数转换英文表示
m0_57195758的博客
07-22 305
Java | Leetcode Java题解之第273题整数转换英文表示
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
it_fly的专栏
07-21 283
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
C++二叉树详解：LeetCode刷题全攻略
它旨在帮助读者掌握二叉树的理论知识和实际操作技巧，通过实例解析和LeetCode题目来提升编程能力。 本教程特别关注于C++的实现，适合对算法有深入理解和编程基础的读者，无论是初学者还是经验丰富的开发者，都能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值