基於整型數組的幾種基本的排序算法

1、選擇排序(排成從小到大的順序)（不穩定，時間複雜度：最差、平均都是O(n²)）

   1.算法思路:

      ①找出數組中最小的數與第一個數進行交換;

      ②找出數組中第二小的數與第二個數進行交換

      ③依此類推，直到數組排序完畢.

  2.例子:

void SelectSort(int Arr[],int length)
{
   for(int m=0;m<length;m++)
   {
    int min=Arr[m];
    int index=m;
    for(int n=m+1;n<length;n++)
    {
      if(Arr[n]<min)
   { 
    min=Arr[n];
    index=n;
   }
 }
 if(index!=m)
 {
   int temp=Arr[index];
   Arr[index]=Arr[m];
   Arr[m]=temp;
 }
   }
}

2、冒泡排序(排成從小到大的順序，大冒狀況)(穩定，時間複雜度:最差、平均都是O(n²)，最好是O(n)（正序狀況）)

1.算法思路:

  ①順序遍歷數組，相鄰兩個元素兩兩比較，大的日後交換

  ②第一遍將最大的數冒到最後一位

  ③第二遍將第二大的數冒到倒數第二位

  ④依次類推，遍歷n-1遍便可排好序

2.例子:

void BubbleSort(int Arr[],int length)
{
   for(int m=0;m<length;m++)
   {
    for(int n=0;n<length-m-1;n++)
    {
      if(Arr[n]>Arr[n+1])
   { 
    int temp=Arr[n];
    Arr[n]=Arr[n+1];
    Arr[n+1]=temp;
   }
 }
   }
}

 

3、直接插入排序(排成從小到大的順序)(穩定，時間複雜度：最差、平均都是O(n²)、最好:O(n))

1.算法思路:

 ①從第二個元素開始執行第一遍「插入」算法，將當前元素與前面(已經排好序)的元素依次進行比較

 ②當前元素是從後往前比較前面已經排好序的元素的，遇到比本身大的元素時與之交換，遇到比本身小的元素或到數組起始位置時停留在原位置不動，算是「插入」結束

 ③接着第三個元素開始執行第二遍"插入"算法，依次類推，數組中全部元素都"插入"完畢也就排好序了

2.例子:

  void InsertSort(int Arr[],int length)
{
   for(int m=1;m<length;m++)
   {
    for(int n=m;n>0;n--)
    {
      if(Arr[n-1]>Arr[n])
   { 
    int temp=Arr[n];
    Arr[n]=Arr[n-1];
    Arr[n-1]=temp;
   }
 }
   }
}

 

4、二分插入排序(穩定，時間複雜度：最差、平均都是O(n²)、最好:O(nlogn))

1.算法思路:

 ①.從數組第二個元素開始執行算法，將當前元素做爲待插元素，折半查找待插元素在前面已經排好的序列中應該插入的位置index

 ②.將應該插入的位置index到待插元素當前位置前一位這一段元素所有後移一位

 ③.將待插元素插入到待插位置

 ④.當全部元素插入完畢時，便可完成排序。

2.例子:

void MiddleSort(int Arr[],int length)
{
  for(int m=1;m<length;m++)
  {
    int low=0;
    int high=m-1;
    int key=Arr[m];
    while(low<=high)
    {
      int middle=(low+high)/2;
      if(key<Arr[middle])
           high=middle-1;
      else
           low=middle+1;       
 }
 
 for(int n=m-1;n>=low;n--)
 {
      Arr[n+1]=Arr[n];
 }
 Arr[low]=key;
  }
}

 

5、希爾排序(不穩定,時間複雜度：O(nlogn))

1.算法思路：

①希爾排序本質上是直接插入排序的變種，直接插入排序是相鄰元素的交換移動，這樣作效率低，希爾排序進行交換的元素的間隔爲dl(dl>=1)，這個dl叫作增量

②給增量一個初始值,將數組劃分爲dl個字數組，全部距離爲dl的元素互爲同一子數組，用直接插入法排序全部子數組

③變小增量值，重複上一操做

④直到增量值爲1，希爾排序跟直接插入排序操做同樣（只不過這時，數組有不少段是連續的），排序完畢 

2.例子:

  void ShellPass(int Arr[],int length,int dl)
{
  for(int m=0+dl;m<length;m++)
  { 
 for(int n=m;n>=0+dl;n=n-dl)
 {
      if(Arr[n-dl]>Arr[n])
      {
     int temp=Arr[n-dl];
     Arr[n-dl]=Arr[n];
     Arr[n]=temp;
   }
 }
  }
}

 

void int ShellSort(int Arr,int lenth,int n)
{
   int dl=n;
   do{
     dl=dl/3+1;
     ShellPass(Arr,lenth,dl);       
   }while(dl>1);
}

 

6、快速排序(不穩定,時間複雜度：最差O(n²)、平均O(nlogn))

1.算法思路：

 ①快排採用的是分治的策略，把數組中一個元素做爲基數，將數組分紅左右兩字段，左邊全部元素均小於等於該基數，右邊全部元素均大於等於該基數，遞歸操做字段，到字段長度爲1時，便可排好序。

 ②將待排序列第一項做爲該次排序的基數，有兩個指針left、right，初始值分別爲待排序列最左端和最右端；

 ③首先right向左邊移動（不越過left,這是由於此時left指向的位置要存入待轉移的元素，要保證right不能超過該位置），找到一個小於基數的元素的位置，將該元素轉移到left指向的位置，同時left後移一位；

 ④而後left向右邊移動（不越過right,這是由於此時right指向的位置存入待轉移的元素，要保證left不能超過該位置），找到一個大於基數的元素的位置，將該元素轉移到right指向的位置，同時right前移一位;

 ⑤待left和right重逢時(left==right)，left所指向的位置就是該次待排序列的分割點，將基數存入left位置，left左邊的元素均小於等於基數，右邊均大於等於基數

 ⑥遞歸操做被分割出來的兩個子序列序列，直到序列長度等於1時，排序結束

 

2.例子:void QuickSort(int Arr[] ,int m,int n){   if(m==n) return;   int left=m,right=n;   int base=Arr[left];   while(left<right)   {     while((left<right)&&(Arr[right]>base))  {    right--;  }    if(left<right)  {    Arr[left]=Arr[right];    left++;  }      while((left<right)&&(Arr[left]<base))  {    left++;  }    if(left<right)  {    Arr[right]=Arr[left];    right--;    }   }   Arr[left]=base;   QuickSort(Arr,m,left-1);   QuickSort(Arr,left+1,n);}