【手把手带你刷Leetcode力扣】算法

最新推荐文章于 2022-06-01 15:40:45 发布
最新推荐文章于 2022-06-01 15:40:45 发布
阅读量308 收藏 1
点赞数
分类专栏： 手把手带你刷Leetcode力扣 文章标签： leetcode 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZZBOOM_/article/details/120689431
版权

1.算法 - 双指针

  • 普通双指针：两个指针往同一个方向移动
  • 对撞双指针：两个指针面对面移动（有序数列）
  • 快慢双指针：慢指针+快指针（环形链表）

141.环形链表

class Solution:
	# Time Complexity: O(N)
	# Space Complexity: O(1)
	def hasCycle(self, head: ListNode) -> bool:
		if head is None:
			return False
		slow = head
		fast = head
		while fast is not None and fast.next is not None:
			fast = fast.next.next
			slow = slow.next
			if slow == fast:
				return True
		
		retrun False

881.救生艇

class Solution:
	# Time Complexity: O(NlogN)
	# Space Complexity: O(1)
	def numRescueBoats(self, people: List[int], limit: int) -> int:
		if people is None or len(people) == 0:
			retrun 0
		people.sort()
		i = 0
		j = len(people) - 1
		res = 0
		while (i <= j):
			if people[i]+people[j] <= limit:
				i = i + 1
			j = j - 1
			res = res + 1
		return res

2.算法 - 二分查找法

有序数列

O（logN）

m = l + (r-l)//2
避免超过int型范围

  1. 二分查找

常规法：

class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(1)
	def search(self, nums, target):
		for i in range(len(nums)):
			if nums[i] == target:
				return i
		return -1

二分查找法：

class Solution(object):
	# Time Complexity: O(logN)
	# Space Complexity: O(1)
	def search(self, nums, target):
		if nums == None or len(nums) == 0:
			return -1
		left, right = 0, len(nums)-1
		while (left<=right):
			mid = left + (right - left)//2
			if nums[mid] == target:
				return mid
			elif nums[mid] > target:
				right = mid - 1
			else:
				left = mid + 1
		return -1
  1. 搜索插入位置

常规法：

class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(1)
	def searchInsert(self, nums, target):
		if nums == None or len(nums) == 0:
			return 0
		prev = -1
		for i in range(len(nums)):
			if nums[i] == target:
				return i
			elif num[i] < target:
				prev = i
			else:
				return prev+1
		return prev+1

二分查找法：

class Solution(object):
	# Time Complexity: O(logN)
	# Space Complexity: O(1)
	def searchInsert(self, nums, target):
		if nums == None or len(nums) == 0:
			return 0
		left, right = 0, len(nums)
		while (left<right):
			mid = left + (right - left)/2
			if nums[mid] == target:
				return mid
			elif nums[mid] > target:
				right = mid
			else:
				left = mid + 1
		return left
  1. 寻找峰值
class Solution(object):
	# Time Complexity: O(logN)
	# Space Complexity: O(1)
	def findPeakElement(self, nums: List[int]) -> int:
		if nums is None or len(nums) == 0:
			return -1
		l = 0
		r = len(nums) - 1
		while l < r:
			mid = l + (r-l)//2
			if nums[mid] > nums[mid+1]:
				r = mid
			else:
				l = mid + 1
		return l
  1. 搜索二维矩阵
class Solution(object):
	# Time Complexity: O(logN)
	# Space Complexity: O(1)
	def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
		if matrix is None or len(matrix) == 0:
			return False
		row = len(matrix)
		col = len(matrix[0])
		l = 0
		r = row * col - 1
		while l <= r:
			m = l + (r-l)//2
			element = matrix[m//col][m%col]
			if element == target:
				return True
			elif element > target:
				r = m - 1
			else:
				l = m + 1
		return False

3.算法 - 滑动窗口法

目的：减少while循环

数组中的定长问题

  1. 长度最小的子数组

暴力法：

class Solution(object):
	# Time Complexity: O(N^2)
	# Space Complexity: O(1)
	def minSubArrayLen(self, s: int, nums: List[int]) -> int:
		if nums is None or len(nums) == 0:
			return 0
		size = 1
		while size <= len(nums):
			for i in range(len(nums)-size+1):
				total = sum(nums[i: i+size])
				if total >= s:
					return size
			size += 1
		return 0

滑动窗口法（双指针法）：

class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(1)
	def minSubArrayLen(self, s: int, nums: List[int]) -> int:
		if nums is None or len(nums) == 0:
			return 0
		result = len(nums) + 1
		total = 0
		i, j = 0, 0
		while j < len(nums):
			total += num[j]
			j += 1
			while total >= s:
				result = min(result, j - i)
				total -= nums[i]
				i += 1
			return 0 if result == len(nums)+1 else result
  1. 定长子串中元音的最大数目
class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(1)
	def maxVowels(self, s: str, k: int) -> int:
		if s is None or len(s) == 0 or len(s) < k:
			return 0
		hashset = set(['a', 'o', 'e', 'i', 'u'])
		res = 0
		count = 0
		for i in range(0, k):
			if s[i] in hashset:
				count = count + 1
		res = max(res, count)
		for i in range(k, len(s)):
			out = s[i-k]
			inc = s[i]
			if out in hashset:
				count = count - 1
			if inc in hashset:
				count = count + 1
			res = max(res, count)
		return res

4.算法 - 递归法

函数直接或间接调用自己

  • 递归
  • 回溯
  • 深度优先搜索
  • 分治法

4个要素

  • 接受的参数
  • 返回值
  • 终止的条件
  • 递归拆解：如何递归下一层
  1. 斐波那契数
class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(N)
	def fib(self, N: int) -> int:
		if N < 2:
			return 0 if N == 0 else 1
		m = self.fib(N-1) + self.fib(N-2)
		return m
  1. 反转链表

迭代法：

class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(1)
	def reverseList(self, head: ListNode) -> ListNode:
		dummy = ListNode()
		dummy.next = head
		while (head != None and head.next != None):
			dummy_next = dummy.next
			temp = head.next
			dummy.next, head.next, temp.next = temp, temp.next, dummy_next
		return dummy.next

递归法：

class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(N)
	def reverseList(self, head: ListNode) -> ListNode:
		if not head or not head.next:
			return head
		p = self.reverseList(head.next)
		head.next.next = head
		head.next = None
		return p
  1. 反转字符串
class Solution(object):
	# Time Complexity: O(N/2)
	# Space Complexity: O(N/2)
	def reverseString(self, s: List[str]) -> None:
		self.recursion(s, 0, len(s)-1)
	
	def recursion(self, s, left, right):
		if left >= right:
			return
		self.recursion(s, left+1, right-1)
		s[left], s[right] = s[right], s[left]

5.算法 - 分治法

大问题切割成一个个小问题

用到递归，自己调用自己

  1. 多数元素
class Solution(object):
	# Time Complexity: O(NlogN)
	# Space Complexity: O(logN)
		def majorityElement(self, nums: List[int] -> int:
			return self.getMajority(nums, 0, len(nums)-1)
		
		def getMajority(self, nums, left, right):
			if left == right:
				return nums[left]
			
			mid = left + (right - left) // 2
			leftMajority = self.getMajority(nums, left, mid)
			rightMajority = self.getMajority(nums, mid+1, right)
			if leftMajority == rightMajority:
				return leftMajority
			
			leftCount = 0
			rightCount = 0
			for i in range(left, right+1):
				if nums[i] == leftMajority:
					leftCount += 1
				elif nums[i] == rightMajority:
					right += 1
			
			return leftMajority if leftCount > rightCount else rightMajority
  1. 最大序列和
class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(logN)
	def maxSubArray(self, nums: List[int]) -> int:
		return self.getMax(nums, 0, len(nums)-1)
	
	def getMax(self, nums, l, r):
		if l == r:
			return nums[l]
		mid = l + (r-l)//2
		leftSum = self.getMax(nums, l, mid)
		rightSum = self.getMax(nums, mid+1, r)
		crossSum = self.crossSum(nums, l, r)
		return max(leftSum, rightSum, crossSum)
	
	def crossSum(self, nums, l, r):
		mid l + (r-l)//2
		# from mid to leftmost
		leftSum = nums[mid]
		leftMax = leftSum
		for i in range(mid-1, l-1, -1):
			leftSum += nums[i]
			leftMax = max(leftMax, leftSum)
		
		# from mid to rightmost
		rightSum = nums[mid+1]
		rightMax = rightSum
		for i in range(mid+2, r+1):
			rightSum += nums[i]
			rightMax = max(rightMax, rightSum)
		
		return leftMax + rightMax

6.算法 - 回溯法

类似枚举，一层一层向下递归，尝试搜索答案

找到答案
尝试别的可能
返回答案

找不到答案
返回上一层递归，尝试别的路径

  1. 括号生成
class Solution(object):
	def generateParenthesis(self, n: int) -> List[str]:
		result = []
		self.backtracking(n, result, 0, 0, "")
		return result

	def backtracking(self, n, result, left, right, s):
		if right > left:
			return
		
		if (left == n and right == n):
			result.append(s)
			return
		
		if left < n:
			self.backtracking(n, result, left+1, right, s+"(")

		if right < n:
			self.backtracking(n, result, left, right+1, s+")")
  1. 子集

暴力法：

class Solution(object):
	# Time Complexity: O(N*2^N)
	# Space Complexity: O(N*2^N)
	def subsets(self, nums: List[int]) -> List[List[int]]:
		result = [[]]
		
		for num in nums:
			# result = result + [cur+[num] for cur in result]
			temp = []
			for cur in result:
				temp.append(cur+[num])
			for t in temp:
				result.append(t)
			
		return result

回溯法：

class Solution(object):
	# Time Complexity: O(N*2^N)
	# Space Complexity: O(N*2^N)
	def subsets(self, nums: List[int]) -> List[list[int]]:
		result = [[]]
		for i in range(1, len(nums)+1):
			self.backtracking(nums, result, i, 0, [])
		return result

	def backtracking(self, nums, result, length, index, subset):
		if len(subset) == lenth:
			result.append(subset[:])
			return
		
		for i in range(index, len(nums)):
			subset.append(nums[i])
			self.backtracking(nums, result, length, i+1, subset)
			subset.pop()

7.算法 - 深度优先搜索算法DFS

从root节点开始，尽可能深的搜索每一个分支（把一个分支的结果搜索完，再去看下一个分支）

  • 二叉树搜索
  • 图搜索

回溯算法 = DFS + 剪枝

  1. 子集
class Solution(object):
	# Time Complexity: O(N*2^N)
	# Space Complexity: O(N*2^N)
	def subsets(self, nums: List[int]) -> List[List[]]:
		result = []
		self.dfs(nums, result, 0, [])
		return result

	def dfs(self, nums, result, index, subset):
		result.append(subset[:])
		if index == len(nums);
			return
		for i in range(index, len(nums)):
			subset.append(nums[i])
			self.dfs(nums, result, i+1, subset)
			subset.pop()
  1. 岛屿数量
# R is the row of grid
# C is the column of grid
class Solution(object):
	# Time Complexity: O(RC)
	# Space Complexity: O(RC)
	def numIslands(self, grid: List[List[str]]) -> int:
		if grid is None or len(grid) == 0:
			return 0
		result = 0
		row = len(grid)
		col = len(grid[0])
		for i in range(0, row):
			for j in range(0, col):
				if grid[i][j] == '1':
					result = result + 1
					self.dfs(grid, i, j, row, col)
		return result
	
	def dfs(self, grid, x, y, row, col):
		if x < 0 or y < 0 or x >= row or y >= col or grid[i][j] == '0':
			return
		grid[x][y] = '0'
		self.dfs(grid, x-1, y, row, col)
		self.dfs(grid, x+1, y, row, col)
		self.dfs(grid, x, y-1, row, col)
		self.dfs(grid, x, y+1, row, col)

8.算法 - 广度优先搜索算法BFS

层层递进，一层一层遍历

  • 二叉树搜索
  • 图搜索
  1. 二叉搜索树的范围和
# Definition for a binary tree node.
# class TreeNode:
#	def __init__(self, val=0, left=None, right=None):
#		 self.val = val
#		 self.left = left
#		 self.right = right

class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(N)
	def rangeSumBST(self, root: TreeNode, low: int, high: int) -> int:
		result = 0
		queue = []
		queue.append(root)
		while len(queue) > 0:
			size = len(queue)
			while size > 0:
				cur = queue.pop()
				if cur.val >= low and cur.val <= high:
					result = result + cur.val
				if cur.left is not None:
					queue.append(cur.left)
				if cur.right is not None:
					queue.append(cur.right)
				size = size - 1
		return result
  1. 二叉树的层序遍历
from collections import deque

class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(N)
	def levelOrder(self, root: TreeNode) -> List[List[]]:
		result = []
		if roor is None:	
			return result
		
		q = deque([])
		q.append(root)
		while len(q) > 0:
			size = len(q)
			ls = []
			while size > 0:
				cur = q.popleft
				ls.append(cur.val)
				if cur.left is not None:
					q.append(cur.left)
				if cur.right is not None:
					q.append(cur.right)
				size = size - 1
			result.append(ls[:])
		return result
  1. 二叉树的层序遍历2
class Solution(object):
	# Time Complexity: O(N)
	# Space Complexity: O(N)
	def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
		result = []
		if root is None:
			return result
		
		q = deque([])
		q.append(root)
		temp = deque([])
		while len(q) > 0:
			size = len(q)
			ls = []
			while size > 0:
				cur = q.popleft()
				ls.append(cur.val)
				if cur.left is not None:
					q.append(cur.left)
				if cur.right is not None:
					q.append(cur.right)
				size = size - 1
			temp.appendleft(ls[:])
		result = list(temp)
		retutn result
  1. 岛屿数量
# R is the row of grid
# C is the column of grid
class Solution(object):
	# Time Complexity: O(RC)
	# Space Complexity: O(RC)
	def numIslands(self, grid: List[List[str]] -> int:
		if grid is None or len(grid) == 0:
			return 0
		result = 0
		row = len(grid)
		col len(grid[0])
		queue = []
		for i in range(0, row):
			for j in range(0, col):
				if grid[i][j] == '1':
					result = result + 1
					queue.append([i,j])
					grid[i][j] = '0'
					while len(queue) > 0:
						cur = queue.pop()
						x = cur[0]
						y = cur[1]
						if x-1 >= 0 and grid[x-1][y] == '1':
							queue.append([x-1, y])
							grid[x-1][y] = '0'
						if y-1 >= 0 and grid[x][y-1] == '1':
							queue.append([x][y-1])
							grid[x][y-1] = '0'
						if x+1 < row and grid[x+1][y] == '1':
							queue.append([x+1][y])
							grid[x+1][y] = '0'
						if y+1 < col and grid[x][y+1] == '1':
							queue.append([x][y+1])
							grid[x][y+1] = '0'
		return result

9.算法 - 并查集算法

Union:
合并两个元素为同一个根节点
Find:
找到某个元素的根节点

Union(x, y)
root Find(x)

  1. 岛屿数量
class Solution(object):
	# Time Complexity: O(RC)
	# Space Complexity: O(RC)
	def numIslands(self, grid: List[List[str]]) -> int:
		if grid is None or len(grid) == 0:
			return 0
		row = len(grid)
		col = lenj(grid[0])
		waters = 0
		uf = UnionFind(grid)
		for i in range(0, row):
			for j in range(0, col):
				if grid[i][j] == '0'
					waters += 1
				else:
					directions = [(0,1), (0,-1), (-1,0), (1,0)]
					for x, y in directions:
						x = x + i
						y = y + j
						if x>=0 and y>=0 and x<row and y<col and grid[x][y] == '1':
							uf.union(x*col+y, i*col+j)
		return uf.getCount() - waters

class UnionFind:
	def __init__(self, grid):
		row = len(grid)
		col = len(grid[0])
		self.root = [-1]*(row*col)
		self.count = row*col
		for i in range(0, row*col):
			self.root[i] = i
	def find(self, x):
		if x == self.root[x]:
			return self.root[x]
		else:
			self.root[x] = self.find(self.root[x])
			return self.root[x]
	def union(self, x, y):
		rootX = self.find(x)
		rootY = self.find(y)
		if rootX != rootY:
			self.root[rootX] = rootY
			self.count -= 1
	def getCount(self):
		return self.count
  1. 朋友圈

并查集优化

Quick Find

self.root[x] = self.find(self.root[x])
return self.root[x]

Quick Union - 权重
防止树太高
比较两个树的高
把矮的树连接到高的树上
使树的高度最低

if rootx != rooty:
	if self.rank[rootx] > self.rank[rooty]:
		root[rooty] = rootx
	elif self.rank[rootx] < self.rank[rooty]:
		root[rootx] = rooty
	else:
		root[rooty] = rootx
		self.rank[rootx] += 1

10.算法 - 贪心算法

每一步做出的都是当前看起来最好的选择
只是局部最优解
而不是整体的最优选择

  1. 零钱兑换

  2. 玩筹码

55.跳跃游戏

11.算法 - 记忆化搜索

减少重复计算

  1. 斐波那契数

  2. 零钱兑换

12.算法 - 动态规划

动态规划三要素

  • 初始状态
  • 方程式
  • 终止状态

  1. 计数：有多少种方法
    机器人从左上角到右下角有多少种路径

  2. 求最值：
    机器人从左到右路径的最大数字和

  3. 求存在性：是否存在某个可能
    是否存在机器人从左到右的路径

  4. 斐波那契数

  5. 不同路径

  6. 买卖股票的最佳时机

  7. 爬楼梯

  8. 完全平方数

  9. 最大正方形

学习视频来源B站—爱学习的饲养员—手把手带你刷Leetcode力扣

爱彻切尔
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
整理了一份最全的力扣刷题攻略（二）
weixin_44071377的博客
04-28 270
2.如果按照对应的知识点，可选择自己较为薄弱的算法知识针对性刷题；1.如果按照本文推荐的顺序逐一刷题，适合第一次系统性刷题的朋友；所以例举数组、链表、哈希表等 3 个知识点的刷题攻略展开；由于篇幅有限且也在不断完善题库，编辑/版式：pingping。
leetcode2sumc-leetcode:力扣算法
07-06
力扣算法 算法 队列 堆 树 数据结构 种类 二叉搜索树 广度优先搜索 设计 位操作 # 标题 解决方案 难度 标签 136 简单的 137 中等的 190 / 简单的 191 / 简单的 201 中等的 231 简单的 260 中等的 268 中等的 318 ...
❤️352❤️带新手一起刷力扣 (LeetCode)❤️代码有详细的注释❤️反思总结❤️352. 将数据流变为多个不相交区间
C/C++/Linux/MySQL
10-10 146
本文章是❤️力扣 (LeetCode)❤️的内容，该专栏还有多篇优质内容在等待你观看，现在点击右上角点击这个————????订阅专栏???? ????坚持刷算法 ????每天进步一点点 ????冲冲冲冲冲冲冲冲冲冲 ????刷力扣 (LeetCode)刷力扣 (LeetCode) 巧解力扣题目????????代码????????反思???????? 题目???????? 代码???????? typedef long long LL; const LL INF = 1e18; typedef pair
如何有效地做算法题
weixin_30246221的博客
01-11 3366
这篇文章最早发在我团队的文档中。我的团队鼓励每个同学都在业余时间多做算法题，特别是新人。个人认为在编程能力的提升上比做 side project 更有用，对职业发展也是如此。当然出于兴趣做的 side project 另当别论。转到这里，希望对各位读者有用。 如何有效地写算法题 目的 持续做算法题的目的仍然是自身能力提升。可以继续细化成三点: 保持思维敏捷。非常重要，状态好才能保持...
算法有救了！GitHub上神仙项目手把手带你刷算法
leeta的博客
08-02 305
算法有救了！！！ 前不久在 GitHub 出现了一个手把手带你刷 算法的项目：fucking-algorithm。该项目此前在 GitHub 开源后，连续多次霸榜 GitHub Trending 首页，用了一周Star数便突破 110k，受欢迎程度由此可见一斑： 仓库作者 labuladong 最先提出「刷题要掌握模板和套路」的观点，刷题就是应对面试拿 offer，再也别整什么《算法导论》这种花里胡哨的了。 还在为动态规划的一系列问题发愁吗？书中给动态规划总结出了一套框架模板，还有整整一个章节
LeetCode 刷题 （算法入门）
西西与贝贝
11-03 142
一、有序数组的进阶 方法三：双指针法 利用双指针，left和right从数组两端向中间遍历，每次将对应元素平方后比较大的值逆序存放在数组中 class Solution { public: vector<int> sortedSquares(vector<int>& nums) { int n = nums.size(); vector<int> ans(n);//初始化一个大小为n的数组 for (
lrucacheleetcode-LeetCode:力扣算法解决方案
06-29
力扣算法解决方案 二和 两个数字相加 无重复字符的最长子串 最长回文子串 之字形转换 3总和 从列表末尾删除第 N 个节点 合并两个排序列表 合并 k 个排序列表 有效数独 排列 组字谜 螺旋矩阵 合并间隔 独特的路径 ...
leetcode 力扣 1446 时钟指针的夹角 题解 算法题.docx
09-14
。。。
javalruleetcode-leetcode:力扣算法题解
06-29
力扣算法解题，java语言 题解 简单 序号(力扣题序号) 题名 题解 两数之和 整数反转 相同的树 最长回文串 链表的中间节点 三维形体的表面积 卡牌分组 可以被一步捕获的棋子数 不用加号的加法 最小的K个数 不用加减...
Python算法题源代码-LeetCode(力扣)-全排列
最新发布
02-26
力扣热题Python源代码 题目46. 全排列 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。 示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1...
leetcode中文版
08-26
leetcode中文版
【leetcode】算法刷题汇总
小朱小朱绝不认输的博客
06-01 1486
本篇总结的就是刷题过程中遇到的经典题目，以及对应的数据结构算法的学习。如果想按照数据结构进行刷题，可以参考：150道基础算法分类总结（2022）更新中……
手把手带你刷Leetcode力扣 学习总结
qq_39223444的博客
07-05 1525
文章目录1. 总体规划2. 算法复杂度2.1 时间复杂度2.2 空间复杂度3. 数据结构3.1 数组【Array】3.1.1 Python常用操作3.1.2 Java常用操作3.1.3 练习题3.2 链表【Linked List】3.2.1 Python常用操作3.2.2 Java常用操作3.2.3 练习题3.3 队列【Queue】3.3.1 Python常用操作3.3.2 Java常用操作3.3.3 练习题3.4 栈【Stack】3.4.1 Python常用操作3.4.2 Java常用操作3.4.3 练习
手把手教您刷力扣，击破数据结构和算法--笔记
wc19862274581的博客
02-28 173
强推学习视频： 手把手带你刷Leetcode力扣｜各个击破数据结构和算法｜大厂面试必备技能【已完结】_哔哩哔哩_bilibili「力扣」8.5折优惠链接：https://leetcode-cn.com/premium/?promoChannel=siyangyuan其他相关合集：手把手带你刷力扣+数据结构+算法合集：BV1sy4y1q79MLeetcode力扣 1-300题视频讲解合集：BV1xa411A76qLeetcode力扣301+题视频讲解合集：BV1eK4y1j7fTLeetcode力扣常用算法
力扣算法刷题（一）——Array
Super_Yiang的博客
02-10 461
一、数组删除 1）【27】移除元素 题目链接：https://leetcode-cn.com/problems/remove-element/ 我的解： class Solution { public int removeElement(int[] nums, int val) { if(nums.length==0){ return 0; ...
刷完 900 多道算法题的首次总结：LeetCode 应该怎么刷？
热门推荐
负雪明烛
03-29 12万+
LeetCode 算法题应该怎么刷？算法题学习路线？怎么组队刷题？有没有算法刷题群？ 你是怎么入门 LeetCode 的？刷完 1000 道算法题是什么体验？大家都是怎么刷题的？ 新手小白开始刷算法题应该怎么刷，注意什么？刷 LeetCode 总是觉得太难怎么办？ 刷算法题有没有书籍推荐？该按照什么顺序刷算法题？LeetCode 怎么看别人的题解？有哪些好的算法题博主推荐？
力扣（LeetCode）77. 组合（2022.03.18）
ChaoYue_miku的博客
03-18 1054
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 示例 1： 输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ] 示例 2： 输入：n = 1, k = 1 输出：[[1]] 提示： 1 <= n <= 20 1 <= k <= n 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/com
如何刷Leetcode?【从400到700到900的全网总结篇】
sinat_29950703的博客
08-30 1255
本篇汇总了以下四篇如何刷leetcode的方法 如何两个月刷400道leetcode 刷完700多题后的首次总结：LeetCode应该怎么刷？ 写于LeetCode刷完900题之际的感想 LeetCode小白如何上手刷题？ 前言 随着互联网寒潮的到来, 越来越多的互联网公司提高了面试的难度，其中之一就是加大了面试当中手撕算法题的比例。这里说的算法题不是深度学习，机器学习这类的算法，而是排序，广度优先，动态规划这类既考核数据结构也考核编程能力的题目。刷题的网址非常的多，其中以leetcode是最为出名的。 在
一周刷爆leetcode,算法大神左神
09-06
一周刷爆LeetCode的算法大神左神是指左程云。他耗时100天打造了算法与数据结构基础到高级全家桶教程，详细解析了一线大厂必问的算法面试题真题，并提供了相关的代码和讲义。他的教程中包括了复杂度和简单排序算法的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值