常見排序演算法的實現

插入排序是最簡單最直觀的排序演算法了，它的依據是：遍歷到第n個元素的時候前面的n-1個元素已經是排序好的了，那麼就查詢前面的n-1個元素把這第n個元素放在合適的位置，如此下去直到遍歷完序列的元素為止。

演算法的複雜度也是簡單的，排序第乙個需要1的複雜度，排序第二個需要2的複雜度，因此整個的複雜度就是

1 + 2 + 3 + …… + n = o（n ^ 2）的複雜度。

// 插入排序
void insertsort(int array, int length)
// 在合適位置安放當前元素
array[j + 1] = key;
}}

shell排序是對插入排序的乙個改裝，它每次排序把序列的元素按照某個增量分成幾個子串行，對這幾個子串行進行插入排序，然後不斷的縮小增量擴大每個子串行的元素數量，直到增量為一的時候子串行就和原先的待排列序列一樣了，此時只需要做少量的比較和移動就可以完成對序列的排序了。

// shell排序
void shellsort(int array, int length)
else
}// 在合適位置安放當前元素
array[j] = temp;
}}

堆的定義：

n個關鍵字序列kl，k2，…，kn稱為堆，當且僅當該序列滿足如下性質（簡稱為堆性質）：

（1） ki≤k2i且ki≤k2i+1 或（2）ki≥k2i且ki≥k2i+1（1≤i≤）

若將此序列所儲存的向量r[1……n]看做是一棵完全二叉樹的儲存結構，則堆實質上是滿足如下性質的完全二叉樹：樹中任一非葉結點的關鍵字均不大於（或不小於）其左右孩子（若存在）結點的關鍵字。

堆的這個性質使得可以迅速定位在乙個序列之中的最小（大）的元素。

堆排序演算法的過程如下：1）得到當前序列的最小（大）的元素 2）把這個元素和最後乙個元素進行

交換，這樣當前的最小（大）的元素就放在了序列的最後，而原先的最後乙個元素放到了序列的最前面 3）的

交換可能會破壞堆序列的性質（注意此時的序列是除去已經放在最後面的元素），因此需要對序列進行調整，使之滿足於上面堆的性質。重複上面的過程，直到序列調整完畢為止。

// array是待調整的堆陣列,i是待調整的陣列元素的位置,length是陣列的長度
void heapadjust(int array, int i, int nlength)
else　　　 // 否則退出迴圈
}// 最後把需要調整的元素值放到合適的位置
array[i] = ntemp;
}// 堆排序演算法
void heapsort(int array, int length)
// 從最後乙個元素開始對序列進行調整,不斷的縮小調整的範圍直到第乙個元素
for (int i = length - 1; i > 0; --i)
}

乙個測試及輸出的結果，在每次heapadjust之後顯示出來當前陣列的情況

before heap sort: 71 18 151 138 160 63 174 169 79 78 // 開始調整前半段陣列元素 71 18 151 138 160 63 174 169 79 78 71 18 151 169 160 63 174 138 79 78 71 18 174 169 160 63 151 138 79 78 71 169 174 138 160 63 151 18 79 78 174 169 151 138 160 63 71 18 79 78 // 開始進行全域性的調整 169 160 151 138 78 63 71 18 79 174 160 138 151 79 78 63 71 18 169 174 151 138 71 79 78 63 18 160 169 174 138 79 71 18 78 63 151 160 169 174 79 78 71 18 63 138 151 160 169 174 78 63 71 18 79 138 151 160 169 174 71 63 18 78 79 138 151 160 169 174 63 18 71 78 79 138 151 160 169 174

18 63 71 78 79 138 151 160 169 174

氣泡排序演算法的思想：很簡單，每次遍歷完序列都把最大（小）的元素放在最前面，然後再對剩下的序列從父前面的乙個過程，每次遍歷完之後待排序序列就少乙個元素，當待排序序列減小為只有乙個元素的時候排序就結束了。因此，複雜度在最壞的情況下是o（n ^ 2）。

void　 swap( int　*a,　 int　*b)
//　 氣泡排序
void　 bubblesort( int　 array,　int　 length)
}//　 如果這次遍歷沒有元素的交換,那麼排序結束
if ( false == exchange)
break ;
}}

快速排序的演算法思想：選定乙個樞紐元素，對待排序序列進行分割，分割之後的序列乙個部分小於樞紐元素，乙個部分大於樞紐元素，再對這兩個分割好的子串行進行上述的過程。

// 對乙個給定範圍的子串行選定乙個樞紐元素,執行完函式之後返回分割元素所在的位置,
// 在分割元素之前的元素都小於樞紐元素,在它後面的元素都大於這個元素
int partition(int array, int low, int high)
// 將這個比樞紐元素小的元素交換到前半部分
swap(&array[low], &array[high]);
// 從前往後在前半部分中尋找第乙個大於樞紐元素的元素
while (low < high && array[low] <= pivot)
// 將這個比樞紐元素大的元素交換到後半部分
swap(&array[low], &array[high]);
}// 返回樞紐元素所在的位置
return low;
}// 快速排序
void quicksort(int array, int low, int high)
}

歸併排序的演算法思想：把待排序序列分成相同大小的兩個部分，依次對這兩部分進行歸併排序，完畢之後再按照順序進行合併。

// 歸併排序中的合併演算法
void merge(int array, int start, int mid, int end)
// 拷貝後半部分陣列
for (int i = 0; i < n2; i++)
// 把後面的元素設定的很大
temp1[n1] = temp2[n2] = 1000;
// 逐個掃瞄兩部分陣列然後放到相應的位置去
for (int k = start, i = 0, j = 0; k <= end; k++)
else
}}// 歸併排序
void mergesort(int array, int start, int end)
}

常見排序演算法的實現

常見排序演算法的實現

常見排序演算法的實現

常見的排序演算法實現

相關推薦