排序总结

标签：pre   选择   时间   ret   int   quick   shel   --   wap   

排序大法总结

这里的排序都是一些函数调用,默认为int类型,从小到大,第一个参数为头指针,第二个为数组长度.

直接选择排序

时间复杂度为 $O(n^{2})$
是不稳定排序.

思路:

每次选出待排区间的最值,放在第一个.

void selection_sort(int num[],int len){
    int minpos;
    for(register int i=0;i<len;i++){
        minpos=i;
        for(register int j=i;j<len;j++){
            if(num[minpos]>num[j]) minpos=j;
        }
        swap(num[minpos],num[i]);
    }
    return ;
}

冒泡排序

时间复杂度在最坏以及平均情况下下为$O(n^{2})$，最好情况下为$O(n)$，是稳定排序.

思路:

不断冒泡

void bubble_sort(int num[],int len){
    for(register int i=0;i<len;i++){
        for(register int j=0;j<len-i-1;j++){
            if(num[j]>num[j+1]) swap(num[j],num[j+1]);
        }
    }
    return ;
}

直接插入排序

void insert_sort(int num[],int len) {
    int v,j;
    for(register int i=1;i<len;i++) {
        v=num[i];
        j=i-1;
        while(j>=0&&v<num[j]) {
            num[j+1]=num[j];
            j=j-1;
        }
        num[j+1]=v;
    }
}

希尔排序

时间复杂度在平均情况下为，在最好情况下为，在最坏情况下为，是不稳定排序

void shell_sort(int num[],int len) {
    int gap=len;
    while(gap>1) {
        gap=gap/3+1;
        for(register int i=gap; i<len; i++) {
            int temp=num[i];
            int pos=i-gap;
            while(pos>=0) {
                if(temp<num[pos]) swap(num[pos],num[pos+gap]);
                pos-=gap;
            }
        }
    }
    return ;
}

快速排序

时间平均复杂度为，但是在极端情况下会退化，是不稳定排序。

void quick_sort(int num[],int len) {
    int i=0,j=len-1;
    int k=num[0];
    if(i>=j) return;
    while(i<j) {
        while((i<j)&&num[j]>=k) j--;
        swap(num[i],num[j]);
        while((i<j)&&(num[i]<k)) i++;
        swap(num[i],num[j]);
    }
    quick_sort(num,i-1);
    quick_sort(num+i+1,len-i-1);
    return;
}

归并排序

时间复杂度为，是稳定排序。

void merge_sort(int num[],int len){
    if(len==1) return ;
    merge_sort(num,len>>1);
    merge_sort(num+(len>>1),len-(len>>1));
    int i=0,j=len>>1,pos=0,fuzhu[len];
    while(i<(len>>1)&&j<len) fuzhu[pos++]=(num[i]<num[j])? num[i++]:num[j++];
    while(i<(len>>1)) fuzhu[pos++]=num[i++];
    while(j<len) fuzhu[pos++]=num[j++];
    for(register int p=0;p<len;p++) num[p]=fuzhu[p];
    return ;
}

堆排序

时间复杂度为，是不稳定排序。

void heap_sort(int num[],int len) {
    int mid[len+1];
    for(register int i=1,pos; i<=len; i++) {
        mid[i]=num[i-1];
        pos=i;
        while(pos!=1) {
            if(mid[pos]<mid[pos>>1]) swap(mid[pos],mid[pos>>1]);
            else break;
            pos>>=1;
        }
    }
    for(register int i=1,pos,nex; i<=len; i++) {
        num[i-1]=mid[1];
        mid[1]=mid[len-i+1];
        pos=1;
        while(pos<<1<=len-i) {
            nex=pos<<1;
            if((mid[nex]>mid[nex|1]&&nex<len-i)) nex++;
            if(mid[pos]<=mid[nex]) break;
            swap(mid[pos],mid[nex]);
            pos=nex;
        }
    }
}

排序总结

标签：pre   选择   时间   ret   int   quick   shel   --   wap   

原文地址：https://www.cnblogs.com/STOGMH/p/11699929.html