8大常见排序算法代码实现（C++）

直接插入，希尔，选择，冒泡（略），快排，归并，基数（类似桶排序），堆排序（最大堆）：

 

#include <iostream>
#include <math.h>
using namespace std;

void insertSort(int a[]){    // n,n2,n2,stable
    int k=sizeof(a)/sizeof(a[0]);
    int i,j,temp;
    for(i=1;i<k;i++)
    {
        if(a[i]<a[i-1])
        {
            temp=a[i];
            for(j=i-1;j>=0&&a[j]>temp;j--)
                a[j+1] = a[j];
            a[j+1] = temp;
        }
    }
}
#define MAXNUM 10
void shellInsert(int array[],int n,int dk)
{
    int i,j,temp;
    for(i=dk;i<n;i++)
    {
        temp=array[i];
        for(j=i-dk;(j>=i%dk)&&array[j]>temp;j-=dk)
        {
            array[j+dk]=array[j];
        }
        if(j!=i-dk) array[j+dk]=temp;
    }
}
int dkHibbard(int t,int k)
{
    return int(pow(2,t-k+1)-1);
}
void shellSort(int array[],int n,int t)     //n,n1.3,n2,not stable
{
    void shellInsert(int array[],int n,int dk);
    int i;
    for(i=1;i<=t;i++)
        shellInsert(array,n,dkHibbard(t,i));

}
void selectSort(int a[],int n)   //n2,n2,n2,not stable
{
    int i,j,k,t;
    for(i=0;i<n;i++)
    {
        k=i;
        for(j=i+1;j<n;j++)
            if(a[k]>a[j])
              k=j;
        if(k!=i){
            t=a[i];
            a[i]=a[k];
            a[k]=t;
        }
    }
}
void quickSort(int *a,int left,int right)  //nlogn,nlogn,n2,not stable
{
        if(left>=right) return;
        int i = left;
        int j = right;
        int key = a[left];
        while(i<j)
        {
            while(i<j&&key<=a[j])
            {
                j--;
            }
            a[i] = a[j];
            while(i<j&&key>=a[i])
            {
                i++;
            }
            a[j] = a[i];
        }
        a[i] = key;
        quickSort(a,left,i-1);
        quickSort(a,i-1,right);
}
void Merge(int sourceArr[],int tempArr[],int startIndex,int midIndex,int endIndex)
{
    int i = startIndex,j = midIndex+1,k = startIndex;
    while(i!=midIndex+1 && j!=endIndex+1)
    {
        if(sourceArr[i]>sourceArr[j])
            tempArr[k++]=sourceArr[j++];
        else
            tempArr[k++]=sourceArr[i++];
    }
    while(i!=midIndex+1)
        tempArr[k++]=sourceArr[i++];
    while(j!=endIndex+1)
        tempArr[k++]=sourceArr[j++];
    for(i=startIndex;i<endIndex;i++)
        sourceArr[i]=tempArr[i];
}


void MergeSort(int sourceArr[],int tempArr[],int startIndex,int endIndex)   //nlogn,nlogn,nlogn,stable
{
    int mideIndex;
    if(startIndex<endIndex)
    {
        mideIndex = (startIndex+endIndex)/2;
        MergeSort(sourceArr,tempArr,startIndex,mideIndex);
        MergeSort(sourceArr,tempArr,mideIndex+1,endIndex);
        Merge(sourceArr,tempArr,startIndex,mideIndex,endIndex);
    }

}

int maxbit(int data[],int n)
{
    int d = 1;
    int p = 10,i;
    for(i=0;i<n;++i)
        while(data[i]>=p)
        {
            p*=10;
            ++d;
        }
    return d;
}

void radixsort(int data[],int n)        //d(r+n),d(r+n),d(r+n),stable
{
    int d = maxbit(data,n);
    int *tmp=new int[n];
    int *count=new int[10];
    int i,j,k;
    int radix = 1;
    for(i=1;i<=d;i++)
    {
        for(j=0;j<10;j++)
            count[j]=0;
        for(j=0;j<n;j++)
        {
            k=(data[j]/radix)%10;
            count[k]++;
        }
        for(j=1;j<10;j++)
            count[j]=count[j-1]+count[j];
        for(j=n-1;j>=0;j--)
        {
            k=(data[j]/radix)%10;
            tmp[count[k]-1] = data[j];
            count[k]--;
        }
        for(j=0;j<n;j++)
        {
            data[j] = tmp[j];
        }
        radix = radix*10;
    }
    delete[]tmp;
    delete[]count;
}

void HeapAdjust(int array[],int i,int nLength)
{
    int nChild,nTemp;
    for(;2*i+1<nLength;i=nChild)
    {
        nChild = 2*i+1;
        if(nChild<nLength-1&&array[nChild+1]>array[nChild])
            ++nChild;
        if(array[i]<array[nChild])
        {
            nTemp=array[i];
            array[i] = array[nChild];
            array[nChild] = nTemp;
        }
        else break;
    }
}
void HeapSort(int array[],int length)       //nlogn,nlogn,nlogn,not stable
{
    int i;
    for(i=length/2-1;i>=0;--i)
        HeapAdjust(array,i,length);
    for(i=length-1;i>0;--i)
    {
        array[i]=array[0]^array[i];  //10,11
        array[0]=array[0]^array[i];  //01
        array[i]=array[0]^array[i];  //01
        HeapAdjust(array,0,i);
    }

}
int main()
{

    return 0;
}