數據結構——排序

排序的定義
  假設含有n個記錄的序列爲{r1,r2,r3,...,rn}
  其相應的關鍵字爲{k1,k2,k3,...,kn}
  需肯定一種排序列p1,p2,p3,...,pn
  使其相應的關鍵字知足kp1<kp2<kp3<...<kpn關係
  即便得序列成爲一個按關鍵字有序的序列{rp1,rp2,rp3,...,rpn}

排序的穩定性
  假設ki=kj(1<=i<=n,1<=j<=n,i!=j)
  在排序前
    序列中ri領先於rj(i<j)
  若是
    ri仍領先於rj，則稱所用的排序方法是穩定的
    rj領先ri，則稱所用的排序方法是不穩定的

內排序
  在排序的整個過程當中，待排序的全部記錄所有被放置在內存中

  排序算法的性能受3方面的影響
    時間性能：時間開銷是衡量排序算法好壞的標誌
    輔助空間：算法執行時所須要的額外內存空間
    算法的複雜性：算法過於複雜會影響算法的效率

外排序
  在排序的整個過程當中，須要在內外存之間屢次交換排序的記錄

 

1 最簡單的冒泡排序

void bubbleSort(int a[],int len) //int a[]等效於int *a
{
  for(int i=0;i<=len-1;i++)
  {
    for(int j=i+1;j<len;j++)
    {
      if(a[i]>a[j])
      {
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
      }
    }
  }
}

void main()
{
  int a[]={7,3,5,9,1,8,2,4,6,0};
  bubbleSort(a,10);
}

2 真正的冒泡排序

void bubbleSort(int a[],int len)
{
  for(int i=0;i<=len-1;i++)
  {
    for(int j=len-1;j>=1+i;j--)
    {
      if(a[j]<a[j-1])
      {
        int temp=a[j];
        a[j]=a[j-1];
        a[j-1]=temp;
      }
    }
  }
}

void main()
{
  int a[]={7,3,5,9,1};
  bubbleSort(a,5);
}

3 冒泡排序的優化

void bubbleSort(int a[],int len)
{
  for(int i=0;i<len;i++)
  {
    bool flag=false;
    for(int j=len-1;j>=i+1;j--)
    {
      if(a[j]<a[j-1])
      {
        int temp=a[j];
        a[j]=a[j-1];
        a[j-1]=temp;
        flag=true;
      }
    }
    if(flag==false)
      continue;
  }
}

void main()
{
  int a[]={7,3,5,9,1};
  bubbleSort(a,5);
}

4 簡單選擇排序

 1 void selectSort(int a[],int len)
 2 {
 3   for(int i=0;i<len-1;i++)
 4   {
 5     int min=i;
 6     for(int j=i+1;j<len;j++)
 7     {
 8       if(a[min]>a[j])
 9       {
10         min=j;
11       }
12     }
13     if(i!=min)
14     {
15       int temp=a[i];
16       a[i]=a[min];
17       a[min]=temp;
18     }
19   }
20 }
21 
22 void main()
23 {
24   int a[]={7,3,5,9,1};
25   selectSort(a,5);
26 }

5 直接插入排序

void insert(int a[],int n)
{
  for(int i=1;i<n;i++)
  {
    //把選擇的元素放在臨時變量中
    int t=a[i];
    int j=0;
    for(j=i-1;j>=0 && a[j]>t;j--)
    {
      a[j+1]=a[j];
    }
    a[j+1]=t;
  }
}

void main()
{
  int a[]={7,3,5,2,8};
  insert(a,5);
}

6 希爾排序

void shellSort(int a[],int len)
{
  int increment=len;
  while(increment>1)
  {
    increment=increment/3+1;
    for(int i=increment;i<len;i++)
    {
      int key=a[i];
      int j=i-increment;
      while(j>=0)
      {
        if(key<a[j])
        {
          int temp=a[j];
          a[j]=key;
          a[j+increment]=temp;
        }
        j=j-increment;
      }
    }
  }
}

void main()
{
  int a[]={7,3,5,2,8};
  shellSort(a,5);
}

7 堆排序

void heapAdjust(int a[],int s,int m)
{
  int temp;
  int child;
  for(temp=a[s];2*s+1<m;s=child)
  {
    child=2*s+1;  //數組下標是從0開始，因此不是2*s
    if(child!=m-1 && a[child]<a[child+1])
    {
      ++child;  //找到最大的兒子結點
    }
    if(temp<a[child])
    {     
      a[s]=a[child];
    }
    else
      break;
  }
  a[s]=temp;
}

void heapSort(int a[],int len)
{
  for(int i=len/2;i>=0;i--)
  {
    heapAdjust(a,i,len);  //構造堆
  }
  for(int i=len-1;i>0;i--)
  {
    int temp=a[0];
    a[0]=a[i];
    a[i]=temp;
    heapAdjust(a,0,i);
  }
}

void main()
{
  int a[]={7,3,5,2,8};
  heapSort(a,5);
}

8 歸併排序

void mergeSort(int a[],int len)
{
  merge(a,a,0,len-1);
}

void mSort(int sr[],int tr1[],int s,int t)
{
  if(s==t)
  {
    tr1[s]=sr[s];
  }
  else
  {
    int tr2[MAXSIZE+1];
    int m=(s+t)/2;
    mSort(sr,tr2,s,m);
    mSort(sr,tr2,m+1,t);
    merge(tr2,tr1,s,m,t);
  }
}

void merge(int sr[],int tr[],int i,int m,int n)
{
  int j,k,l;
  for(int j=m+1,k=i;i<=m && j<=n;k++)
  {
    tr[k]=sr[i]<sr[j]?sr[i++]:sr[j++]
  }
  if(i<=m)
  {
    for(l=0;l<=m-i;l++)
    {
      tr[k+l]=sr[i+1];
    }
  }
  if(j<=n)
  {
    for(l=0;l<=n-j;l++)
    {
      tr[k+l]=sr[j+1];
    }
  }
}

void main()
{
  int a[]={7,3,5,2,8};
  mergeSort(a,5);
}

9 快速排序

  原理：

  1.按從小到大排序

  2.定義一個key=a[0]爲基準元素，low=0；high=n-1(n爲數組元素個數)；
  3.首先key與a[high]比較.若是key<=a[high],high就減1(即high--),直到找到一個比key小的數據(key>a[high])；而後交換此時的兩個數據，並將low加1(即low++)；
  4.比較此時key與a[low]的大小.若是key>=a[low],low就加1(即low++)，直到找到一個比key大的數據(即key<a[low]),而後交換此時的兩個數據，並將high減1(即high--)；
  5.重複三、4步驟，直到low=high，此時的數據至關於分爲兩個數組:等於key左邊的數據都小於key，等於key右邊的數據都大於key

  6.繼續排序key左右兩邊的數據，重複二、三、4步驟

 1 #include <stdio.h>
 2 
 3 int main()
 4 {
 5     int i;
 6     int a[]={35,12,37,-58,54,76,22};
 7     quicksort(a,0,6);
 8     for(i=0;i<7;i++)
 9     {
10         printf("%d\n",a[i]);
11     }
12 }
13 
14 void swap(int *p,int *q)
15 {
16     int buf;
17     buf=*p;
18     *p=*q;
19     *q=buf;
20     return;
21 }
22 
23 int quicksort(int *a,int low,int high)
24 {
25     int i=low;
26     int j=high;
27     int key=a[low];
28     if(low>=high)
29     {
30         return;
31     }
32     while(low<high)
33     {
34         while(low<high && key<=a[high])
35         {
36             high--;//please
37         }
38         if(key>a[high])
39         {
40             swap(&a[low],&a[high]);
41             low++;
42         }
43         while(low<high && key>=a[low])
44         {
45             low++;
46         }
47         if(key<a[low])
48         {
49             swap(&a[low],&a[high]);
50             high--;
51         }    
52     }
53     quicksort(a,i,low-1);
54     quicksort(a,low+1,j);
55 }