几种常见的排序算法

这个星期学习了几种常见的算法，整理如下

首先是冒泡排序，就是不停地交换，复杂度N*N，这里就不上代码了

接下来是插入排序，就是从已经排好序的序列中找到合适的位置，复杂度也是N*N，同理不上代码。

接下来是希尔排序(shell sort)，希尔排序是基于插入排序提出的，算作是插入排序的一个优化，代码如下

void insertsort(int a[],int k,int grap,int n){//间隔为grap的插入排序

    int j;
    for(int i=k+grap;i<=n;i+=grap){
        int tmp=a[i];
        for(j=i-grap;j>=1;j-=grap){
            if(a[j]<=tmp) break;
            a[j+grap]=a[j];
        }
        a[j+grap]=tmp;
    }
}

void shellsort(int a[],int n){ //调整间隔grap

    for(int grap=n/2;grap>=1;grap/=2){
        for(int k=1;k<=grap;k++){
            insertsort(a,k,grap,n);
        }
        show(a,n);
    }
}

接下来是快速排序，基本思想就是找一个数，然后找到该数的合适位置，使得该数的左边全部小于它，而右边全部大于它，复杂度N*logN，然后分治代码如下

void quicksort(int a[],int low,int hight,int n){

    int i=low,j=hight;

    int tmp=a[low];
    while(low<hight){
        while(low<hight && a[hight]>tmp) hight--;
        a[low]=a[hight]; low++;
        while(low<hight && a[low]<tmp) low++;
        a[hight]=a[low];
        hight--;
    }
    a[low]=tmp;   
   if(low-1>i) quicksort(a,i,low-1,n);
   if(hight+1<j) quicksort(a,hight+1,j,n);
}

堆排序，基本思想是构建一个最大/小堆，然后每次交换根和最后一个元素，再去掉最后一个元素，重新调整堆，复杂度N*logN，代码如下

void MaxHeap(int *a,int i,int n){ //构建最大堆
    int l=2*i;
    int r=2*i+1;
    int lar=i;
    if(l<=n && a[l]>a[lar])
        lar=l;
    if(r<=n && a[r]>a[lar])
        lar=r;
    if(lar!=i){
        swap(a[i],a[lar]);
        MaxHeap(a,lar,n);
    }
}

void BuildHeap(int *a,int n){

    for(int i=n/2;i>=1;i--){
        MaxHeap(a,i,n);
    }
}

void HeapSort(int *a,int n){   //进行排序

    for(int i=n;i>=2;i--){
        swap(a[1],a[i]);
        n--;
        MaxHeap(a,1,n);
    }
}

未完待续。。。