c语言排序算法（使用链表）

存储结构：

#define MAXSIZE 20
typedef  int keytype;
typedef struct 
 { keytype  key;
    InfoType  otherinfo;    /*没有可以省略*/
  }RedType;
typedef struct 
  { RedType r[MAXSIZE+1];
     int length; 
}Sqlist; 

一、直接插入排序（Straight Insertion Sort）

        直接插入排序（Straight Insertion Sort）是一种最简单的排序方法，其基本操作是将一条记录插入到已排好的有序表中，从而得到一个新的、记录数量增1的有序表。

void insertsorting(Sqlist *s)
  { int i,j;
     for(i=2;i<=s->length;i++)
        { s->r[0]=s->r[i];
           j=i-1;
           while(s->r[0].key<s->r[j].key)
               {  s->r[j+1]=s->r[j];
                   j--;   }
            s->r[j+1]=s->r[0]; 
       
} }

二、折半插入排序（Binary Insertion Sort）

        折半插入排序（Binary Insertion Sort）是对直接插入排序算法的一种改进。

        折半插入排序与直接插入排序算法原理相同。只是，在向已排序的数据中插入数据时，采用来折半查找（二分查找）。先取已经排序的序列的中间元素，与待插入的数据进行比较，如果中间元素的值大于待插入的数据，那么待插入的数据属于数组的前半部分，否则属于后半部分。依次类推，不断缩小范围，确定要插入的位置。

void Binsertsorting(Sqlist *l)
  { int i,j;
     for(i=2;i<=l->length;i++){
          l->r[0]=l->r[i]; 
          low=1;  high=i-1;
         while(low<=high){
              m=(low+high)/2;
               if(l->r[0].key<l->r[m].key)   high=m-1;
               else  low=m+1;   }

         for(j=i-1;j>=high+1;--j)  l->r[j+1]=l->r[j];

         l->r[high+1]=l->r[0];
       }    
}

三、希尔排序(Shell's Sort)

        希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。

        希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。

void shellsort (Sqlist *t)
{ 
     RedType temp; int d,bool,i,j;
     d=t->length;
     while(d>=1) {
        d=d/2;
        do {
             bool=1;
             for(i=1;i<=t->length-d;i++){
                   j=i+d; 
                   if(t->r[i].key>t->r[j].key){ 
                   temp=t->r[i];t->r[i]=t->r[j];
                   t->r[j]=s; 
                   bool=0;  
                 }
           }    
        }while(bool==1);
    }
}  

四、气泡排序(又称冒泡排序,直接交换排序)（Bubble Sort）

        冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

void bubble(Sqlist *t)
  { int i,j,flag;  RedType temp;
     for(i=1;i<t->length;i++)
       { flag=1;
          for(j=t->length;j>=i;j--)
            if(t->r[j].key<t->r[j-1].key)
            { temp=t->r[j-1];t->r[j-1]=t->r[j];
               t->r[j]=temp;  flag=0;}
           if(flag)   break;
        }
    }

五、快速排序（Quicksort）

        快速排序（Quicksort）是对冒泡排序算法的一种改进。

        通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

void quicksort( Sqlist *l,int s,int t)
 { int i,j;  RedType temp;
    i=s;  j=t;  temp=l->r[s];
    while(i<j)
       { while((l->r[j].key>=temp.key) && (i<j))    j--;
          if(j>i) { l->r[i]=l->r[j];   i++; }
          while((l->r[i].key<=temp.key) &&(i<j))  i++;
          if(j>i) {l->r[j]=l->r[i];  j--;}     }     
    l->r[i]=temp;
    if(s<i-1)   quicksort(l,s,i-1);
    if(t>i+1)   quicksort(l,i+1,t); 
}

六、选择排序（Selection sort）

        选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

void selectsort(Sqilist *t)
  { RedType temp; int i,j,k;
     for(i=1;i<=t->length-1;i++)
       {k=i;
         for(j=i+1;j<=t->length;j++)
            if(t->r[j].key<t->r[k].key)   k=j;
        if(k!=i) {temp=t->r[i];t->r[i]=t->r[k];t->r[k]=temp; }
       }
   }