文章目录
- 快速排序
- 归并排序
- 冒泡排序
- 二分查找
- 二分查找的拓展——上下界与个数问题
- 最小生成树
- 线段树和树状数组的异同
- 两个栈模拟队列和双端队列
- 最长上升子序列,dp实现,nlogn实现
- 快排时间复杂度和空间复杂度
- 布隆过滤器知道吗?用在什么场景下?推导会么(加分项)
- K个链表归并
- 二叉树前序中序遍历,重建二叉树
- 二叉树的前序遍历和中序遍历的非递归实现
- 哈希表相关
- 大数相加,大数相乘
- 判断完全二叉树、满二叉树、二叉搜索树BST
- 链表反转
- 反转二叉树(镜像二叉树)
- 稳定和非稳定的排序算法有哪些
- 二分查找递归和非递归的时间和空间复杂度
- 输入补全可以用哪个数据结构来做
- 编辑距离
- 和等于 k 的最短子数组长度
- 判断是否为对称二叉树
- 旋转数组:不用额外内存
- 二叉树的序列化与反序列化
- 第k大的数,两种做法 (quick select, heap)
- 判断链表是否有环以及环的位置,证明
- 青蛙跳台阶+有一次后退机会
- 最长公共子串、最长公共子序列
- 二叉树路径最大和
- 蓄水池采样问题
- 2 sum,3 sum
- 一个排序数组能够构成多少个二叉搜索树
- 分解质因数
快速排序
参考:快速排序partition过程常见的两种写法+快速排序非递归实现
import random
def partition(arr, low, high):
r=random.randint(low,high) # 随机选[low,high]内的数与arr[low]交换
arr[r],arr[low]=arr[low],arr[r]
pivot=arr[low]
while low < high:
while low < high and arr[high] >= pivot:
high-=1
arr[low] = arr[high]#从后面开始找到第一个小于pivot的元素,放到low位置
while low < high and arr[low] <= pivot:
low+=1
arr[high] = arr[low]#从前面开始找到第一个大于pivot的元素,放到high位置
arr[low] = pivot#最后枢纽元放到low的位置
return low
def quick_sort(arr, low, high):
if low < high:
mid = partition(arr, low, high)
quick_sort(arr, low, mid-1)
quick_sort(arr, mid+1, high)
归并排序
def merge(left, right):
"""合并两个已排序好的列表,产生一个新的已排序好的列表"""
result = [] # 新的已排序好的列表
i = 0 # 下标
j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
def merge_sort(seq):
if len(seq) <= 1:
return seq
mid = len(seq) // 2 # 将列表分成更小的两个列表
# 分别对左右两个列表进行处理,分别返回两个排序好的列表
left = merge_sort(seq[:mid])
right = merge_sort(seq[mid:])
# 对排序好的两个列表合并,产生一个新的排序好的列表
return merge(left, right)
冒泡排序
def bubble_sort(arr):
n = len(arr)
# 进行n次冒泡,每次排好一个
for i in range(n):
# 最后 i 个已经有序
for j in range(0, n-i-1):
if arr[j] > arr[j+1] :
arr[j], arr[j+1] = arr[j+1], arr[j]
二分查找
def binary_search(array,t):
low = 0
high = len(array)-1
while low <= high:
mid = (low+high)//2
if array[mid] < t:
low = mid + 1
elif array[mid] > t:
high = mid - 1
else:
return mid
return -1
二分查找的拓展——上下界与个数问题
1、二分查找总结
2、二分查找算法及其扩展
3、二分查找的坑点与总结
注意点:
1、(low+high)/2
容易溢出
2、注意边界条件即各个while
中的不等号处理
最小生成树
TODO
线段树和树状数组的异同
TODO
两个栈模拟队列和双端队列
栈 s1, s2 实现队列
(后)入队操作:
将元素压入s1
(前)出队操作:
if s2不为空:
弹出栈顶元素
elif s1不为空:
将s1的元素逐个倒入s2,但最后一个元素弹出后直接返回而不用压入s2
else:
抛出队列为空的异常
双端队列:
栈 s1, s2 实现双端队列
后入队操作:
将元素压入s1
前入队操作:
将元素压入s2
前出队操作:
if s2不为空:
弹出栈顶元素
elif s1不为空:
将s1的元素逐个倒入s2,但最后一个元素弹出后直接返回而不用压入s2
else:
抛出队列为空的异常
后出队操作:
if s1不为空:
弹出栈顶元素
elif s2不为空:
将s2的元素逐个倒入s1,但最后一个元素弹出后直接返回而不用压入s1
else:
抛出队列为空的异常
最长上升子序列,dp实现,nlogn实现
TODO
快排时间复杂度和空间复杂度
最好情况是选中的pivot为中值,因此划分均衡
最坏情况是选中的pivot为最小值或最大值,导致每次划分为1个和 剩余
若选取pivot的方法是直接用low或high位置的元素,则最坏情况=数组有序,避免方法是随机选取pivot
时间复杂度:
平均情况下是 ,最坏情况下(数组有序)是
空间复杂度:
快排的实现是递归调用的, 而且每次函数调用中只使用了常数的空间,因此空间复杂度等于递归深度,在和平均情况下为 ,为
布隆过滤器知道吗?用在什么场景下?推导会么(加分项)
K个链表归并
题目:https://leetcode.com/problems/merge-k-sorted-lists/submissions/
参考:https://leetcode.com/problems/merge-k-sorted-lists/discuss/10511/10-line-python-solution-with-priority-queue
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
import queue
class Solution(object):
def mergeKLists(self, lists):
# 我们放入队列的元素是(node.val,node),如果有相同val的node,就会调用node的比较方法
ListNode.__lt__ = lambda x, y: True if x.val < y.val else False
dummy = ListNode(None)
curr = dummy
q = queue.PriorityQueue()
for node in lists:
if node is not None:
q.put((node.val,node))
while q.qsize()>0:
curr.next = q.get()[1]
curr=curr.next
if curr.next is not None:
q.put((curr.next.val, curr.next))
return dummy.next
二叉树前序中序遍历,重建二叉树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if inorder:
ind = inorder.index(preorder.pop(0))
root = TreeNode(inorder[ind])
root.left = self.buildTree(preorder, inorder[0:ind])
root.right = self.buildTree(preorder, inorder[ind+1:])
return root
一般的实现是将preorder划分两部分给左右子树的构建,但是这里用pop()弹出了结点,而且是先对左子树构建,所以到了右子树的时候,preorder中左子树的所有结点刚好pop完了
注意:若给前序和中序,直接问后序遍历的结果,可以先建树,然后再后序遍历。
二叉树的前序遍历和中序遍历的非递归实现
参考:https://blog.csdn.net/Applying/article/details/84982712
前序遍历
# 二叉树结点定义见前面的《二叉树前序中序遍历,重建二叉树 》
class Solution:
def preorderTraversal(self, root: TreeNode) -> List[int]:
res = []
if root is None:
return res
stack = []
stack.append(root)
while len(stack)!=0:
p = stack.pop()
# 访问,即加入结果list
res.append(p.val)
# 这里注意,要先压入右子节点,再压入左节点
if p.right is not None:
stack.append(p.right)
if p.left is not None:
stack.append(p.left)
return res
# 二叉树结点定义见前面的《二叉树前序中序遍历,重建二叉树 》
class Solution:
def inorderTraversal(self, root: TreeNode) -> List[int]:
res=[]
if root is None:
return res
stack = []
p = root
# 栈非空 或 p非空
while len(stack)!=0 or p is not None:
# 向左搜索,寻找最左的节点,即中序遍历的第一个节点
while p is not None:
stack.append(p)
p = p.left
# 对每一个节点进行判断
if len(stack)!=0:
# 访问当前节点
r = stack.pop()
res.append(r.val)
# 遍历其右子树
p = r.right
return res
哈希表相关
解决哈希冲突:
- 开放定址法
- 线性探测法
- 平方探测法
- 链地址法
常用哈希函数:课本常介绍除留余数法,Fasttext用的是FNV-1a,文件校验常用MD5、SHA-1
大数相加,大数相乘
TODO
判断完全二叉树、满二叉树、二叉搜索树BST
判断二叉树是否为完全二叉树
以层次遍历的方法, 找到第一个两个儿子不都存在的节点
if 此节点没有左子树且有右子树:
不是完全二叉树
else 看下一个节点:
如果下一个节点是叶子,则是完全二叉树,否则不是完全二叉树
判断是否为满二叉树
# 返回是否为满二叉树以及该树的最大深度
def is is_full(p):
if p is None:
return True, 0
else:
lres, lhei = is_full(p.left)
rres, rhei = is_full(p.right)
if lres and rres and lhei==rhei: # 左子树和右子树都是满二叉树且高度相等
return True, lhei+1
else:
return False, max(lhei, rhei)+1
判断是否为BST
中序遍历的结果若有序则是BST,否则不是
链表反转
头插法
反转二叉树(镜像二叉树)
交换树中所有节点的左右子节点,即得到树的镜像。
def invert(root):
if root is None:
return root
tmp = root.left
root.left = invert(root.right)
root.right= invert(tmp)
return root
稳定和非稳定的排序算法有哪些
稳定算法包括:归并、冒泡、插入、基数。“归泡插基”
二分查找递归和非递归的时间和空间复杂度
非递归:时间 ,空间
递归:时间 ,空间
输入补全可以用哪个数据结构来做
字典树,见:如何实现搜索框的关键词提示功能
编辑距离
和等于 k 的最短子数组长度
要求:如果用动态规划要优化时间,用贪心法需要证明
Leetcode有道类似的:
判断是否为对称二叉树
def sym(p, q):
if p is None and q is None:
return True
elif p is not None and q is not None:
# 对称的条件:p和q的值相同,并且p的左子树与q的右子树对称,p的右子树与q的左子树对称
return (p.val == q.val) and sym(p.left,q.right) and sym(p.right,q.left)
return False
class Solution:
def isSymmetric(self, root: TreeNode) -> bool:
return root is None or sym(root.left,root.right)
旋转数组:不用额外内存
def reverse(nums,low,high):
while low < high:
nums[low], nums[high] = nums[high], nums[low]
low+=1
high-=1
class Solution:
# Do not return anything, modify nums in-place instead.
def rotate(self, nums: List[int], k: int) -> None:
k %= len(nums)
reverse(nums, 0, len(nums)-1)
reverse(nums, 0, k - 1)
reverse(nums, k, len(nums) - 1)
二叉树的序列化与反序列化
第k大的数,两种做法 (quick select, heap)
在从小到大排序后的数组中,第 大的数是从 开始算的第 小的数,下标从 开始,因此第 大的数下标为 .
方法一:quick select
class Solution {
public:
int partition(vector<int>& arr,int low,int high){
int r = (rand() % (high-low+1))+ low; // [low, high]
swap(arr[r], arr[low);
int pivot = arr[low];
while(low<high){
while(low<high && arr[high]>=pivot)high--;
arr[low]=arr[high];
while(low<high && arr[low]<=pivot)low++;
arr[high]=arr[low];
}
arr[low]=pivot;
return low;
}
int findKthLargest(vector<int>& nums, int k) {
int mid=-1, low=0, high=nums.size()-1;
while(true){
mid = partition(nums,low,high);
if(mid==nums.size()-k){
return nums[mid];
}else if(mid<nums.size()-k){
low=mid+1;
}else{
high=mid-1;
}
}
}
};
使用优先队列,用法见:c++优先队列(priority_queue)用法详解
class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
// 默认是大顶堆,使用greater<T> 是小顶堆
priority_queue<int,vector<int>,greater<int>> q;
for(auto it:nums){
q.push(it);
// pop掉最小的,剩下k个最大的,最后的top()就是k个最大中的最小值
if(q.size()>k) q.pop();
}
return q.top();
}
};
判断链表是否有环以及环的位置,证明
class Solution:
def hasCycle(self, head: ListNode) -> bool:
if not head or not head.next: # 空链表或只有一个节点时没有环
return False
slow,fast=head,head
while fast and fast.next:
slow=slow.next
fast=fast.next.next
if slow==fast:
break
return slow==fast
证明寻找环的起点的算法:
http://www.bnee.net/article/20526.html
1、慢指针slow走到了环入口时,设共走了k步。此时快指针fast越过了环入口的步数为delta。因为快指针可能绕着环走了很多圈,所以有k = delta + n * R,其中R为环的大小,n为快指针绕环走的圈数。
2、证明必然会相遇。慢指针进入环中后,因为快指针每次都比慢指针快一步,所以,快慢指针最后一定会相遇。
3、计算快慢指针相遇位置。因为慢指针在刚进入环时距离快指针delta步,所以快指针还需要比慢指针多走R - delta步才能与慢指针相遇。又因为快指针每次走两步,所以快指针还需要走2(R - delta)步。那么,相对环的起点而言,相遇位置为2(R - delta) + delta = 2R - delta,即,距离环入口delta处,与慢指针刚进入环时快指针所在位置对称。
4、快指针重新从头结点开始走,速度为一次一步,与慢指针相同。可知,快指针走到环入口时,所需步数为k。由于 k = delta + n * R,所以慢指针也是刚好走到环入口。
class Solution:
def detectCycle(self, head: ListNode) -> ListNode:
if not head or not head.next:
return None
slow,fast=head,head
while fast and fast.next:
slow=slow.next
fast=fast.next.next
if slow==fast:
break
if slow==fast:
fast=head
while slow!=fast:
slow=slow.next
fast=fast.next
return slow
return None
青蛙跳台阶+有一次后退机会
面经看到,但是搜索不到这道题的解法,我目前的个人思路是这样的:
先当做没有后退机会来算,然后考虑一次后退机会加在不同位置带来的新的跳法总共多少种。
设有 级台阶,分别标号 ,我们一开始处于位台阶 ,最后要到达位置 .
当没有后退机会时,设从台阶 到达台阶 共有的跳法种数是 ,则
然后考虑一次后退机会加在不同位置带来的新的跳法总共多少种
如果后退之后到达的是台阶 ,那么产生新的跳法数是 “从台阶 到台阶 的跳法种数”,这应该等价于 “从台阶 到台阶 的跳法种数”,也就是 .
由上可知,考虑上后退位置的不同,
也就是按照没有后退机会求出前面所定义的
数组后,对数组求和再加上
即为所求,用python就是return dp[n] + sum(dp)
最长公共子串、最长公共子序列
二叉树路径最大和
https://leetcode.com/problems/binary-tree-maximum-path-sum/
蓄水池采样问题
https://www.jianshu.com/p/7a9ea6ece2af
https://blog.csdn.net/anshuai_aw1/article/details/88750673
给定一个数据流,数据流长度N很大,且N直到处理完所有数据之前都不可知,请问如何在只遍历一遍数据(O(N))的情况下,能够随机选取出k个不重复的数据。
这个场景强调了3件事:
- 数据流长度N很大且不可知,所以不能一次性存入内存。
- 时间复杂度为O(N)。
- 随机选取k个数,每个数被选中的概率为k/N。
思路:
1、前 k 个数据直接放入蓄水池。
2、蓄水池装满了 k 个数据之后,当接收到第 i 个数据时,在 [0, i] 范围内取随机数 r,若 r 落在[0, k-1]范围内,则用接收到的第i个数据替换蓄水池中的第 r 个数据。
3、重复步骤2。
核心代码如下:
int[] reservoir = new int[k];
// init
for (int i = 0; i < reservoir.length; i++){
reservoir[i] = dataStream[i];
}
for (int i = k; i < dataStream.length; i++){
// 随机获得一个[0, i]内的随机整数
int r = rand.nextInt(i + 1);
// 如果随机整数落在[0, m-1]范围内,则替换蓄水池中的元素
if (r < k){
reservoir[r] = dataStream[i];
}
}
注:这里使用已知长度的数组dataStream来表示未知长度的数据流,并假设数据流长度大于蓄水池容量m。
证明:
先求第 个数 在第 步之后被保留在蓄水池的概率 。在第 步时,它被保留的概率是 ,在第 步时,被保留的概率是 ,以此类推,可知:
再求第 个数 在第 步之后被保留在蓄水池的概率 。最后要保留必须在遇到它时将该数用于替换蓄水池中的数据,而且之后的每一步他都没有被替换掉。在第 步时,该数被保留下来的概率是 ,在第 步时,被保留在蓄水池的概率是 ,以此类推,可知:
综上可知,每个数在第 步之后被保留的概率都是
2 sum,3 sum
一个排序数组能够构成多少个二叉搜索树
https://leetcode.com/problems/unique-binary-search-trees/
分解质因数
def get_num_factors(num):
res = []
tmp = 2
if num <= 3:
return [num]
while num >= tmp:
if num % tmp == 0:
res.append(tmp)
num = num // tmp # 更新
else:
tmp = tmp + 1 # 同时更新除数值,不必每次都从头开始
return res