四种nlogn排序算法代码

1.快速排序:不稳定排序,最好情况O(nlogn),最差情况O(n^2).平均情况在所有nlogn排序中最快的排序

快速排序分两步
第一步是将l-r区间进行分块(假设将区间最后一个作为关键字)前面一块的数比小于等于关键字,后面一块大于关键字,并返回第一个大于关键字的位置,即函数partition
第二部是对l~pos-1 和pos+1~r分别进行快速排序.

递归式:
int partition(int l,int r)
{
    int k=r;
    while(l<r)
    {
        int c=0;
        if(a[l]<=a[k])
            l++;
        else
            c++;
        if(a[r]>=a[k])
            r--;
        else
            c++;
        if(c==2)
        {
            int tem=a[l];
            a[l]=a[r];
            a[r]=tem;
        }
    }
    if(l==r)
    {
        if(a[k]>=a[r])
            return r+1;
        else
            return r;
    }
    else
        return l;

}
void quicksort(int l,int r)
{
    if(l>=r)
        return;
    int pos;
    pos=partition(l,r);
    int val=a[r];
    a[r]=a[pos];
    a[pos]=val;
    quicksort(l,pos-1);
    quicksort(pos+1,r);
}

非递归式:
用栈实现,在函数各种变量和参数不是很多的情况下用递归式比较好
详细看网上

2.shell排序:不稳定排序,最好情况O(nlogn),最差情况O(n^x),1<x<2
变长度的插入排序,分别对原数组进行k次长度不同的插入排序即可,注意:最后一次必须是长度为1的插入排序
void shellsort()
{
    for(int i=0;i<=x;i++)//x代表长度的组数
    {
        for(int j=len[i];j<n;j++)//此处是j++而不是j+=len[i]注意！！,希尔排序变长度的排序思想
        {
            int k=j-len[i];
            while(k>=0)
            {
                if(a[j]<a[k])
                {
                    int tem=a[j];
                    a[j]=a[k];
                    a[k]=tem;
                    break;
                }
                else
                    k-=len[i];
            }
        }
    }
}

3.堆排序:不稳定排序,最好和最坏的时间复杂度均为O(nlogn):
主要是写向下渗透函数,然后注意:
1.当数组从0开始左儿子为2*x+1,右儿子为2*x+2
递归返回条件i》(x+1)/2-1
2.当数组从1开始左儿子为2*x,右儿子为2*x+1
递归返回条件i》(x+1)/2
class heaps
{
public:
    int heap[50]={9,8,7,6,5,4,3,2,1,34,5,6,74,24,5,1,2,3,4,55,21,13,41,3};
    int maxsize=23;
    void godown(int i,int x)
    {
        if(i>(x+1)/2-1)//返回条件,易错点
            return;
        int MAX;
        int j;
        if(i*2+2>x)//当只有左孩子的情况!!易错点
        {
            MAX=heap[i*2+1];
            j=i*2+1;
        }
        else//有两个孩子的情况
        {
            if(heap[i*2+1]>heap[i*2+2])
            {
                MAX=heap[i*2+1];
                j=i*2+1;
            }
            else
            {
                MAX=heap[i*2+2];
                j=i*2+2;
            }
        }
        if(MAX>heap[i])
        {
            heap[j]=heap[i];
            heap[i]=MAX;
            godown(j,x);
        }

}
    void buildheap()
    {
        for(int i=(maxsize+1)/2-1;i>=0;i--)
            godown(i,maxsize);
    }
    void heapsort()
    {
        int k=maxsize;
        for(int i=1;i<=maxsize;i++)
        {
            int tem=heap[k];
            heap[k]=heap[0];
            heap[0]=tem;
            k--;
            godown(0,k);//注意,堆的大小在不断变化
        }
    }
};

4.归并排序:稳定排序,最好和最坏的时间复杂度均为O(nlogn)

void merge(int* a,int l,int r)
{
    int tem[100];
    int mid=(l+r)/2;
    int i=l;
    int j=mid+1;
    int k=l;
    for(;i<=mid+1||j<=r+1;i++,j++)
    {
        if(i==mid+1&&j==r+1)
            break;
        if(i==mid+1)
        {
            tem[k++]=a[j];
            i--;
            continue;
        }
        if(j==r+1)
        {
            tem[k++]=a[i];
            j--;
            continue;
        }
        if(a[i]<a[j])
        {
            tem[k++]=a[i];
            j--;
        }
        else
        {
            tem[k++]=a[j];
            i--;
        }
    }
}
void merge_sort(int* a,int l,int r)
{
    int mid=(l+r)/2;
    if(mid+1>r)
        return;
    merge_sort(a,l,mid);
    merge_sort(a,mid+1,r);
    merge(a,l,r);
}

此外还有3种O(n^2)的排序,不详细介绍
1.选择排序：不稳定，时间复杂度 O(n^2)
2.插入排序：稳定，时间复杂度 O(n^2)
3.冒泡排序：稳定，时间复杂度 O(n^2)