排序的实现

排序（sorting）分为内部排序（internal sorting）和外部排序（external sorting）
定义如下结构：
#define maxsize 20
typedef int Keytype;
typedef struct
{
 Keytype key;
 Infotype other;
} Redtype;
typedef struct
{
 Redtype r[maxsize+1]; //r[0]作哨兵单元
 int length;
} Sqlist;

时间复杂度与空间复杂度

以下算法是不加哨兵单元的内部排序方法
1、冒泡排序（Bubble Sorting）
void BubbleSort(int data[],int n)
{
 int i,j;
 int temp;
 for(i=0;i {
  for(j=0;j  {
   if(data[j]>data[j+1])
   {
    temp=data[j];
    data[j]=data[j+1];
    data[j+1]=temp;
   }
  }
 }
}
排序结果稳定
2、选择排序（Selcettion Sorting）
void SelectSort(int data[],int n)
{
 int i,j;
 int min,temp;
 for(i=0;i {
  min=i;
  for(j=i+1;j  {
   if(data[j]   {
    min=j;
   }
   }
  temp=data[i];
  data[i]=data[min];
  data[min]=temp;

 }
}
排序结果不稳定
3、插入（Insertion Sorting）
（1）直接插入排序（Straight Insertion Sorting）
void InsertSort(int data[],int n)
{
 int i,j;
 int temp;

 for(i=1;i {
  temp=data[i];
  j=i-1;
  while(temp=0)
  {
   data[j+1]=data[j];
   j--;
  }
  data[j+1]=temp;
 }
}
排序结果稳定
（2）希尔排序（ShellSort）
void ShellSort(int data[],int n)
{
 int gap,i,j,temp;

 for(gap=n/2;gap>0;gap/=2)
 {
  for(i=gap;i  {
   temp=data[i];
   j=i-gap;
   while(temp=0)
   {
    data[j+gap]=data[j];
    j=j-gap;
   }
   data[j+gap]=temp;
  }
 }
}
排序结果不稳定

4、快速排序（Quick Sorting）－冒泡法（Bubble Sorting）的改进
int qs(int data[],int left,int right)
{
 int temp;
 temp=data[left];
 while (left {
  while(lefttemp)
  {
   right--;
  }
  if(left   data[left++]=data[right];
  while(left  {
   left++;
  }
  if(left   data[right--]=data[left];
 }
 data[left]=temp;

 return left;
}

void QuickSort(int data[],int left,int right)
{
 int base;
 if(left {
  base=qs(data,left,right);
  QuickSort(data,left,base-1);
  QuickSort(data,base+1,right);
 }
}

排序结果不稳定
5、归并排序（Merge Sorting）

排序结果稳定
6、堆排序（Heap Sorting）
排序结果不稳定

7、基数排序
排序结果稳定

希尔排序，选择排序，快速排序，堆排序为不稳定排序。其它排序为稳定排序。
1－3为简单排序，4－8为先进排序。

对排序算法的总结：

(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡，随机的快速排序为宜；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。

快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的。

void ms(int data[],int left, int base,int right)
{
 int i,j;
 for(i=base+1,j=left;left {
  if(data[left]   T[j]=R[left++];
  else
   T[j]=R[i++];
 }
}
void MergeSort(int data[],int left,int right)
{
 int base;
 if(left {
  base=(left+right)/2;
  MergeSort(data,left,base);
  MergeSort(data,base+1,right);
  ms(data,left,base,right);
 }
}