數據結構——排序法

排序；
一、插入排序（直接插入排序和希爾排序）
二、選擇排序（直接選擇排序和堆排序）
三、交換排序（冒泡排序和快速排序）
四、歸併排序
五、基數排序

－－－－－－－－－－－－－－－－－－－－－
直接插入排序
說明：逐個將後一個數加到前面的排好的序中。在直接插入排序過程當中，對其中一個記錄的插入排序稱爲一次

排序；直接插入排序是從第二個記錄開始進行的，所以，長度爲n的記錄序列須要進行n-1次排序才能完成整個

序列的排序。時間複雜度爲O(n2)。
void InsertSort(elemtype x[],int n)
/*用直接插入法對x[0]-x[n-1]排序*/
{
  int i,j;
  elemtype s;
  for(i=0;i<n-1;i++) 
  {
    s=x[i+1];
    j=i;
    while(j>-1&&s.key<x[j].key)
    {
      x[j+1]=x[j];
      j--;
    }
    x[j+1]=s;
  }
}

－－－－－－－－－－－－－－－－－－－－－
希爾排序
說明：希爾排序又稱縮小增量排序，增量di能夠有各類不一樣的取法，但最後一次排序時的增量必須爲1，最簡

單可取di+1=di/2（取小）。時間複雜度爲O(n(log2n)2)。

void ShellSort(elemtype x[],int n,intd[],int Number)
/*用希爾排序法對記錄x[0]-x[n-1]排序，d爲增量值數組*/
/*Number爲增量值個數，各組內採用直接插入法排序*/
{
  int i,j,k,m,Span;
  elemtype s;
  for(m=0;m<Number;m++) 
  {
    Span=d[m];
    for(k=0;k<Span;k++)
    {
     for(i=k;i<n-1;i+=Span)/*這個for以後的是「組內採用直接插入法排序」*/
      {
       s=x[i+Span];
       j=i;
       while(j>-1&&s.key<x[j].key) 
       {
         x[j+Span]=x[j];
         j-=Span;
       }
       x[j+Span]=s;
      }
    }
  }
}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－
直接選擇排序
說明：每次將後面的最小的找出來插入前面的已排好的序中。同理，具備n個記錄的序列要作n-1次排序。
時間複雜度爲O(n2)。
void SelectSort(elemtype x[],int n)
/*用直接選擇排序法對x[0]-x[n-1]排序*/
{
  int i,j,Small;
  elemtype Temp;
  for(i=0;i<n-1;i++)
  {
    Small=i;
    for(j=i+1;j<n;j++) 
     if(x[j].key<x[Small].key)
       Small=j;
    
    if(Small!=i)
     {
       Temp=x[i];
       x[i]=x[Small];
       x[Small]=Temp;  
     }
  } 
}

－－－－－－－－－－－－－－－－－－－－－－－－－－
冒泡排序
說明：兩個兩個比較，將大的日後移。經過第一次冒泡排序，使得待排序的n個記錄中關鍵字最大的記錄排到

了序列的最後一個位置上。而後對序列中前n-1個記錄進行第二次冒泡排序。。。對於n個記錄的序列，共需進

行n次冒泡排序。時間複雜度爲O(n2)。

void BubbleSort(elemtype x[],int n)
/*用冒泡排序法對x[0]-x[n-1]排序*/
{
  int i,j,flag=1;
  elemtype Temp;
  for(i=1;i<n&&flag==1;i++) 
  {
    flag=0;
    for(j=0;j<n-i;j++)
    {
      if(x[j].key>x[j+1].key)
       {
          flag=1;
          Temp=x[j];
          x[j]=x[j+1];
          x[j+1]=Temp;
       }
    } 
  }
}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
快速排序
說明：又叫分區交換排序，是對冒泡排序方法的一種改進。時間複雜度爲O(nlog2n)。

void QuickSort(elemtype x[],int low,int high)
/*用遞歸方法對記錄x[0]-x[n-1]進行快速排序*/
{
  int i,j;
  elemtype Temp;

  i=low;
  j=high;
  Temp=x[low];

  while(i<j)
  {
    /*在序列的右端掃描*/
    while(i<j&&Temp.key<=x[j].key)j--;
    if(i<j)
    {
      x[i]=x[j];
      i++;
    }

    /*在序列的左端掃描*/
    while(i<j&&x[i].key<Temp.key)i++;
    if(i<j) 
    {
      x[j]=x[i];
      j--;
    }
  }  
    x[i]=Temp;

   /*對子序列進行快速排序*/  
   if(low<i-1)QuickSort(x,low,i-1);
   if(j+1<high)QuickSort(x,j+1,high);
}

－－－－－－－－－－－－－－－－－－－－－－－－－
歸併排序
說明：所謂歸併排序就是將兩個或兩個以上的有序數據序列合併成一個有序數據序列的過程。
時間複雜度爲O(nlog2n)。

void merge(r,l,m,h,r1,r2)/*r[l,m]及r[m+1,h]分別有序，歸併後置於r2中*/
sqlist r,r2;
int l,m,h;
{
  int i,j,k;
  k=l;/*k是r2的指示器，i、j分別爲s一、s2的指示器*/
  i=l;
  j=m+1;

  while(i<=m&&j<=h)   {     if(r[i].key<=r[j].key)      {         r2[k]=r[i];         i++;      }      else      {         r2[k]=r[j];         j++;      }     k++;    }   if(i>m)  /*s1結束*/    while(j<=h)     {     r2[k]=r[j];     j++;k++;    }    else    while(i<=m)     {       r2[k]=r[i];       i++;k++;      } }