并查集
class UnionFind{
int[] p;
UnionFind(int num){
//方便数组操作
for(int i=0;i<=num;i++){
p[i]=i;
}
}
int find(int x){
//递归 将每个元素指向最终的老大,缩短路径
if(p[x]!=x) p[x]=find(p[x]);
return p[x];
}
void union(int a, int b){
int fa = find(a);
int fb = find(b);
p[fb]=fa;
}
}
二分法
//check函数检查mid是否满足条件
//区间[l, r]被划分为[l, mid]和[mid+1, r]
int bsearch1(int l , int r){
while(l<r){
int mid = l+r>>1;
if(check(mid)) r=mid;
else l=mid+1;
}
return l;
}
//区间[l, r]被划分为[l, mid-1]和[mid, r]
int bsearch2(int l, int r){
while(l<r){
int mid = l+r+1>>1;
if(check(mid)) l=mid;
else r=mid-1;
}
return l;
}
快速排序
void quickSort(int[] arr, int l, int r){
if(l>=r) return;
int i=l-1, j=r+1, x=arr[l+r>>1];
while(i<j){
do i++; while(arr[i]<x);
do j--; while(arr[j]>x);
if(i<j) swap(i,j);
}
quickSort(arr, l, j);
quickSort(arr, j+1, r);
}
归并排序
int[] tmp=new int[arr.length];
void mergeSort(int[] arr, int l, int r){
if(l>=r) return;
int mid= l+r>>1;
mergeSort(arr, l, mid);
mergeSort(arr, mid+1, r);
int k=0, i=l, j=mid+1;
while(i<=mid && j<=r){
if(arr[i] <= arr[j]) tmp[k++]=arr[i++];
else tmp[k++] = arr[j++];
}
while(i<=mid) tmp[k++]=arr[i++];
while(j<=r) tmp[k++]=arr[j++];
for(i=l,j=0; i<=r; i++,j++)
arr[i]=tmp[j];
}
单调栈
常见模型:找出每个数左边离他最近比它大/小的数
//这里用数组模拟栈了
int N=100010;
int[] stk =new int[N];
int t=0;
for(int i=1;i<=n;i++){
//不满足条件就弹出栈顶元素
//check函数比较栈顶元素和当前数,如果要求小的数,那么check函数就是stk[t]>=当前数
while(t>0 && check(stk[t], i)) t--;
if(t==0){
//输出-1,没有满足条件的数
}else{
//输出栈顶元素
}
stk[++t]=i;
}
单调队列
常见模型:找出滑动窗口的最大/小值
//求滑动窗口的最大值,,那么队列就应该是单调递减的,这样队列头就是最大值
//nums是目标数组,k是滑动窗口的大小
int[] find(int[] nums,int k){
//队列存数组的下标
Deque<Integer> q = new LinkedList();
//输出结果数组的大小
int[] res = new int[nums.length-k+1];
for(int i=0,index=0; i<nums.length; i++){
//当i>k时,窗口需要向后移动一位,队列弹出头元素
if(q.size()>0 && i-k+1>q.getFirst())
q.pollFirst();
//如果队尾元素小于当前元素,不符合单调递减,踢出队尾元素
while(q.size()>0 && nums[q.getLast()]<nums[i])
q.pollLast();
q.add(i);
if(i>=k-1)
res[index++] = nums[q.getFirst()];
}
}
堆
//h[1]是堆顶,x的左儿子是2x,右儿子是2x+1
int[] h = new int[N];
//存第k个插入的点在堆中的位置
int[] position_h = new int[N];
//存在堆中下标是k的点是第几个插入的
int[] num_h = new int[N];
int size;
//交换两个点
void heapSwap(int a, int b){
swap(position_h[num_h[a]], position_h[num_h[b]]);
swap(num_h[a], num_h[b]);
swap(h[a], h[b]);
}
void down(int u){
int t=u;
if(2*u <=size && h[2*u]<h[t]) t=u*2;
if(2*u+1<=size && h[2*u+1]<h[t]) t=2*u+1;
if(t!=u){
heapSwap(t,u);
down(t);
}
}
void up(int u){
while(u/2>0 && h[u]<h[u/2]){
heapSwap(u, u/2);
u>>=1;
}
}
//建堆 O(n)
for(int i=n/2;i>0;i--) down(i);
哈希
//1.拉链法 数组加链表
int N = 200011; //大的质数,减少哈希碰撞
int[] arr = new int[N];
int[] n= new int[N];
int[] hash = new int[N];
int index=0;
void insert(int x){
int k = (x%N+N)%N;
arr[index] = x;
n[index] = hash[k];
hash[k] = index++;
}
boolean find(int x){
int k = (x%N+N)%N;
for(int i=hash[k]; i!=-1; i=n[i]){
if(arr[i]==x) return true;
}
return false;
}
//2.开放寻址法
int[] hash[N];
//如果x在哈希表中,返回x的下标,否则返回x应该插入的位置
int find(int x){
int k = (x%N+N)%N;
while(hash[k]!=x){
k++;
if(k==N) k=0;
}
return k;
}
大根/顶堆
//堆的根节点是最大值,这个堆中存放的都是小于等于根节点的值
//Java中PriorityQueue通过二叉小顶堆实现
//leetcode 692.前k个高频单词
//寻找前k个最大的值,则需要构建小顶堆
public List<String> topKFrequent(String[] words, int k) {
Map<String,Integer> map = new HashMap();
for(String w:words){
map.put(w, map.getOrDefault(w,0)+1);
}
PriorityQueue<String> heap = new PriorityQueue<>((w1,w2)->
map.get(w1).equals(map.get(w2))?w2.compareTo(w1) : map.get(w1)-map.get(w2));
for(String w:words){
heap.add(w);
if(heap.size()>k) heap.poll();
}
List<String> res = new ArrayList();
while(!heap.isEmpty()) res.add(0,heap.poll);
return res;
}
//leetcode 295.寻找数据流的中位数
//利用大顶堆和小顶堆存数据,大顶堆中存放的都是小数据,小顶堆中都是大数据,这样两个堆的根节点就是中位数
PriorityQueue<Integer> min_heap = new PriorityQueue();
PriorityQueue<Integer> max_heap = new PriorityQueue((a,b)->b-a);
void addNum(int x){
if(min_heap.isEmpty() || min_heap.peek()<=x) nim_heap.add(x);
else{
max_heap.add(x)
min_heap.add(max_heap.poll());
}
if(min_heap.size()>max_heap.size()+1){
max_heap.add(min_heap.poll());
}
}
double findMedian() {
if(min_heap.size() == max_heap.size()) return (min_heap.peek()+max_heap.peek())/2.0;
return min_heap.peek();
}