排序

 

模板

#include <iostream>

using namespace std;

int num[111];


void Sort(int num[],int n)
{
    
}
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>num[i];
    Sort(num,n);
    return 0;
}

插入排序：

最佳情况：T(n) = O(n2)  最差情况：T(n) = O(n2)  平均情况：T(n) = O(n2)

void insertSort(int num[],int n)
{
    for(int i=1;i<n;i++)
    {
        int cur=i-1;
        int cnum=num[i];
        while(cur>=0&&cnum<num[cur])
        {
            num[cur+1]=num[cur];
            cur--;
        }
        num[cur+1]=cnum;
    }
    for(int i=0;i<n;i++)
        cout<<num[i]<<" ";
    cout<<endl;
}

希尔排序

最佳情况：T(n) = O(nlog2 n)  最坏情况：T(n) = O(nlog2 n)  平均情况：T(n) =O(nlog2n)　

类似于插入排序

void shellSort(int num[],int n)
{
    int gap=n/2;
    while(gap)
    {
        for(int i=gap;i<n;i++)
        {
            int temp=num[i];
            int preIndex=i-gap;
            while(preIndex>=0&&temp<num[preIndex])
            {
                num[preIndex+gap]=num[preIndex];
                preIndex-=gap;
            }
            num[preIndex+gap]=temp;
        }
        gap/=2;
    }
    for(int i=0;i<n;i++)
        cout<<num[i]<<" ";
    cout<<endl;
}

归并排序

先用分治的思想分开然后将左右两个数组O（n）合并，合并的策略采用三个下表做比较

最佳情况：T(n) = O(n)  最差情况：T(n) = O(nlogn)  平均情况：T(n) = O(nlogn)

void Merge(int num[],int l,int r)
{
    int arrayLet[111];
    int arrayRight[111];
    int mid=(l+r)/2;
    int i1,j1;
    for(i1=l;i1<=mid;i1++)
        arrayLet[i1-l]=num[i1];
    for(j1=mid+1;j1<=r;j1++)
        arrayRight[j1-(mid+1)]=num[j1];
    i1-=l;
    j1-=(mid+1);
    int i=0;
    int j=0;
    for(int index=l;index<=r;index++)
    {
        if(i>=i1)
            num[index]=arrayRight[j++];
        else if(j>=j1)
            num[index]=arrayLet[i++];
        else if(arrayLet[i]<arrayRight[j])
            num[index]=arrayLet[i++];
        else num[index]=arrayRight[j++];    
    }
}
void mergeSort(int num[],int l,int r)
{
    if(l>=r) return;
    int mid=(l+r)/2;
    mergeSort(num,l,mid);
    mergeSort(num,mid+1,r);
    Merge(num,l,r);
}

快速排序

最佳情况：T(n) = O(nlogn)   最差情况：T(n) = O(n2)   平均情况：T(n) = O(nlogn)　

在原数组已经有序的情况是最坏的n2情况，这时候选择基准数的时候可以用随机化选择，然后交换使得优化

void qsort(int num[],int l,int r)
{
    if(l >= r) return;
    int p=r;
    int l1=l;
    int r1=r;//注意r的起始位置
    while(l1 < r1)
    {
        while(num[l1] <= num[p] && l1 < r1) l1++;
        while(num[r1] >= num[p] && r1 > l1) r1--;
        if(l1 < r1) swap(num[l1],num[r1]);
    }
    swap(num[l1],num[p]);//替换基准点
    qsort(num,l,p-1);
    qsort(num,p+1,r);
}

堆排序

最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)