排序算法

选择排序
插入排序
交换排序

排序算法	最好时间复杂度	最差时间复杂度	平均时间复杂度	空间复杂度	稳定性
直接插入排序	O(n)	O(n2)	O(n2)	O(1)	稳定
冒泡排序	O(n)	O(n2)	O(n2)	O(1)	稳定
选择排序	O(n2)	O(n2)	O(n2)	O(1)	不稳定
快速排序	O(nlog2n)	O(n2)	O(nlog2n)	O(log2n) ~ O(n)	不稳定
堆排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(1)	不稳定
归并排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(n)	稳定

冒泡排序：

for(i=n-1;i>=0;i--)
  for(j=0;j<i;j++)
  {
      if(a[j]>a[j+1]){int temp=a[j];a[j]=a[j+1];a[j+1]=temp;}
  }

归并排序： o(nlogn)可用于求逆序数对

void guibing(int low,int high)
{
    if(low>=higrh)return;
    int mid=(low+high)/2;
    guibing(low,mid);
    guibing(mid+1,high);
    int c[100];
    for(i=low;i<=high;i++)c[i]=a[i];
    i=low;j=mid+1;k=low;
    while(i<=mid&&j<=high)
   {
        if(c[i]>c[j]){a[k++]=c[j];j++;}
        else {a[k++]=c[i];i++;}
   }
   if(i<=mid)for(;i<=mid;i++)a[k++]=c[i];
   else if(j<=high)for(;j<=high;j++)a[k++]=c[j];
}

void g-sort()
{
      guibing(0,n-1);
}


快速排序：

void Quick-sort(int low,int high)
{
    if(low<high)
    {
         int q=partition(low,high);
         Quick-sort(low,q-1);
         Quick-sort(q+1,high);
    }
}

int partition(int low,int high)
{
     int x=a[high],i=low-1,j;
     for(j=low;j<high;j++)
     {
         if(a[j]<=x){i++;int temp=a[i];a[i]=a[j];a[j]=temp;}
     }
     int temp=a[i+1];a[i+1]=a[high];a[high]=temp;
     return i+1;
}


堆排序：  可用于优先队列

void heapify(int i,int length)
{
    int left=2*i+1;
    int right=2*i+2;
    int largest;
    while(i<length)
    {
         if(left<length&&a[i]<a[left])largest=left;
         else largest=i;
         if(right<length&&a[right]>a[i])largest=right;
         if(largest==i)return;
         else
         {
            int temp=a[i];a[i]=a[largest];a[largest]=temp;
         }
         i=largest;
    }
}

void BuildHeap()
{
     for(i=length/2;i>=0;i--)
     {
         heapify(i,length);
     }
}

void Heap-sort()
{
     Buildheap();
     for(i=n;i>=1;i--)
     {
         int temp=a[0];a[0]=a[i-1];a[i-1]=temp;
         heapify(0,i-1);
     }
}