一、插入排序（Insertion Sort）

1. 基本思想：每次將一個待排序的資料元素，插入到前面已經排好序的數列中的適當位置，使數列依然有序；直到待排序資料元素全部插入完為止。

二、選擇排序（Selection Sort）

1. 基本思想：每一趟從待排序的資料元素中選出最小（或最大）的一個元素，順序放在已排好序的數列的最後，直到全部待排序的資料元素排完為止。

三、氣泡排序（Bubble Sort）

1. 基本思想：兩兩比較待排序資料元素的大小，發現兩個資料元素的次序相反時即進行交換，直到沒有反序的資料元素為止。
2. 排序過程：設想被排序的陣列A［1..N］垂直豎立，將每個資料元素看作有重量的氣泡，根據輕氣泡不能在重氣泡之下的原則，從下往上掃描陣列A，凡掃描到違反本原則的輕氣泡，就使其向上"漂浮"，如此反覆進行，直至最後任何兩個氣泡都是輕者在上，重者在下為止。

四、快速排序（Quick Sort）

1. 基本思想：在當前無序區A[1..H]中任取一個數據元素作為比較的"基準"(不妨記為X)，用此基準將當前無序區劃分為左右兩個較小的無序區：A[1..I-1]和A[I+1..H]，且左邊的無序子區中資料元素均小於等於基準元素，右邊的無序子區中資料元素均大於等於基準元素，而基準X則位於最終排序的位置上，即A[1..I-1]≤X.Key≤A[I+1..H](1≤I≤H)，當A[1..I-1]和A[I+1..H]均非空時，分別對它們進行上述的劃分過程，直至所有無序子區中的資料元素均已排序為止。

五、堆排序（Heap Sort）

1. 基本思想：堆排序是一樹形選擇排序，在排序過程中，將A[1..N]看成是一顆完全二叉樹的順序儲存結構，利用完全二叉樹中雙親結點和孩子結點之間的內在關係來選擇最小的元素。
2. 堆的定義: N個元素的序列K1,K2,K3,...,Kn.稱為堆，當且僅當該序列滿足特性：
   　　K[i]≤K[2i]  K[i]≤K[2i+1]  (1≤ i≤ [N/2])

   堆實質上是滿足如下性質的完全二叉樹：樹中任一非葉子結點的關鍵字均大於（或小於）等於其孩子結點的關鍵字。如果一個堆中根結點（稱為堆頂）的關鍵字最小，我們把它稱為小根堆。反之，若完全二叉樹中任一非葉子結點的關鍵字均大於等於其孩子的關鍵字，則稱之為大根堆。

3. 排序過程：堆排序正是利用小根堆（或大根堆）來選取當前無序區中關鍵字最小（或最大）的記錄實現排序的。我們不妨利用大根堆來排序。每一趟排序的基本操作是：將當前無序區調整為一個大根堆，選取關鍵字最大的堆頂記錄，將它和無序區中的最後一個記錄交換。這樣，正好和直接選擇排序相反，有序區是在原記錄區的尾部形成並逐步向前擴大到整個記錄區。

   
   

六、幾種排序演算法的比較和選擇

1. 選取排序方法需要考慮的因素：
   (1) 待排序的元素數目n；
   (2) 元素本身資訊量的大小；
   (3) 關鍵字的結構及其分佈情況；
   (4) 語言工具的條件，輔助空間的大小等。
2. 小結：
   (1) 若n較小(n <= 50)，則可以採用直接插入排序或直接選擇排序。由於直接插入排序所需的記錄移動操作較直接選擇排序多，因而當記錄本身資訊量較大時，用直接選擇排序較好。
   (2) 若檔案的初始狀態已按關鍵字基本有序，則選用直接插入或氣泡排序為宜。
   (3) 若n較大，則應採用時間複雜度為O(nlog2n)的排序方法：快速排序、堆排序或歸併排序。快速排序是目前基於比較的內部排序法中被認為是最好的方法。
   (4) 在基於比較排序方法中，每次比較兩個關鍵字的大小之後，僅僅出現兩種可能的轉移，因此可以用一棵二叉樹來描述比較判定過程，由此可以證明：當檔案的n個關鍵字隨機分佈時，任何藉助於"比較"的排序演算法，至少需要O(nlog2n)的時間。

   #include "Sort.h"
   #include <iostream>
   using namespace std;
   
   
   Sort::Sort(void)
   {
   }
   
   
   Sort::~Sort(void)
   {
   }
   //氣泡排序
   //原理：每趟排序是通過比較兩兩相鄰的元素，大的向後移動，一趟
   //完後，最大的移動到最後，共需要size-1趟排序，特殊情況下，某趟未
   //移動任何元素，則說明序列已然有序，則排序完畢，此時趟數<size-1
   void Sort::maoPao(int data[],int size)
   {
       //換序標誌，如果本趟沒任何交換，表示已有序，退出
       bool flag = true;
       //需要size-1趟排序
       for (int i = 0; i < size - 1; i++)
       {
           //已有序，退出
           if (!flag)
               break;
           //先設為已有序，
           flag = false;
           for (int j = 0; j < size - i - 1; j++ )
           {
               //換序
               if (data[j] > data[j + 1])
               {
                   swap(data,j,j + 1);
                   //需要下一趟
                   flag = true;
               } 
           }
       }
       print(data,size);
   }
   //選擇排序
   //原理：每次選擇都是從序列中選擇最小的元素，放到序列前面，共需size-1次選擇
   void Sort::xuanZe(int data[],int size)
   {
       //需要size-1次選擇
       for (int i = 1; i < size; i++)
       {
           //記錄最小值下標
           int k = i - 1;
           for (int j = i; j < size; j++)
           {
               if (data[j] < data[k])
                   k = j;
           }
           if (k != i - 1)
               swap(data,k,i - 1);
       }
       print(data,size);
   }
   //直接插入排序
   //原理：將序列分為有序和無序兩部分，每次排序需要將無序區的一個元素
   //插入到有序區的合適位置，需要size-1次排序
   void Sort::chaRu(int data[],int size)
   {
       //data[0]為有序區，[1，size-1]為無序區，
       //一次遍歷無序區元素插入到有序區
       for (int i = 1; i < size; i++)
       {
           int temp = data[i];
           int j = i - 1;
           for (; j >=0 && data[j] > temp; j--)
           {
               swap(data,j,j+1);
           }
           data[j + 1] = temp;
       }
       print(data,size);
   }
   //歸併排序
   //原理：一次歸併可描述為，將一個序列分成兩組，將這兩組歸併為一個有序的新序列，
   //歸併排序就是遞迴的進行上述操作（遞迴棧的最底部是將序列分成了[一個元素]、[一個元素]
   //這樣的兩組），我的表達能力也就到這了
   void Sort::guiBing(int data[],int size)
   {
       mergeSort(data,0,size - 1);
       print(data,size);
   }
   void Sort::mergeSort(int data[],int first,int last)
   {
       //遞迴出口，只歸併長度大於1的陣列
       if (first < last)
       {
           int mid = (first + last)/2;
           //遞迴左半組
           mergeSort(data,first,mid);
           //遞迴右半組
           mergeSort(data,mid + 1,last);
           //左右半組都排好後，再對著兩組排序
           merge(data,first,mid,last);
       }
       
   }
   //歸併兩個陣列[first,mid]、[mid+1,last]，最後合併為一個有序的陣列[first,last]
   void Sort::merge(int data[],int first,int mid,int last)
   {
       int *temp = new int[last - first + 1];
       int k = 0;
       int index1 = first;
       int index2 = mid + 1;
       while (index1 <= mid && index2 <= last)
       {
           if (data[index1] <= data[index2])
               temp[k++] = data[index1++];
           else
               temp[k++] = data[index2++];
       }
       while (index1 <= mid)
           temp[k++] = data[index1++];
       while (index2 <= last)
           temp[k++] = data[index2++];
       for (int i = 0; i < k; i++)
           data[first + i] = temp[i];
       delete[] temp;
   }
   //快速排序
   //原理：一次快排可描述為，將序列分成三部分[左邊組都小於中間數]、[中間數]、[右邊組都大於中間數]
   //快排就是再遞迴的對左邊組和右邊組進行上述操作
   void Sort::kuaiPai(int data[],int size)
   {
       quickSort(data,0,size - 1);
       print(data,size);
   }
   void Sort::quickSort(int data[],int left,int right)
   {
       //遞迴出口
       if (left < right)
       {
           int mid = partion(data,left,right);
           quickSort(data,left,mid - 1);
           quickSort(data,mid + 1,right);
       }
   }
   //一趟分組，執行完後分為左右兩組,左組都小於中間數，右組都大於中間數
   int Sort::partion(int data[],int left,int right)
   {
       //第一個數做中間值
       int temp = data[left];
       int leftIndex = left;
       int rightIndex = right;
       //相等時退出
       while (leftIndex < rightIndex)
       {
           //從右邊找到數值<temp的數
           while (leftIndex < rightIndex && data[rightIndex] >= temp)
               rightIndex--;
           //把找到的數放到中間數位置,此時data[rightIndex]相當於中間數位置
           if (leftIndex < rightIndex)
               data[leftIndex++] = data[rightIndex];
           //從左邊找到數值>temp的數
           while (leftIndex < rightIndex && data[leftIndex] < temp)
               leftIndex++;
           //把找到的數放到中間數位置
           if (leftIndex < rightIndex)
               data[rightIndex--] = data[leftIndex];
       }
       //最後將中間數放到真正的中間位置,此時leftIndex=rightIndex
       data[leftIndex] = temp;
       //返回中間數下標，以便對左右兩組繼續排序
       return leftIndex;
   }
   //希爾排序
   //原理：屬於一種改進的插入排序，將序列按照特定的步長分成若干個子序列，
   //對各個子序列進行插入排序，然後再按照更小的步長分成若干子序列，對子序列排序，
   //......最後一步的步長為1，這樣最後一步則“等於”直接插入排序了，此時的序列是
   //基本有序的，直接插入排序對有序序列的排序效率是很高的
   void Sort::xiEr(int data[],int size)
   {
       int temp;
       for (int d = size/2; d >=1; d = d/2)
       {
           for (int i = d; i < size; i++)
           {
               int j = i - d;
               temp = data[i];
               while (j >= 0 && data[j] > temp)
               {
                   data[j + d] = data[j];
                   j -= d;  
               }
               if (j != i - d)
                   data[j + d] = temp;  
           }
       }
       print(data,size);
   }
   //交換陣列中兩個元素
   void Sort::swap(int data[],int i,int j)
   {
       int temp = data[i];
       data[i] = data[j];
       data[j] = temp;
   }
   void Sort::print(int data[],int size)
   {
       for (int i = 0; i < size; i++)
       {
           cout<<data[i]<<"  ";
       }
       cout<<endl;
   }
   

   
   
   (5) 當記錄本身資訊量較大時，為避免耗費大量時間移動記錄，可以用連結串列作為儲存結構。