排序算法的总结

一.

1.排序的基本概念：

       排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序，若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。

2.排序的稳定性：

      假设在待排序的序列中存在多个具有相同关键字的记录。设ki = kj (1<=i<=n,1<=j<=n, i != j),若在排序前的序列中Ri领先于Rj，经过排序后得到的序列中Ri仍领先于Rj，则称所用的排序方法是稳定的；反之，若相同关键字的领先关系在排序过程中发生变化，则称所用的排序方法是不稳定的。

     排序过程中，一般进行两种操作：

       1.比较两个关键字大小。

       2.将记录从一个位置移到另一个位置。

二.

1.直接插入排序：

void InsSort(RecordType r[],int length)
{
    for(i=2;i<=length;i++)
     {
         r[0]=r[i];
         j=i-1;
         while(r[0].key<r[j].key)
         {
             r[j+1]=r[j];
             j=j-1;
         }
          r[i+1]=r[0];
     }
}

2.希尔排序：

void ShellInsert(RecordType r[],int length,int delat)
{
     for(i=1+delta;i<=length;i++)
     {
        if(r[i].key<r[i-delta].key)
        {
           r[0]=r[i];
           for(j=i-delta;j>0 && r[0].key<r[j].key;j-=delta)
                r[j+delta]=r[j];
            r[j+delta]=r[0];
        }
     }
}



void ShellSort(RecordType r[],int length,int delta[],int n)
{
     for(i=0;i<=n-1;++i)
         ShellInsert(r,Length,delta[i]);

}

3.冒泡排序

void BubbleSort(RecordType r[],int n)
{
   change = TRUE;
   for(i=1 ; i<=n-1 ; && change; ++i)
   {
      change = FALSE;
      for(j=1; j<=n-i;++j)
      {
         x=r[j];
         r[j]=r[j+1];
         r[j+1]=x;
         change=TURE; 
      }
   }
}

4.快速排序

void QKSort(RecordType r[],int low,int high)
{
    if(low<hight)
    {
       pos=QKPass(r,low,high);
       QKSort(r,low,pos-1);
       QKSort(r,pos+1,high); 
    }
}


int QKPass(RecordType r[],int low,int high)
{
   x=r[low];
   while(low<high)
   {
      while(low<high && r[high].key>=x.key)
          high--;
      if(low<high)
       {
          r[low]=r[high];
          low++;
       }
       while(low<high && r[low].key<x.key)
           low++;
       if(low<high)
       {
           r[high]=r[low];
           high--;
       }
   }
   r[low]=x;
   return low;
}

5.简单选择排序：

void SelectSort(RecordType r[],int n)
{
    for(i=1;i<=n-1;++i)
     {
        k=i;
        for(j=i+1;j<=n;++j)
           if(r[j].key<r[k].key)   k=j;
         if(k!=i)
         {
            x=r[i];
            r[i]=r[k];
            r[k]=x;
         }
     }
}

6.归并排序

void Merge(RecordType r[],int low,int mid,int high,RecordType r2[])
{
   i=low;j=mid+1;k=low;
   while(i<=mid)&&(j<=high)
   {
       if(r1[i].key<=r1[j].key)
        {
           r2[k]=r1[i];
           ++i; 
        }
        else
        {
           r2[k]=r1[j];
           ++j;
        }
        ++k;
   }
   while(i<=mid)
   {
      r2[k]=r1[i];
      k++;
      i++; 
   }
   while(j<=high)
   {
      r2[k]=r1[j];
      k++;
      j++;
   }
}


void MSort(RecordType r1[],int low,int high,RecordType r3[])
{
   RecordType * r2;
   r2 = (RecordType *)malloc(sizeof(RecordType )*(high-low+1));
   if(low==high)
       r3[low]=r1[low];
   else{
      mid =(low + high)/2;
      MSort(r1,low,mid,r2);
      MSort(r1,mid+1,high,r2);
      Merge(r2,low,mid,high,r3);
    }
    free(r2);
}


void MergeSort(RecordType r[],int n)
{
    MSort(r,l,n,r);
}