基本的内部排序

1、交换排序

1.1、冒泡排序（稳定的）

void BubbleSort(int a[],int n)
{//冒泡排序
         int tmp;
   bool exchange=true;
   for(int i =0;i<n;i++)
   {
    exchange=false;
    for(int j=0;j<n-i-1;j++)
     if(a[j]>a[j+1]){tmp=a[j];a[j]=a[j+1];a[j+1]=tmp;exchange=true;}
     if(!exchange) break;
   }
}

void BiDirectionBubbleSort(int a[],int n)
{//双向冒泡排序
 int tmp;
     int up=0;
  int low=n-1;
  int t;
  while(up<low)
  {
   t=up;
         for(int i=up;i<low;i++)  
    if(a[i]>a[i+1]){tmp=a[i];a[i]=a[i+1];a[i+1]=tmp;t=i;}
   low=t;

     for(int j=low;j>up;j--)
  
   if(a[j]<a[j-1]){tmp=a[j];a[j]=a[j-1];a[j-1]=tmp;t=j;}
         up=t;
      
  }
}

1.2、快速排序（不稳定的）

void QuickSort(int a[],int low,int high)
{//快速排序
 int s;
     if(low<high)
  {  
   s=Partition(a,low,high);
       QuickSort(a,low,s-1);
       QuickSort(a,s+1,high);
  }
}

int Partition(int a[],int low,int high)
{
 int p=a[low];
 int tmp;
 int i=low,j=high;
 while(i<j)
 {
  while(a[j]>=p&&i<j) j--;
  if(a[j]<p)
  {
  tmp=a[j];
  a[j]=a[i];
  a[i]=tmp;
  }
  while(a[i]<=p&&i<j) i++;
  if(a[i]>p)
  {
  tmp=a[j];
  a[j]=a[i];
  a[i]=tmp;
     }
 }
 return j;
}

2、插入排序

2.1、直接插入排序

void DirectInsertSort(int a[],int n)
{//直接插入排序
 int tmp,j;
    for(int i=1;i<n;i++)
 {
  tmp=a[i];
  for(j=i-1;j>=0;j--)
  {   
   if(tmp<a[j])
   {
     a[j+1]=a[j];
   }
   else
   { 
       break;
   }
  }
   a[j+1]=tmp;
 }
}

2.2、折半插入排序( 稳定的)

void BinaryInsertionSort(int a[],int n)
{//折半插入排序( 稳定的)
 int tmp,low,high,mid;
 for(int i=1;i<n;i++)
 {
  tmp=a[i];
        low=0,high=i-1;
  while(low<=high)
  {
              mid=(low+high)/2;
     if(a[mid]>tmp) high=mid-1;
     else  low=mid+1;
  }
  for(int j=i-1;j>=low;j--)
   a[j+1]=a[j];
  a[low]=tmp;
 }
}

2.3、希尔排序（不稳定的）

void ShellSort(int a[],int n)
{//希尔排序（不稳定的）
     int gap=n/2;
  int tmp,j;
  while(gap>=1)
  {
   for(int i=gap;i<n;i++)
   {
          tmp=a[i];
    j=i;
    while(j>=gap)
    {
     if(tmp<a[j-gap])
     {
      a[j]=a[j-gap];
         j=j-gap;
     }
     else
     {
                    break;
     }
    }
    a[j]=tmp;  
   }
   gap=gap/2;
  }
}

2.4、//链表插入排序(稳定的)

#define MAXNUM 10000
struct Node
{
 int key;
 int link;
};

void LinkInsert(int a[],int n)
{//链表插入排序(稳定的)
 Node *node=new Node[n+1];
     node[0].key=MAXNUM;
  node[0].link=1;
  int current,pre;
  for(int i=1;i<n+1;i++)
  {
   node[i].key=a[i-1];
   node[i].link=0;
 
  }
      for(int i=2;i<n+1;i++)
   {
           current=node[0].link;
     pre=0;
     while(node[current].key<=node[i].key)
     {
      pre=current;
      current=node[current].link;
     }
     node[i].link=current;
     node[pre].link=i;
   }
   int k=node[0].link;
   for(int j=0;j<n;j++)
   {
    a[j]=node[k].key;
    k=node[k].link;
   }
   delete[] node;
}

3、选择排序

3.1、直接选择排序（不稳定的）

void SelectionSort(int a[],int n)
{//直接选择排序（不稳定的）
      int tmp,min;
   for(int i=0;i<n-1;i++)
   {
    min=i;
    for(int j=i+1;j<n;j++)
     if(a[j]<a[min]){min=j;}
      if(i!=min)
   {
    tmp=a[min];
    a[min]=a[i];
    a[i]=tmp;
   }
   }
}

3.2、锦标赛排序（有待补充）

3.3、堆排序（有待补充）

4、归并排序（稳定的）

4.1、递归实现

void Merge(int a[],int i,int m,int n)
{//将a[i....m]和a[m+1,.....n]归并到a[i,...n]
 int j,k;
 int *b=new int[n+1];
 for(int l=0;l<=n;l++)
  b[l]=a[l];
   for(j=m+1, k=i;i<=m&&j<=n;k++)
   {
    if(b[i]<=b[j]) a[k]=b[i++];
    else a[k]=b[j++];
   }
      for(;i<=m;i++)
    a[k++]=b[i];
   for(;j<=n;j++)
    a[k++]=b[j];
     delete[]  b;
}

void MergeSort(int a[],int m,int n)
{
 if(m<n)
 {
  int mid=(m+n)/2;
  MergeSort(a,m,mid);
  MergeSort(a,mid+1,n);
  Merge(a,m,mid,n);
 }
}

4.2、迭代实现

void Merge(int a[],int i,int m,int n)
{//将a[i....m]和a[m+1,.....n]归并到a[i,...n]
 int j,k,l;
 int blen=n-i;
 int *b=new int[blen];
 for(int l=0;l<blen;l++)
  b[l]=a[i+l];
   for(j=m-i,l=0,k=i;l<m-i&&j<blen;k++)
   {
    if(b[l]<=b[j]) a[k]=b[l++];
    else a[k]=b[j++];
   }
      for(;l<m-i;l++)
    a[k++]=b[l];
   for(;j<blen;j++)
    a[k++]=b[j];
     delete[]  b;

}

void MergeSort(int a[],int m,int n)
{
 int blockLen=1,count=n;
    while(count>1)
 {
  for(int i=0;i<=count;i+=2*blockLen)
   Merge(a,i,i+blockLen,i+2*blockLen);
 blockLen=blockLen*2;  
 count=(count+1)/2;
 }

}