剑指offer-排序算法

常用排序算法自主手写代码：
1、冒泡排序 时间O(N^2)，空间O(1),稳定，数据有序效果越好

void BubbleSort(int a[],int n){
    int flag=1;
    for(int i=1;i<n&&flag;i++){
        flag=0;      //表示有序
        for(int j=1;j<n-i+1;j++){
                if(a[j-1]>a[j]){
                    swap(a[j],a[j-1]);
                    flag=1;
                }
        }
    }
    //flag=1说明该趟不是全部都有序，需要继续比较
    //flag=0说明没有进行互换，数组已经有序了，没有必要继续比较，直接结束
}

2、选择排序 时间O(N^2),空间O(1),不稳定，最好情况是数据有序

//3,1,3,2,4,6,8
//之所以不稳定，是因为排序过程中两个相同元素的位置会改变
void SelectSort(int a[],int n){
    int flag=1;
    for(int i=0;i<n&&flag;i++){
        flag=0
        for(int j=i+1;j<n;j++){
            if(a[j]<a[i]){
                swap(a[j],a[i]);
                flag=1;
            }
        }
    }
}

3、插入排序 时间O(N^2)，空间O(1)，稳定，最好情况是数据有序

void InsertSort(int a[],int n){
    for(int i=1;i<n;i++){
        int key=a[i];   //待插入的数据
        int j=i-1;
        for(;j>=0;j--){
            if(a[j]>key)
                    a[j+1]=a[j];
            else break;
        }
        a[j+1]=key;
    }
}

4、快速排序 时间O(NlogN)，空间O(1)，原址排序，不稳定

int Partition(int a[],int n,int low,int high){
    int pivot=a[low];
    while(low<high){
        for(;low<high&&a[high]>=pivot;high--);
        if(low<high)    a[low++]=a[high];

        for(;low<=high&&a[low]<=pivot;low++);
        if(low<high)    a[high--]=a[low];
    }
    a[low]=pivot;
    return low;
}
void QuickSort(int a[],int n,int low,int high){
    if(low<=high){
        int mid=Partition(a,n,low,high);
        QuickSort(a,n,low,mid-1);
        QuickSort(a,n,mid+1,high);
    }
}

5、堆排序 时间O(NlogN) 空间O(1) 原址排序 不稳定

//1.维护最大堆的性质
void MaxHeap(int a[],int n,int i){
    int largest=i;
    int left=2*i+1;
    int right=2*i+2;
    if(left<n&&a[left]>a[largest]){
        largest=left;
    }
    if(right<n&&a[right]>a[largest]){
        largest=right;
    }
    if(largest!=i){
        swap(a[largest],a[i]);
        MaxHeap(a,n,largest);
    }
}
//2.创建最大堆
void CreateMaxHeap(int a[],int n){
    for(int i=n/2;i>=0;i--){
        MaxHeap(a,n,i);
    }
}
//3.堆排序
void HeapSort(int a[],int n){
    CreateMaxHeap(a,n);
    for(int i=n-1;i>0;i--){
        swap(a[i],a[0]);
        MaxHeap(a,i,0);
    }
}

6、归并排序 时间O(logN) 空间O(N) 稳定

//1.将有序的两个数组归并为一个有序的数组
//数组为以mid为中心两边都是有序的,需要将a[low]到a[mid]和a[mid]到a[high]合并
void Merger(int a[],int b[],int low,int mid,int high)
{
    int i=low,j=mid+1;
    int k=low;
    while(i<=mid&&j<=high){
        if(a[i]<a[j])
            b[k++]=a[i++];
        else
            b[k++]=a[j++];
    }
    while(i<=mid)
        b[k++]==a[i++];
    while(j<=high)
        b[k++]=a[j++];

   //特别注意：必须原址保存,因为归并排序的目的就是要求原来的数据越来越以中间线划分为连续的两段，必须保存
   for (int i=low;i<=high;i++)
        a[i] = b[i];
}
void MergeSort(int a[],int b[],int low,int high){
        if(low<high){
            int mid=low+(high-low)/2;
            MergeSort(a,b,low,mid);
            MergeSort(a,b,mid+1,high);
            Merger(a,b,low,mid,high);
        }
}