UP讲的很好，推荐大家去看。

1. 总体规划

2. 算法复杂度

2.1 时间复杂度

1. 什么是时间复杂度？
   算法的执行效率
   算法的执行时间与算法的输入值之间的关系
2. 常见时间复杂度案例分析
   
   O(1):与num无关
   
   O(n)
   
   O(log n):2的n次方等于num。典型：二分查找
   
   O(m+n)：循环并列，相加
   
   O(nlogn):循环嵌套，相乘。典型：排序
   
   O(n2n^2n2)
3. 常见时间复杂度对比
   

2.2 空间复杂度

1. 什么是空间复杂度？
   算法的存储空间与算法的输入值之间的关系
   占空间的都是声明出来的变量

2. 常见空间复杂度案例分析
   
   变量是常量：O(1)
   
   变量是array、list等，递归：O(n)

3. 常见空间复杂度对比
   
   时间和空间只能二选一
   面试时：和面试官讲清楚
   工作时：时间>空间

3. 数据结构

3.1 数组【Array】

数组：在连续的内存空间中，存储一组相同类型的元素。

特点： 适合读，不适合写------读多写少

3.1.1 Python常用操作

1. 创建数组
   

2. 添加或插入元素
   
   中间添加,插入：O(n)
   尾部添加，添加：O(1)

3. 访问元素
   

4. 更新元素
   

5. 删除元素
   
   remove:查找所需要的元素，然后删除，O(n)
   pop(i):删除i索引的值，但剩余元素需要移位，O(n)
   pop():删除最后一个，O(1)

6. 获取数组长度
   

7. 遍历数组
   

8. 查找某个元素
   

9. 数组排序
   
   a.sort()，会直接改变a
   sorted(a)，不会改变

3.1.2 Java常用操作

3.1.3 练习题

485 最大连续1的个数

283 移动零

class Solution(object):def moveZeroes(self, nums):""":type nums: List[int]:rtype: None Do not return anything, modify nums in-place instead."""for i in nums:if i==0:nums.remove(0)nums.append(0)return nums

27 移除元素

class Solution:def removeElement(self, nums, val):if nums is None or len(nums)==0:return 0l,r = 0, len(nums)-1while l<r:while(l<r and nums[l] != val):l=l+1while(l<r and nums[r] == val):r=r-1nums[l],nums[r] = nums[r],nums[l]return l if nums[l]==val else l+1

class Solution:def removeElement(self, nums, val):for i in range(len(nums)-1,-1,-1):if nums[i] == val:nums.remove(nums[i])

3.2 链表【Linked List】

单端链表 √
双端链表 leetcode一般不用

特点： 适合写，不适合读------读少写多

3.2.1 Python常用操作

1. 创建链表
   
2. 添加元素
   
3. 访问元素
   
4. 搜索元素：返回索引
   
5. 更新元素
   
6. 删除元素
   
7. 长度
   

3.2.2 Java常用操作

3.2.3 练习题

203 移除链表元素

class Solution:def removeElements(self, head: ListNode, val: int) -> ListNode:dummy = ListNode(0)dummy.next = headprev = dummywhile head is not None:if head.val == val:prev.next = head.nexthead = head.nextelse:prev = headhead = head.next return dummy.next

206 反转链表

class Solution:def reverseList(self, head: ListNode) -> ListNode:dummy = ListNode(0)dummy.next = headwhile head is not None and head.next is not None:dnext = dummy.nexthnext = head.nextdummy.next = hnexthead.next = hnext.nexthnext.next = dnextreturn dummy.next

3.3 队列【Queue】

插入删除只能在头尾，所以时间复杂度：O(1)

3.3.1 Python常用操作

1. 创建队列
   
2. 添加元素
   
3. 获取即将出队的元素
   
4. 删除即将出队的元素
   
5. 判断队列是否为空
   
6. 队列长度
   len(queue)
7. 遍历队列
   

3.3.2 Java常用操作

3.3.3 练习题

933 最近的请求次数

class RecentCounter:def __init__(self):self.q = deque()def ping(self, t: int) -> int:self.q.append(t)while len(self.q)>0 and t-self.q[0]>3000:self.q.popleft()return len(self.q)

3.4 栈【Stack】

3.4.1 Python常用操作

1. 创建栈
   

2. 添加元素
   

3. 查看栈顶元素-即将出栈的元素
   

4. 删除栈顶元素
   

5. 栈的大小
   

6. 栈是否为空
   

7. 栈的遍历
   

3.4.2 Java常用操作

3.4.3 练习题

20 有效的括号

class Solution:def isValid(self, s: str) -> bool:if len(s)==0:return Truestack= []for c in s:if c == "(" or c == "[" or c == "{":stack.append(c)else:if len(stack) == 0:return Falseelse:temp = stack.pop()if c == ")":if temp != "(":return Falseelif c == "]":if temp != "[":return False elif c == "}":if temp != "{":return False   return True if len(stack) == 0 else False

496 下一个更大元素（栈+队列）

class Solution:def nextGreaterElement(self，nums1: List[int]，nums2: List[int]) -> List[int]:res =[]stack = []for num in nums2:stack.append( num)for num in nums1:temp =[]isFound = FalsenextMax = -1while ( len(stack) != 0 and not isFound ) :top = stack.pop()if top > num:nextMax = topelif top ==num :isFound = Truetemp.append( top)res.append( nextMax)while len(temp) != 0:stack.append(temp. pop( ))return res

3.5 哈希表【Hash Table】

3.5.1 Python常用操作

1. 创建哈希表：数组或字典
   
2. 添加元素
   
3. 删除元素
   
4. 修改元素
   
5. 获取key的值
   
6. 检查key是否存在
   
7. 哈希表长度
8. 哈希表是否还有元素
   

3.5.2 Java常用操作

3.5.3 练习题

217 存在重复元素

class Solution:def containsDuplicate(self, nums: List[int]) -> bool:if len(nums) == 0:return Falsedict = {}for num in nums:if num not in dict:dict[num] = 1else:dict[num] = dict[num]+1for v in dict.values(): if v>1:return True   return False

389 找不同

class Solution:def findTheDifference(self, s: str, t: str) -> str:if len(s) == 0:return t table = [0]*26for i in range(len(s)):table[ord(s[i])-ord('a')] -= 1for j in range(len(t)):table[ord(t[j])-ord('a')] += 1for k in range(26):if table[k] == 1:ascii = k+ord('a')return chr(ascii)

496 下一个更大元素

class Solution:def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:stack,hash = [],{}res = []for i in nums2:while len(stack) != 0 and i>stack[-1]:temp = stack.pop()hash[temp] = i stack.append(i)while len(stack) != 0:hash[stack.pop()] = -1for num in nums1:res.append(hash[num])return res

3.6 集合【Set】

无序 不重复
主要作用：
检查某一个元素是否存在
重复元素

3.6.1 Python常用操作

1. 创建集合
   
2. 添加元素
   
3. 搜索元素
   
4. 删除元素
   
5. 长度
   

3.6.2 Java常用操作

3.6.3 练习题

217 存在重复元素

class Solution:def containsDuplicate(self, nums: List[int]) -> bool:set1 = set(nums)if len(set1) == len(nums):return Falseelse:return True

705 设计哈希集合

class MyHashSet:def __init__(self):"""Initialize your data structure here."""self.hashset = [False]*1000001def add(self, key: int) -> None:self.hashset[key]=Truedef remove(self, key: int) -> None:self.hashset[key]=Falsedef contains(self, key: int) -> bool:"""Returns true if this set contains the specified element"""return self.hashset[key]

3.7 树【Tree】

** 满二叉树的所有叶子节点必须在同一层上。**
满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。

3.8 堆【Heap】

一般删除和搜索都是针对堆顶元素。






生成完全二叉树和变成最小堆的过程是并列的，都是O(n)，取一个即可。

3.8.1 Python常用操作

1. 创建堆（最大堆|最小堆）
2. 添加元素
3. 获取堆顶元素
4. 删除堆顶元素
5. 堆的长度
6. 堆的遍历
   
   Python里面没有直接生成最大堆的，要把数字全部取反，形成最小堆后再全部取反。

3.8.2 Java常用操作

3.8.3 练习题

215 数组中第k个最大元素

这是堆的方法

import heapqclass Solution:def findKthLargest(self, nums: List[int], k: int) -> int:heap = []heapq.heapify(heap)for num in nums:heapq.heappush(heap,num*-1)while k>1:heapq.heappop(heap)k=k-1return heapq.heappop(heap)*-1

可以直接调用函数

class Solution:def findKthLargest(self, nums: List[int], k: int) -> int:nums.sort()return nums[len(nums)-k]

692 前k个高频单词

最大堆的思想是把元素全放在堆中，然后从堆顶一个一个取最大元素

最小堆的的思想是加生成堆的过程中把堆顶的小元素剔除，堆里只剩所需的k个元素，然后再取出。

只放置k个，加元素的过程中当元素个数大于k时把现有堆的最小值删掉。

import heapq
class Solution:def topKFrequent(self, words: List[str], k: int) -> List[str]:mapping = {}for word in words:if word not in mapping:mapping[word] = 0mapping[word] = mapping[word] + 1print(mapping)heap = []heapq.heapify(heap)for key,value in mapping.items():heapq.heappush(heap,Node(key,value))if len(heap)>k:heapq.heappop(heap)res = []print(len(heap))while len(heap)>0:temp = heapq.heappop(heap)print(temp.key,":",temp.value)res.append(temp.key)res.reverse()return res

3.9 图【Graph】

度是一个节点的几条边。

3.10 数据结构知识点回顾

对比数据结构，特点，优缺点，复杂度

4. 算法

4.1 双指针

4.1.1 算法

普通双指针： O(n^2)

对撞双指针： 有序时考虑，O(n)

快慢双指针： 环形链表，快慢指针可相遇

4.1.2 练习题

141 环形链表

class Solution:def hasCycle(self, head: ListNode) -> bool:if head is None:return Falseslow = headfast = headwhile fast is not None and fast.next is not None:fast = fast.next.nextslow = slow.nextif slow == fast:return Truereturn False

881 救生艇

对撞指针

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

4.2 二分查找

4.2.1 算法

O(log n)

4.2.2 练习题

704 二分查找

普通解法：O(n)

class Solution:def search(self, nums: List[int], target: int) -> int:for i in range(len(nums)):if nums[i] == target:return ireturn -1

二分法：O(logn)

class Solution:def search(self, nums: List[int], target: int) -> int:if nums is None or len(nums) == 0:return -1L = 0R = len(nums) - 1while L <= R:mid = L + (R - L ) // 2if nums[mid] == target:return midelif nums[mid] > target:R = mid-1else:L = mid+1return -1

35 搜索插入位置

常规方法：

        if nums ==None or len( nums) == 0:return 0prev = -1for i in range( len( nums )):if nums[i] == target:return ielif nums[i] < target:prev = ielse:return prev+1return prev+1

二分法

class Solution:def searchInsert(self, nums: List[int], target: int) -> int:if nums ==None or len( nums) == 0:return 0left = 0right = len(nums)while( left < right):mid = left + ( right - left)//2if nums[mid] == target:return midelif nums[mid] > target:right = midelse:left = mid + 1return left

自己的解法（菜狗的解法）

class Solution:def searchInsert(self, nums: List[int], target: int) -> int:L = 0R = len(nums) - 1while L <= R:mid = L + (R - L ) // 2if nums[mid] == target:return midelif nums[mid] > target :if mid-1 < 0 or nums[mid - 1] < target:return midelse:R = mid-1else:if mid+1 == len(nums) or nums[mid + 1] > target:print(mid+1)return mid+1else:L = mid+1

162 寻找峰值

class Solution:def findPeakElement(self, nums: List[int]) -> int:if nums is None or len(nums) == 0:returnleft = 0right = len(nums)-1while left < right:mid = left+(right-left)//2if nums[mid] > nums[mid+1]:right = midelse:left = mid + 1return  left

74 搜索二维矩阵

4.3 滑动窗口（技巧）

目的：减少while循环

4.3.1 算法

4.3.2 练习题

209 长度最小的子数组

class Solution:def minSubArrayLen(self, target: int, nums: List[int]) -> int:if nums is None or len(nums) == 0:return 0res = len(nums)+1i=0j=0total = 0while j<len(nums):total = total+nums[j]j = j+1while total >= target:res = min(res,j-i)total = total - nums[i]i = i+1if res == len(nums)+1:return 0else:return res

1456 定长子串中元音的最大数组

class Solution:def maxVowels(self, s: str, k: int) -> int:if s is None or len(s) == 0 or len(s)<k:return 0hashset = set(['a','e','i','o','u'])count = 0res = 0for i in range(0,k):if s[i] in hashset:count = count+1res = max(res,count)for i in  range(k,len(s)):out = s[i-k]inc = s[i]if out in hashset:count = count - 1if inc in hashset:count = count + 1res = max(res,count)return res

4.4 递归 recursion

4.4.1 算法

时间复杂度：O(n^20)
空间复杂度：O(n)

4.4.2 练习题

509 斐波那契数列

class Solution:def fib(self, n: int) -> int:if n < 2:return 1 if n==1 else 0sum = self.fib(n-1) + self.fib(n-2)return sum

206 反转链表

class Solution:def reverseList(self, head: ListNode) -> ListNode:if head is None or head.next is None:return headp = self.reverseList(head.next)head.next.next = headhead.next = Nonereturn p

344 反转字符串

class Solution:def reverseString(self, s: List[str]) -> None:self.recursion(s,0,len(s)-1)def recursion(self,s,left,right):if left>=right:returnself.recursion(s,left+1,right-1)s[left],s[right] = s[right],s[left]

# 双指针
class Solution:def reverseString(self, s: List[str]) -> None:"""Do not return anything, modify s in-place instead."""l = 0r = len(s)-1while l < r:s[l],s[r] = s[r],s[l]l += 1r -= 1return s

4.5 分治法（divide & conquer）

4.5.1 算法

归并排序

4.5.2 练习题

169 多数元素

# 排序法
class Solution:def majorityElement(self, nums: List[int]) -> int:nums.sort()half = len(nums)//2return nums[half]

# 哈希表
class Solution:def majorityElement(self, nums: List[int]) -> int:hashset = {}for i in nums:if i not in hashset:hashset[i] = 0hashset[i] = hashset[i] + 1half = len(nums)//2for key in hashset.keys():if hashset[key] > half:return keyreturn -1

53 最大子序列

class Solution:def maxSubArray(self, nums: List[int]) -> int:# 暴力法1，超时# count = 1# max1 = float('-inf')# while count<=len(nums):#     for i in range(0,len(nums)-count+1):#         sum1 = sum(nums[i:i+count])#         max1 = max(max1,sum1)#     count += 1# return max1  # 暴力法2，超时result = float('-inf')for i in range(0,len(nums)):temp = 0for j in range(i,len(nums)):temp = temp+nums[j]result = max(result,temp)return result

class Solution:def maxSubArray(self, nums: List[int]) -> int:for i in range(1, len(nums)):nums[i]= nums[i] + max(nums[i-1], 0)return max(nums)

4.6 回溯法（Backtracking）

4.6.1 算法

回溯法也是一种递归，要有终止条件。

4.6.2 练习题

22 括号生成

78 子集

回溯法

class Solution:def subsets(self, nums: List[int]) -> List[List[int]]:for i in range(1,len(nums)+1):self.backtracking(nums,result,i,0,[])return resultdef backtracking(self,nums,result,length,index,subset):if len(subset) == length:result.append(subset[:])returnfor i in  range(index,len(nums)):subset.append(nums[i])self.backtracking(nums,result,length,i+1,subset)subset.pop()

扩展法

class Solution:def subsets(self, nums: List[int]) -> List[List[int]]:result = [[]]for num in nums:temp=[]for cur in result:temp.append(cur+[num])for t in temp:result.append(t)return result

深度优先算法

class Solution:def subsets(self, nums: List[int]) -> List[List[int]]:result=[]self.dfs(nums,result,0,[])return resultdef dfs(self,nums,result,index,subset):result.append(subset[:])if index == len(nums):returnfor i in range(index,len(nums)):subset.append(nums[i])self.dfs(nums,result,i+1,subset)subset.pop()

77 组合

46 全排列

八皇后 数独

4.7 深度优先搜索（DFS）

4.7.1 算法

回溯是走到一定程度就不走了，DFS是一直走到底。

4.7.2 练习题

78 子集

200 岛屿数量

DFS:

class Solution:def numIslands(self, grid: List[List[str]]) -> int:if grid is None or len(grid) == 0:return 0result = 0row = len(grid)col = len(grid[0])for i in range(0,row):for j in range(0,col):if grid[i][j] == '1':result += 1self.dfs(grid,i,j,row,col)return resultdef dfs(self,grid,x,y,row,col):if x<0 or y<0 or x>= row or y>= col or grid[x][y] == '0':returngrid[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)

BFS：

class Solution:def numIslands(self, grid: List[List[str]]) -> int:if grid is None or len(grid) == 0:return 0result = 0row = len(grid)col = len(grid[0])q = []for i in range(0,row):for j in range(0,col):if grid[i][j] == '1':result += 1q.append([i,j])grid[i][j] == '0'while len(q)>0:cur = q.pop()x = cur[0]y = cur[1]if x-1 >= 0 and grid[x-1][y] == '1':q.append([x-1,y])grid[x-1][y] == '0'if y-1 >= 0 and grid[x][y-1] == '1':q.append([x,y-1])grid[x][y-1] == '0'if x+1 < row and grid[x+1][y] == '1':q.append([x+1,y])grid[x+1][y] == '0'if y+1 < col and grid[x][y+1] == '1':q.append([x,y+1])grid[x][y+1] == '0'return result

4.8 广度优先搜索（BFS）

4.8.1 算法

4.8.2 练习题

938 二叉搜索树的范围和

递归法：



BFS：一般会和队列结合使用

4.9 动态规划

4.9.1 算法

4.9.2 练习题

4.10 前缀树（Trie）

4.10.1 算法

4.10.2 练习题

4.11 并查集

4.12 并查集优化

4.13 贪心算法

哈希表：某个字符在数组里出现的次数
第几大：堆
有序时：对撞指针
找到所有的：回溯法
遍历查询某个值：可以通过赋值防止被再次遍历

参考链接：手把手带你刷Leetcode力扣

手把手带你刷Leetcode力扣 学习总结相关推荐

1. 【手把手带你刷Leetcode力扣】10.数据结构 -图

   图: 顶点 邻居节点 边 度:边的数量 无向图 有向图 入度:指向该顶点的边的数量 出度:以该顶点为起点指向别的顶点的边的数量 权重图 最短路径 贝尔曼-福特算法(Bellman-Ford) 迪克斯特 ...

2. 东哥手把手带你刷二叉树|第三期

   学算法认准 labuladong 后台回复进群一起力扣???? 读完本文,你可以去力扣解决: 652.寻找重复子树(Medium) 接前文 手把手带你刷二叉树(第一期)和 手把手带你刷二叉树(第二期) ...

3. IDEA的LeetCode力扣插件设置与使用（超详细）

   目录 一.下载插件 二.插件配置 注意 三.插件使用  欢迎大家来学习和使用LeetCode力扣插件!!! 这几天准备刷算法题,突然发现了IDEA插件商城里面有LeetCode力扣的插件,于是就下载下 ...

4. 1.1机器学习和深度学习综述(百度架构师手把手带你零基础实践深度学习原版笔记系列)

   人工智能.机器学习.深度学习的关系 近些年人工智能.机器学习和深度学习的概念十分火热,但很多从业者却很难说清它们之间的关系,外行人更是雾里看花.在研究深度学习之前,我们先从三个概念的正本清源开始. 概 ...

5. 《LeetCode力扣练习》剑指 Offer 30. 包含min函数的栈 Java

   <LeetCode力扣练习>剑指 Offer 30. 包含min函数的栈 Java 一.资源 题目: 定义栈的数据结构,请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中,调 ...

6. 《LeetCode力扣练习》剑指 Offer 29. 顺时针打印矩阵 Java

   <LeetCode力扣练习>剑指 Offer 29. 顺时针打印矩阵 Java 一.资源 题目: 输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字. 示例 1: 输入:matr ...

7. 《LeetCode力扣练习》第96题 不同的二叉搜索树 Java

   <LeetCode力扣练习>第96题 不同的二叉搜索树 Java 一.资源 题目: 给你一个整数 n ,求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种?返回 ...

8. 《LeetCode力扣练习》剑指 Offer 28. 对称的二叉树 Java

   <LeetCode力扣练习>剑指 Offer 28. 对称的二叉树 Java 一.资源 题目: 请实现一个函数,用来判断一棵二叉树是不是对称的.如果一棵二叉树和它的镜像一样,那么它是对称的 ...

9. 《LeetCode力扣练习》剑指 Offer 27. 二叉树的镜像 Java

   <LeetCode力扣练习>剑指 Offer 27. 二叉树的镜像 Java 一.资源 题目: 请完成一个函数,输入一个二叉树,该函数输出它的镜像. 例如输入: 4 / 2 7 / \ / ...

最新文章

1. 30天敏捷结果（27）：做些有重要意义的事
2. 2.6_Database Interface JDBC及驱动类型
3. java中filereader读取文件_java – 如何使用FileReader逐行读取
4. JZOJ 5305. 【NOIP2017提高A组模拟8.18】C
5. 物联网将成为第四次工业革命的基石
6. 信息学奥赛一本通（2033：【例4.19】阶乘之和）
7. ubuntu 重装系统备份数据 ubuntu安装kde桌面
8. 计算机组成原理笔记（王道考研） 第三章：存储系统
9. win11toast：python桌面通知工具
10. C#控制定位Word光标移动到任意行或者最后一行，取得光标位置等操作
11. html语言hr标记,HTML水平线段HR标记详解
12. 线性方程组的直接解法
13. Python画玫瑰花源码
14. 「建模学习」游戏中的场景建模，原来是靠3D扫描建模技术完成？
15. 概率论与数理统计(3.4) 相互独立的随机变量
16. 多元线性回归之预测房价
17. css使用ttf字体
18. 如何将express搭建的后台代码部署到服务器域名访问
19. 长期在电脑面前喝什么茶好
20. Macbook Pro M1安装Homebrew跟git安装

热门文章

1. Android自动开关机实现, AlarmManager实现开关机闹钟
2. vue+element表头根据查询条件动态改变
3. 表格文字自动对齐 html6,Excel文字对齐技巧：学会这6种方式，快速整理规范表格...
4. java聊天室代码_java聊天室的实现代码
5. 著名书画家、国家一级美术师宋峰长卷作品获拍182万
6. 内蒙古农业大学计算机学院老师黑名单,内蒙古农业大学计算机与信息工程学院2020年考研调剂信息...
7. 【无标题】amd卡顿，黑屏，解决办法
8. 给你个抽奖活动，概率你该如何设置？
9. vue手机端开发聚焦不灵敏
10. 潇洒老师总结的汽车发动机结构种类汇总