一、快速排序的基本思想
??? 　設(shè)當(dāng)前待排序的無序區(qū)為R[low..high]，利用分治法可將快速排序的基本思想描述為：
①分解：
??? 　在R[low..high]中任選一個記錄作為基準(zhǔn)(Pivot)，以此基準(zhǔn)將當(dāng)前無序區(qū)劃分為左、右兩個較小的子區(qū)間R[low..pivotpos-1)和R[pivotpos+1..high]，并使左邊子區(qū)間中所有記錄的關(guān)鍵字均小于等于基準(zhǔn)記錄(不妨記為pivot)的關(guān)鍵字pivot.key，右邊的子區(qū)間中所有記錄的關(guān)鍵字均大于等于pivot.key，而基準(zhǔn)記錄pivot則位于正確的位置(pivotpos)上，它無須參加后續(xù)的排序。
? 注意：
??? 　劃分的關(guān)鍵是要求出基準(zhǔn)記錄所在的位置pivotpos。劃分的結(jié)果可以簡單地表示為(注意pivot=R[pivotpos])：
??? 　R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys
????????????????? 其中l(wèi)ow≤pivotpos≤high。
②求解：
?? 　 通過遞歸調(diào)用快速排序?qū)ψ?、右子區(qū)間R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。

完整的代碼如下：

#include<iostream> #include<stack> using namespace std; int partition(int *arr , int low , int high) {int pivo = arr[low];while(low < high){while(low < high && arr[high] >= pivo)--high;arr[low] = arr[high];while(low < high && arr[low] <= pivo)++low;arr[high] = arr[low];}arr[low] = pivo;return low; }// 快速排序 遞歸 void qsort(int *arr , int low , int high) {if(low < high){int pivo = partition(arr , low , high);qsort(arr , low , pivo-1);qsort(arr , pivo+1 , high);} }// 快速排序 非遞歸 void qsort_no_recursive(int *arr , int low , int high) {stack<int>s;int pivo;if(low < high){pivo = partition(arr , low , high);if(low < pivo - 1){s.push(low);s.push(pivo-1);}if(pivo + 1 < high){s.push(pivo+1);s.push(high);}while(!s.empty()){high = s.top();s.pop();low = s.top();s.pop();pivo = partition(arr , low , high);if(low < pivo - 1){s.push(low);s.push(pivo-1);}if(pivo + 1 < high){s.push(pivo+1);s.push(high);}}//while}//if }//簡單示例 ? int main(void) ? { ?int i , a[11] = {20,11,12,5,6,13,8,9,14,7,10}; ?printf("排序前的數(shù)據(jù)為：\n"); ?for(i = 0 ; i < 11 ; ++i) ?printf("%d ",a[i]); ?printf("\n"); ?//qsort(a , 0 , 10);qsort_no_recursive(a , 0 , 10);printf("排序后的數(shù)據(jù)為：\n"); ?for(i = 0 ; i < 11 ; ++i) printf("%d ",a[i]); ?printf("\n");return 0; ? } 二、希爾排序
???? 希爾排序（Shell Sort）又稱為縮小增量排序，輸入插入排序算法，是對直接排序算法的一種改進。本文介紹希爾排序算法。
???? 對于插入排序算法來說，如果原來的數(shù)據(jù)就是有序的，那么數(shù)據(jù)就不需要移動，而插入排序算法的效率主要消耗在數(shù)據(jù)的移動中。因此可知：如果數(shù)據(jù)的本身就是有序的或者本身基本有序，那么效率就會得到提高。
???? 希爾排序的基本思想是：將需要排序的序列劃分成為若干個較小的子序列，對子序列進行插入排序，通過則插入排序能夠使得原來序列成為基本有序。這樣通過對較小的序列進行插入排序，然后對基本有序的數(shù)列進行插入排序，能夠提高插入排序算法的效率。
???? 在希爾排序中首先解決的是子序列的選擇問題。對于子序列的構(gòu)成不是簡單的分段，而是采取相隔某個增量的數(shù)據(jù)組成一個序列。 增量一般的選擇原則是：取上一個增量的一半作為此次序列的劃分增量。首次選擇序列長度的一半為增量。
???? 先假如：數(shù)組的長度為10，數(shù)組元素為：25、19、6、58、34、10、7、98、160、0
???? 整個希爾排序的算法過程如下如所示：

上圖是原始數(shù)據(jù)和第一次選擇的增量 d = 5。本次排序的結(jié)果如下圖：

上圖是第一次排序的結(jié)果，本次選擇增量為 d=2。 本次排序的結(jié)果如下圖：

當(dāng)d=1 是進行最后一次排序，本次排序相當(dāng)于冒泡排序的某一次循環(huán)。最終結(jié)果如下：

在實際使用過程中，帶排序的數(shù)據(jù)肯定不是只有十個，但是上述是希爾排序的思想。其實希爾排序只是插入排序的一種優(yōu)化。
C++實現(xiàn)希爾排序的代碼如下所示：
#include<iostream> using namespace std;void shell_sort(int array[] , int length) {int i , j , temp;int d = length/2;?????? // 設(shè)置希爾排序的初始增量while(d >= 1){for(i = d ; i < length ; ++i){temp = array[i];j = i - d;?????? // 步長為d的前面一個位置while(j >= 0 && array[j] > temp)??????? // 從后往前進行插入排序{array[j + d] = array[j];j -= d;}array[j + d] = temp;???? // 找到了插入位置}d /= 2;} }int main(void) {int i , a[]={25,19,6,58,34,10,7,98,160,0};shell_sort(a , 10);for(i = 0 ; i < 10 ; ++i)cout<<a[i]<<" ";cout<<endl;system("pause");return 0; }// 模板 template<class T> void ShellSort(T *a,int len) //希爾排序算法 {int gap , j;for(gap = len / 2 ; gap > 0 ; gap /= 2){for(j = gap;j < len ; ++j) //j從gap個元素開始{if(a[j] < a[j - gap]) //每個元素與自己組內(nèi)的數(shù)據(jù)進行直接插入排序{T temp = a[j];int k = j - gap;while(k >= 0 && a[k] > temp){a[k + gap] = a[k];k -= gap;}a[k + gap] = temp;}}} } 三、插入排序
直接插入排序(direct Insert Sort)的基本思想是：順序地將待排序的記錄按其關(guān)鍵碼的大小插入到已排序的記錄子序列的適當(dāng)位置。子序列的記錄個數(shù)從1開始逐漸增大，當(dāng)子序列的記錄個數(shù)與順序表中的記錄個數(shù)相同時排序完畢。
void InsertSort(int array[] , int length) // 無哨兵的插入排序 {int i , j , temp;for(i = 1 ; i < length ; ++i){if(array[i] < array[i-1]){temp = array[i];for(j = i - 1 ; j >= 0 && array[j] > temp ;--j)array[j + 1] = array[j];array[j + 1] = temp;}} }void InsertSort(int array[] , int length) // 有哨兵的插入排序 {int i , j ;for(i = 1 ; i <= length ; ++i){if(array[i] < array[i-1]){array[0] = array[i];for(j = i - 1 ; array[j] > array[0] ;--j)array[j + 1] = array[j];array[j + 1] = array[0];}} } （1）時間、空間復(fù)雜度
????? 插入排序雖然在最壞情況下復(fù)雜性為O(n2)，但是對于小規(guī)模輸入來說，插入排序法是一個快速的排序法。從空間來看，它只需要一個元素的輔助空間，用于元素的位置交換O(1)。
（2）穩(wěn)定性:
???? 插入排序是穩(wěn)定的；因為具有同一值的元素必然插在具有同一值得前一個元素的后面，即相對次序不變。
四、簡單選擇排序
????? 簡單選擇排序的基本思想：第i趟簡單選擇排序是指通過n-i次關(guān)鍵字的比較，從n-i+1個記錄中選出關(guān)鍵字最小的記錄，并和第i個記錄進行交換。共需進行i-1趟比較，直到所有記錄排序完成為止。例如：進行第i趟選擇時，從當(dāng)前候選記錄中選出關(guān)鍵字最小的k號記錄，并和第i個記錄進行交換。
實現(xiàn)代碼如下：
void SelectSort(int array[] , int length) // 簡單選擇排序 {int i , j , k;for(i = 0 ; i < length-1 ; ++i){k = i;for(j = i + 1 ; j < length ; ++j) // 從后面選擇一個最小的記錄{if(array[j] < array[k])k = j;}if(k != i) // 與第i個記錄交換swap(array[i] , array[k]);} }（1）關(guān)鍵字比較次數(shù)
??? 　無論文件初始狀態(tài)如何，在第i趟排序中選出最小關(guān)鍵字的記錄，需做n-i次比較，因此，總的比較次數(shù)為：
???? n(n-1)/2=0(n2)
（2）記錄的移動次數(shù)
??? 　當(dāng)初始文件為正序時，移動次數(shù)為0
??? 　文件初態(tài)為反序時，每趟排序均要執(zhí)行交換操作，總的移動次數(shù)取最大值3(n-1)。
??? 　直接選擇排序的平均時間復(fù)雜度為O(n2)。
（3）直接選擇排序是一個就地排序
（4）穩(wěn)定性分析
??? 　 直接選擇排序是不穩(wěn)定的。
?? 【例】反例[2， 2，1]
五、歸并排序
void Merge(int array[] , int low , int mid , int high) {int i , j , k;int *temp = (int *)malloc((high - low + 1)*sizeof(int));i = low , j = mid + 1 , k = 0;while(i <= mid && j <= high){if(array[i] < array[j]) // 進行排序存入動態(tài)分配的數(shù)組中temp[k++] = array[i++];elsetemp[k++] = array[j++];}while(i <= mid) // 如果前一半中還有未處理完的數(shù)據(jù)，按順序移入動態(tài)分配的數(shù)組內(nèi)temp[k++] = array[i++];while(j <= high) // 如果前一半中還有未處理完的數(shù)據(jù)，按順序移入動態(tài)分配的數(shù)組內(nèi)temp[k++] = array[j++];for(i = low , j = 0; i<= high ; ++i)array[i] = temp[j++];free(temp); }void Msort(int array[] , int low , int high) {int mid;if(low < high){mid = (low + high)>>1;Msort(array , low , mid);Msort(array , mid + 1 , high);Merge(array , low , mid , high);} }
六、堆排序
void HeapAdjust(int array[] , int s , int m) // 對堆進行調(diào)整，使下標(biāo)從s到m的無序序列成為一個大頂堆 {int j , temp = array[s];for(j = 2*s; j <= m ; j *= 2){if(j < m && array[j] < array[j + 1]) // 如果結(jié)點的左孩子小于右孩子增加j的值++j; // 用于記錄較大的結(jié)點的下標(biāo)if(temp >= array[j]) // 如果父結(jié)點大于等于兩個孩子,則滿足大頂堆的定義，跳出循環(huán)break;array[s] = array[j]; // 否則用較大的結(jié)點替換父結(jié)點s = j; // 記錄下替換父結(jié)點的結(jié)點下標(biāo) }array[s] = temp; // 把原來的父結(jié)點移動到替換父結(jié)點的結(jié)點位置 }void HeapSort(int array[] , int len) {int i;for(i = len / 2; i >= 0 ; --i) // 建立大頂堆HeapAdjust(array , i , len-1);for(i = len - 1 ; i > 0 ; --i){swap(array[0] , array[i] ); // 第個元素和最后一個元素進行交換 HeapAdjust(array , 0 , i-1); // 建立大頂堆 } } 七、冒泡排序
// 將小元素冒泡到最前面，首先操作的是小元素 void Bubble_Sort1(int array[] , int len) {int i , j;for(i = 0 ; i < len - 1 ; ++i){for(j = i + 1 ; j < len ; ++j){if(array[j] < array[i])swap(array[i] , array[j] ); }} }// 將最大的元素冒泡到最后面 void Bubble_Sort2(int array[] , int len) {int i , j;for(i = 0 ; i < len ; ++i) //注意和上面的算法對照此循環(huán){for(j = 0 ; j < len - 1 - i ; ++j){if(array[j] > array[j + 1])swap(array[j] , array[j+1] ); }} }// 雙向冒泡 void Bubble_Sort3(int array[] , int len) {int left , right , i;left = 0 , right = len - 1;while(left < right){for(i = left ; i < right ; ++i) // 從左到右冒泡{if(array[i + 1] < array[i])swap(array[i] , array[i+1]);}--right;for(i = right ; i > left ; --i) // 從右到左冒泡{if(array[i ] < array[i - 1])swap(array[i] , array[i-1]);}++left;} }

總結(jié)

以上是生活随笔為你收集整理的快速排序、希尔排序、插入排序、选择排序、归并排序、堆排序总结的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。