一些算法模板

最新推荐文章于 2024-09-12 19:02:20 发布

火鸡味锅巴。

最新推荐文章于 2024-09-12 19:02:20 发布

阅读量82

点赞数

分类专栏：后端文章标签：算法

本文链接：https://blog.csdn.net/qq_34660546/article/details/114489455

版权

后端专栏收录该内容

9 篇文章 0 订阅

订阅专栏

本文深入探讨了数据结构和算法在解决实际问题中的应用，包括并查集的实现，二分查找的两种变体，快速排序与归并排序的详细步骤，以及单调栈、单调队列和哈希表等数据结构的典型用例。此外，还介绍了大根堆和小顶堆在寻找中位数和高频元素上的应用。这些基础知识对于提升编程能力至关重要。

摘要由CSDN通过智能技术生成

并查集

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();
}