Leetcode刷题笔记--Hot41-50

已于 2023-09-23 17:15:20 修改
阅读量343 收藏 1
点赞数
分类专栏： 数据结构&LeetCode 文章标签： 数据结构
于 2023-09-06 22:09:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863869/article/details/132724627
版权

目录

1--二叉树的层序遍历（102）

2--二叉树的最大深度（104）

3--从前序与中序遍历序列构造二叉树（105）

4--二叉树展开为链表（114）

5--买卖股票的最佳时机（121）

6--二叉树中的最大路径和（124）

7--最长连续序列（128）

8--只出现一次的数字（136）

9--单词拆分（139）

10--环形链表（141）

1--二叉树的层序遍历（102）

主要思路：

        经典广度优先搜索，基于队列；

        对于本题需要将同一层的节点放在一个数组中，因此遍历的时候需要用一个变量 nums 来记录当前层的节点数，即 nums 等于队列元素的数目；

#include <iostream>
#include <vector>
#include <queue>
 
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:
    std::vector<std::vector<int>> levelOrder(TreeNode* root) {
        std::vector<std::vector<int>> res;
        if(root == nullptr) return res;
        std::queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int nums = q.size(); // 当前层的节点数
            std::vector<int> tmp;
            while(nums > 0){ // 遍历处理同一层
                TreeNode *cur = q.front();
                q.pop();
                tmp.push_back(cur->val);
 
                if(cur->left != nullptr) q.push(cur->left);
                if(cur->right != nullptr) q.push(cur->right);
                
                nums--;
            }
            res.push_back(tmp); // 记录当前层的元素
        }
        return res;
    }
};
 
int main(int argc, char* argv[]){
    // root = [1, null, 2, 3]
    TreeNode *Node1 = new TreeNode(3);
    TreeNode *Node2 = new TreeNode(9);
    TreeNode *Node3 = new TreeNode(20);
    TreeNode *Node4 = new TreeNode(15);
    TreeNode *Node5 = new TreeNode(7);
    Node1->left = Node2;
    Node1->right = Node3;
    Node3->left = Node4;
    Node3->right = Node5;
 
    Solution S1;
    std::vector<std::vector<int>> res = S1.levelOrder(Node1);
    for(auto item : res) {
        for (int v : item) std::cout << v << " ";
        std::cout << std::endl;
    }
    return 0;
}

2--二叉树的最大深度（104）

主要思路：

        递归计算左右子树的深度，选取两者最大值 +1 返回；

#include <iostream>
#include <vector>
#include <queue>
 
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 maxDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        int res = dfs(root);
        return res;
    }
 
    int dfs(TreeNode* root){
        if(root == nullptr) return 0;
        int left_height = dfs(root->left);
        int right_height = dfs(root->right);
        int cur_height = std::max(left_height, right_height) + 1;
        return cur_height;
    }
};
 
int main(int argc, char* argv[]){
    // root = [3,9,20,null,null,15,7]
    TreeNode *Node1 = new TreeNode(3);
    TreeNode *Node2 = new TreeNode(9);
    TreeNode *Node3 = new TreeNode(20);
    TreeNode *Node4 = new TreeNode(15);
    TreeNode *Node5 = new TreeNode(7);
 
    Node1->left = Node2;
    Node1->right = Node3;
    Node3->left = Node4;
    Node3->right = Node5;
 
    Solution S1;
    int res = S1.maxDepth(Node1);
    std::cout << res << std::endl;
    return 0;
}

3--从前序与中序遍历序列构造二叉树（105）

主要思路：

        思路类似于根据中序和后序遍历来构建二叉树；

        对于本题，前序遍历的顺序是：根→左→右，则前序遍历的第一个节点是根节点；

        中序遍历的顺序是：左→根→右，遍历中序数组找到根节点的位置，根据根节点的位置划分左右子树；

        根据左右子树的大小划分前序遍历得到前序遍历的左右子树，递归构建左右子树即可；

#include <iostream>
#include <vector>
#include <queue>

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* buildTree(std::vector<int>& preorder, std::vector<int>& inorder) {
        TreeNode* res = dfs(preorder, 0, preorder.size()-1, inorder, 0, inorder.size()-1);
        return res;
    }

    TreeNode* dfs(std::vector<int>& preorder, int p_st, int p_en, std::vector<int>& inorder, int i_st, int i_en){
        if(p_st > p_en || i_st > i_en){
            return nullptr;
        }

        // 头结点
        TreeNode *root = new TreeNode(preorder[p_st]);
        // 划分中序
        int pos = -1; // 中序遍历中根节点的位置索引
        for(int i = i_st; i <= i_en; i++){
            if(inorder[i] == root->val){
                pos = i;
                break;
            }
        }
        // 左子树的大小
        int left_size = pos - i_st;
        // 右子树的大小
        int right_size = i_en - pos;

        root->left = dfs(preorder, p_st+1, p_st+left_size, inorder, i_st, pos-1);
        root->right = dfs(preorder, p_st+left_size+1, p_en, inorder, pos+1, i_en);
        return root;
    }
};

int main(int argc, char* argv[]){
    // preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
    std::vector<int> preorder = {3, 9, 20, 15, 7};
    std::vector<int> inorder = {9, 3, 15, 20, 7};
    
    Solution S1;
    TreeNode* res = S1.buildTree(preorder, inorder);

    // 层次遍历打印
    std::queue<TreeNode*> q;
    q.push(res);
    while(!q.empty()){
        TreeNode* tmp = q.front();
        q.pop();
        std::cout << tmp->val << " ";
        if(tmp->left != nullptr) q.push(tmp->left);
        if(tmp->right != nullptr) q.push(tmp->right);
    }
    std::cout << std::endl;
    return 0;
}

4--二叉树展开为链表（114）

主要思路：

        根据前序遍历的顺序，遍历二叉树，使用一个指针表示当前遍历到的节点的前驱节点，例如图中 2 的前驱节点是 1，4 的前驱节点是 3（根据前序遍历）；

        将前驱节点的左孩子为 nullptr，右孩子为当前遍历到的节点；根据前序遍历的顺序，递归更新前驱节点、左孩子和右孩子即可；

#include <iostream>
#include <queue>
#include <vector>

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:
    void flatten(TreeNode* root) {
        dfs(root);
    }

    void dfs(TreeNode* cur){
        if(cur == nullptr) return;
        pre->left = nullptr; // 前驱节点的左孩子指向 nullptr
        // 根
        pre->right = cur; // 前驱节点的右孩子指向当前遍历到的节点
        pre = cur; // 更新前驱节点

        TreeNode* left = cur->left;
        TreeNode* right = cur->right;

        dfs(left); // 递归处理左子树
        dfs(right); // 递归处理右子树
    }
private:
    TreeNode* pre = new TreeNode(-1); // 前序遍历的前驱节点
};

int main(int argc, char* argv[]){
    // root = [1,2,5,3,4,null,6]
    TreeNode* Node1 = new TreeNode(1);
    TreeNode* Node2 = new TreeNode(2);
    TreeNode* Node3 = new TreeNode(5);
    TreeNode* Node4 = new TreeNode(3);
    TreeNode* Node5 = new TreeNode(4);
    TreeNode* Node6 = new TreeNode(6);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->right = Node6;

    Solution S1;
    S1.flatten(Node1);
    TreeNode* tmp = Node1;
    while(tmp -> right != nullptr){
        std::cout << tmp->val << " ";
        tmp = tmp->right;
    }
    std::cout << std::endl;
    return 0;
}

5--买卖股票的最佳时机（121）

主要思路：
        计算截止到第 i 天的最低买入价格和最高的利润，不断更新即可；

#include <iostream>
#include <vector>
 
class Solution {
public:
    int maxProfit(std::vector<int>& prices) {
		int min_cost = prices[0];
		int max_profit = 0;
		for(int i = 0; i < prices.size(); i++){
			min_cost = std::min(min_cost, prices[i]);
			max_profit = std::max(max_profit, prices[i] - min_cost);
		}
		return max_profit;
    }
};

int main(int argc, char *argv[]) {
	// [7, 1, 5, 3, 6, 4]
	std::vector<int> test = {7, 1, 5, 3, 6, 4};
	Solution S1;
	int res = S1.maxProfit(test);
	std::cout << res << std::endl;
	return 0;
}

6--二叉树中的最大路径和（124）

主要思路：

        采用二叉树深度递归搜索，对于每一个结点，其最大路径和可能为以下四种情况：cur + cur->left, cur + cur->right, cur, cur + cur->left + cur->right；

        对于每一个结点，其返回给上层的最大路径，可能为以下三种情况：cur + cur->left, cur + cur->right, cur；

#include <iostream>
#include <vector>
#include <limits.h>

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 maxPathSum(TreeNode* root) {
		dfs(root);
		return max;
    }

	int dfs(TreeNode* root){
		if(root == nullptr) return 0;
		int left = dfs(root->left);
		int right = dfs(root->right);
		int cur_sum = std::max(
						std::max(
							std::max(left + root->val, right + root->val), 
								left + right + root->val),
									root->val);
		max = std::max(cur_sum, max);
		int ret_sum = std::max(std::max(left + root->val, right + root->val), root->val);
		return ret_sum;
	}
private:
	int max = INT_MIN;
};

int main(int argc, char *argv[]) {
	// root = [1, 2, 3]
	TreeNode* Node1 = new TreeNode(1);
	TreeNode* Node2 = new TreeNode(2);
	TreeNode* Node3 = new TreeNode(3);
	Node1->left = Node2;
	Node1->right = Node3;
	Solution S1;
	int res = S1.maxPathSum(Node1);
	std::cout << res << std::endl;
	return 0;
}

7--最长连续序列（128）

主要思路：

        利用 unordered_set 实现元素的去重，遍历数组 nums，只处理连续序列最左边的元素（根据其上一个元素是否在 unordered_set 中存在），循环查询其下一个元素是否存在，存在则序列长度 +1；

#include <iostream>
#include <vector>
#include <unordered_set>

class Solution {
public:
    int longestConsecutive(std::vector<int>& nums) {
		std::unordered_set<int> set;
		for(int & num : nums){ // 利用 unordered_set 去重
			set.insert(num);
		}

		int max_len = 0;
		for(int i = 0; i < nums.size(); i++){
			int cur_len = 1;
			int cur_num = nums[i];
			if(set.count(cur_num - 1) == 0){ // 连续子序列左边界元素，不是左边界元素则跳过，确保每一个元素只遍历一次
				while(set.count(cur_num + 1) != 0){ // 利用 unordered_set 实现 O(1) 查询
					cur_len++; // 长度++
					cur_num = cur_num + 1; // 右移
				}
				max_len = std::max(max_len, cur_len); // 更新最大长度
			}
		}
		return max_len;
    }
};

int main(int argc, char *argv[]) {
	// nums = [100, 4, 200, 1, 3, 2]
	std::vector<int> test = {100, 4, 200, 1, 3, 2};
	Solution S1;
	int res = S1.longestConsecutive(test);
	std::cout << res << std::endl;
	return 0;
}

8--只出现一次的数字（136）

主要思路：

           按位异或，出现两次的数字会两两对消，最后只剩下出现过一次的数字；     

#include <iostream>
#include <vector>

class Solution {
public:
    int singleNumber(std::vector<int>& nums) {
		int res = 0;
		for(int num : nums){
			res = res ^ num; // 按位异或
		}	
		return res;
    }
};

int main(int argc, char *argv[]) {
	// nums = [4, 1, 2, 1, 2]
	std::vector<int> test = {4, 1, 2, 1, 2};
	Solution S1;
	int res = S1.singleNumber(test);
	std::cout << res << std::endl;
	return 0;
}

9--单词拆分（139）

主要思路：

        基于动态规划，dp[i] 表示字符串 s 前 i 个字符匹配（即可以由字典的字符串构建而成）；

        初始化 dp[0] = true； 

        状态转移方程为：dp[i] == dp[j] && s.substr(j, i-j)，0 <= j <= i，只要有一个情况匹配即可；

#include <iostream>
#include <vector>
#include <string>
#include <unordered_set>

class Solution {
public:
    bool wordBreak(std::string s, std::vector<std::string>& wordDict) {
		std::unordered_set<std::string> hash;
		for(std::string str : wordDict){
			hash.insert(str);
		}
		
		std::vector<bool> dp(s.length() + 1, 0); // dp[i] 表示前 i 个字符构成的字符串匹配
		// 初始化
		dp[0] = true;
		// 遍历
		for(int i = 1; i <= s.length(); i++){
			for(int j = 0; j <= i; j++){
				if (dp[j] && hash.find(s.substr(j, i - j)) != hash.end()) { // 前 j 个字符匹配，且后 i -j 个字符也匹配 
                    dp[i] = true;
                    break; // 找到一种情况就 break
                }
			}
		}
		return dp[s.length()];
    }
};

int main(int argc, char *argv[]) {
	// s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
	std::string str = "catsandog";
	std::vector<std::string> wordDict = {"cats", "dog", "sand", "and", "cat"};
	Solution S1;
	bool res = S1.wordBreak(str, wordDict);
	if(res) std::cout << "true" << std::endl;
	else std::cout << "false" << std::endl; 
	return 0;
}

10--环形链表（141）

主要思路：

        经典快慢指针，判断两个指针是否相遇即可；

#include <iostream>

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    bool hasCycle(ListNode *head) {
		if(head == nullptr) return false;
        ListNode* slow = head;
		ListNode* fast = head;
		while(fast != nullptr && fast->next != nullptr){
			fast = fast->next->next;
			slow = slow->next;
			if(fast == slow) return true;
		}
		return false;
    }
};

int main(int argc, char *argv[]) {
	// head = [3,2,0,-4], pos = 1
	ListNode *Node1 = new ListNode(3);
	ListNode *Node2 = new ListNode(2);
	ListNode *Node3 = new ListNode(0);
	ListNode *Node4 = new ListNode(-4);

	Node1->next = Node2;
	Node2->next = Node3;
	Node3->next = Node4;
	Node4->next = Node2;

	Solution S1;
	int res = S1.hasCycle(Node1);
	if(res) std::cout << "true" << std::endl;
	else std::cout << "false" << std::endl;
	return 0;
}

晓晓纳兰容若
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode刷题笔记-堆
08-19
### Leetcode刷题笔记——堆相关题型解析 在算法学习和面试准备的过程中，Leetcode是一个不可或缺的资源库。本文将深入探讨堆相关的基础知识及其在Leetcode中的具体应用，特别是针对“Top K”问题的经典解决方案。 ...
谷歌师兄的leetcode刷题笔记-blog:博客
06-30
谷歌师兄的leetcode刷题笔记完美无瑕 一个基于 Tufte CSS 的漂亮、快速、兼容 AMP 的 Jekyll 主题。 Immaculate 真的很快，这要归功于 Google AMP。 当通过 Google 的 CDN 提供服务时，您会看到典型的...
Leetcode刷题笔记--Hot01-10
牵一只蜗牛去散步
05-31 411
基于滑动窗口和哈希表，用一个滑动窗口遍历字符串的字符，确保滑动窗口内的所有字符都是不重复的，当滑动字符不断扩大遇到重复字符时，将左指针右移，直到没有重复字符，这时比较滑动窗口的长度和最大长度的值，更新最大长度；使用双指针法，左指针指向左边的容器，右指针指向右边的容器，左容器容量低则左指针自增，右容器容量低则右指针自减，直到两个指针相遇，记录并更新最大容量值，具体原理证明见上面的讲解视频；遍历字符串的每个字符，用两个指针 l 和 r 分别指向其左字符和右字符，判断左字符和右字符是否相等，不断贪心向外扩展；
Leetcode刷题笔记--Hot61-70
牵一只蜗牛去散步
10-14 284
状态转移方程: dp[i][j] = std::min(dp[i-1][j-1], std::min(dp[i-1][j], dp[i][j-1])) + 1;不断将剩余先修课程数为0的课程加入到队列q中，当队列为空时，若修的课程数等于总课程数，则返回true，否则返回false；遍历两遍，第一遍求解L[i]，L[i]表示第i位左边所有数的乘积；基于动态规划，dp[i][j]表示以(i, j)为右下角，所构成正方形的最大边长。每修队列q中的课程，以该课程作为先修课程的所有课程，其剩余先修课程个数减1；
Leetcode刷题笔记--Hot51-60
牵一只蜗牛去散步
09-24 351
当一个桶不为空时，当准备放入一个新的元素时，如果新的元素与桶内的元素不相同，则不放入这个新元素且将桶内的一个元素拿出来；状态转移方程 dp[i][0] = dp[i-1][1] + nums[i]，dp[i][1] = dp[i-1][0];之所以使用 dp_min[i]，是由于会出现负数的情况，当负负得正时会出现更大的连续和，因此要考虑 dp_min[i]；访问到第i间房屋时，设dp[i][0]表示打劫第i间房屋，dp[i][1]表示不打劫第i间房屋，能够获得的最高金额；非常有哲学意义的一道题！
Leetcode刷题笔记--Hot11-20
牵一只蜗牛去散步
07-05 335
从尾开始遍历，找到第一个 a[j] > a[i] 的位置，交换 a[j] 和 a[i]，并将 a[i] 之后的数据反转，使其变成升序；基于二分法，二分后肯定有一边是有序的，因此首先判断哪一边是有序，接着继续判断target是否在有序部分，如果不在则下一次二分的范围是无序部分；与归并排序两个有序链表的思想类似，可以用 k 个结点指针指向 k 个链表的结点，每次归并值最小的结点到链表中，同时结点下移；利用栈，遍历字符串，遇到左括号则入栈，遇到右括号则出栈，并判断出栈元素是否与右括号匹配；
Leetcode刷题笔记--Hot91--100
牵一只蜗牛去散步
10-31 212
状态转移方程：dp[j] += dp[j - nums[i]]，其实质是：当背包已经装了nums[i]时，剩余容量为 j - nums[i]，此时装满剩余容量的方法数为 dp[j - nums[i]]，遍历不同的 nums[i] 将方法数相加即可；的总结点数，例如上图中[4, 2, 1, 3]可以理解为以 1 为根节点，其左子树路径的最大结点数为[4, 2]，右子树路径的最大结点数为[3]；递归二叉树，对于每一个节点，递归求解左子树的结点数，右子树的结点数，向上返回最大的节点树；7--合并二叉树（617）
Leetcode刷题笔记--Hot81--90
牵一只蜗牛去散步
10-27 222
原地修改数组，遍历数组，根据数组的值修改对应原数组索引的值，具体对应关系是 1对应坐标0，2对应坐标1；转化成0 - 1背包问题，一半的子集和vec作为背包容量，另一半的子集和作为物品，只需判断最后 dp[vec] 是否等于 vec 即可；基于从下到上的 dp 回溯法，每一个节点只有两种状态，dp[0]表示被打劫，dp[1]表示不被打劫；当前节点不被打劫时，其孩子可以都被打劫，也可以都不被打劫，或者一个被打劫另一个不被打劫。这道题使用 0-1 背包问题的 1 维解法时，需要先正序遍历物品，再。
Leetcode刷题笔记--Hot31-40
牵一只蜗牛去散步
08-25 1620
对于 i 个数字，选定不同的数字 head 作为根节点，则左子树的节点数为 head - 1，对应的二叉搜索树数目为 dp[head - 1]，右子树的节点数为 i - head，对应的二叉搜索树数目为 dp[i - head]；对于每一根柱子 i，找到最左边比它高度低的柱子，记为 left[i]，同理找到最右边比它高度低的柱子，记为 right[i]；遍历每一行，以当前行为底，将列看成柱子，遍历每一根柱子，类似于上题，寻找基于该柱子的最大矩形（利用单调栈向左向右寻找比当前柱子矮的边界）；
Leetcode刷题笔记--Hot21-30
牵一只蜗牛去散步
08-22 357
​​​​​当 word1[i]!= word2[j] 时，dp[i][j] = min(dp[i-1][j-1]+1, dp[i-1][j]+1, dp[i][j-1]+1)；初始状态：dp[0][0] = grid[0][0]，上边界dp[0][j] = dp[0][j-1] + grid[0][j]，左边界dp[i][0] = dp[i-1][0] + grid[i][0]；状态转移方程：dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]；
Leetcode刷题笔记--Hot71--80
牵一只蜗牛去散步
10-22 232
定义dp[i][0]表示第 i 天处于买入状态，dp[i][1]处于卖出状态，dp[i][2]处于冷冻期状态。初始化dp[0][0] = -prices[0]，dp[0][1] = 0, dp[0][2] = 0;
谷歌师兄的leetcode刷题笔记-momentum:势头
06-30
谷歌师兄的leetcode刷题笔记动力是给男人的 我们的重点是男人的工作，并成为我们能做到的最好的男人。 我们支持男人拥有真正的友谊 当然，我们喜欢一起玩乐，但我们正在寻找更多的东西：与我们信任的伟人建立真正的...
谷歌师兄的leetcode刷题笔记-saltride:盐渍
06-30
谷歌师兄的leetcode刷题笔记离子盐之旅 IonSaltRide 是一个实验项目，旨在提供一个易于使用的移动应用程序，以帮助我们丰盛生命教会的访客和工作人员。 这是一个绿色项目，将专注于它的可用性，以帮助新用户和有经验...
C++leetcode刷题c-c-master.zip
03-18
在这个“c-c-master”压缩包中，很可能是包含了作者在使用C++解LeetCode题目的过程中整理的一系列代码和笔记。这可能包括了每个问题的解题思路、代码实现、测试用例以及可能遇到的陷阱和优化点。这些宝贵的资源可以...
【数据结构-前缀哈希】力扣1124. 表现良好的最长时间段
最新发布
sjsjs11的博客
08-14 194
表现良好的时间段”有两种情况，一种是当前的sum能在哈希表中匹配到sum - 1时（如果是匹配sum的话，这个子段是「劳累的天数」等于「不劳累的天数」。这一题前缀+哈希并不是空间最优，最优空间是使用贪心+栈的做法，虽然空间复杂度都是O(n)，但是实际的空间使用可能高于 O(n)，因为当哈希表需要扩展时，会预留更多的空间以减少哈希冲突。所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。输入：hours = [9,9,6,0,6,6,9]
C语言实现排序之快速排序算法
2403_83044722的博客
08-14 279
快速排序（Quick Sort）是一种非常高效且实用的排序算法，它采用分治法（Divide and Conquer）的思想来完成排序。
常见8种数据结构
qq_43575301的博客
08-08 2155
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
数据结构（学习）2024.8.9（双向链表）
何物爱惜雨的博客
08-09 634
双向链表的创建，插入，遍历，删除
AcWing暑期LeetCode刷题班-树专题：判断BST
"AcWing夏季LeetCode刷题活动介绍及树相关题目解析" 在AcWing的暑期LeetCode刷题活动中，参与者将面临一系列精选的高频率算法题目，总计80道，涵盖了各种数据结构和算法主题。活动分为8周进行，每周会有10道题目，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值