今天我們來總結一下經典常用的排序算法。
排序算法可以分為內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。
常見的內部排序算法有：插入排序、希爾排序、選擇排序、冒泡排序、歸并排序、快速排序、堆排序、基數排序等。
本文將依次介紹上述八大排序算法。
冒泡排序
冒泡排序（Bubble Sort）是一種簡單直觀的排序算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。
算法步驟：
比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數。
針對所有的元素重復以上的步驟，除了最后一個。
持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
#pragma mark---冒泡排序---
- (void)bubbleSort:(NSMutableArray *)mutArr {
if(mutArr == nil || mutArr.count == 0){
return;
}
for (int i = 0; i < mutArr.count; i ++) {
for (int j = i + 1; j < mutArr.count; j ++) {
if (mutArr[i]> mutArr[j]) {
[mutArr exchangeObjectAtIndex:i withObjectAtIndex:j];
}
}
}
NSLog(@"bubbleSort -- mutArr == %@",mutArr);
}
插入排序
插入排序是一種最簡單直觀的排序算法，它的工作原理是通過構建有序序列，對于未排序數據，在已排序序列中從后向前掃描，找到相應位置并插入。
算法步驟：
將第一待排序序列第一個元素看做一個有序序列，把第二個元素到最后一個元素當成是未排序序列。
從頭到尾依次掃描未排序序列，將掃描到的每個元素插入有序序列的適當位置。（如果待插入的元素與有序序列中的某個元素相等，則將待插入元素插入到相等元素的后面。）
#pragma mark---插入排序---
- (void)insertSort:(NSMutableArray *)mutArr {
if(mutArr == nil || mutArr.count == 0){
return;
}
id temp;
int i, j;
for (i = 1; i < mutArr.count; i ++) {
temp = mutArr[i];
for (j = i; j > 0 && temp < mutArr[j - 1]; j --) {
mutArr[j] = mutArr[j - 1];
}
mutArr[j] = temp ;
}
NSLog(@"insertSort -- mutArr == %@",mutArr);
}
選擇排序
選擇排序(Selection sort)也是一種簡單直觀的排序算法。
算法步驟：
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；
再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾；
重復第二步，直到所有元素均排序完畢。
#pragma mark---選擇排序---
- (void)selectSort:(NSMutableArray *)mutArr {
if(mutArr == nil || mutArr.count == 0){
return;
}
int minimum;
for (int i = 0; i < mutArr.count; i ++) {
minimum = i;
for (int j = i + 1; j < mutArr.count; j ++) {
if (mutArr[minimum] > mutArr[j]) {
minimum = j;
}
}
if (minimum != i) {
id temp = mutArr[minimum];
mutArr[minimum] = mutArr[i];
mutArr[i] = temp;
}
}
NSLog(@"selectSort -- mutArr == %@",mutArr);
}
快速排序
快速排序是由東尼·霍爾所發展的一種排序算法。在平均狀況下，排序 n 個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況并不常見。事實上，快速排序通常明顯比其他Ο(n log n) 算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。
快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分為兩個子串行（sub-lists）。
算法步驟：
從數列中挑出一個元素，稱為 “基準”（pivot）。
重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數可以到任一邊）。在這個分區退出之后，該基準就處于數列的中間位置。這個稱為分區（partition）操作。
遞歸地（recursive）把小于基準值元素的子數列和大于基準值元素的子數列排序。
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會退出，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。
#pragma - mark 快速排序
- (void)quickSort:(NSMutableArray *)array low:(int)low high:(int)high {
if(array == nil || array.count == 0) {
return;
}
if (low >= high) {
return;
}
//取中值
int middle = low + (high - low)/2;
NSNumber *prmt = array[middle];
int i = low;
int j = high;
//開始排序，使得left<prmt 同時right>prmt
while (i <= j) {
// while ([array[i] compare:prmt] == NSOrderedAscending) { 該行與下一行作用相同
while ([array[i] intValue] < [prmt intValue]) {
i++;
}
// while ([array[j] compare:prmt] == NSOrderedDescending) { 該行與下一行作用相同
while ([array[j] intValue] > [prmt intValue]) {
j--;
}
if(i <= j){
[array exchangeObjectAtIndex:i withObjectAtIndex:j];
i++;
j--;
}
NSLog(@"排序中:");
[self printArray:array];
}
if (low < j) {
[self quickSort:array low:low high:j];
}
if (high > i) {
[self quickSort:array low:i high:high];
}
}
- (void)printArray:(NSArray *)array {
for(NSNumber *number in array) {
NSLog(@"%d ",[number intValue]);
}
printf("\n");
}
堆排序
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，并同時滿足堆積的性質：即子結點的鍵值或索引總是小于（或者大于）它的父節點。
堆排序的平均時間復雜度為Ο(nlogn) 。
算法步驟：
創建一個堆H[0..n-1]；
把堆首（最大值）和堆尾互換；
把堆的尺寸縮小1，并調用shift_down(0),目的是把新的數組頂端數據調整到相應位置；
重復步驟2，直到堆的尺寸為1
#pragma mark---堆排序---
//每次執行最大堆(索引要向前前移動 即排除已經排好的最大堆頭元算 交換到list尾部的這個元素)
- (void)HeapSort:(NSMutableArray *)list{
for(NSInteger i = [list count] ; i > 0; i--){
[self CreateBiggestHeap:list Count:i];
[list exchangeObjectAtIndex:(i-1) withObjectAtIndex:0];
}
NSLog(@"%@",list);
}
//創建最大堆heap 最大／最小優先級隊列
- (void)CreateBiggestHeap:(NSMutableArray *)list Count:(NSInteger)count{
NSInteger lastParentIndex = (count - 2)/2;
for(NSInteger i = lastParentIndex; i >= 0 ; i--){
NSInteger parentIndex = i;
NSInteger parentNode = [[list objectAtIndex:parentIndex] intValue];
//獲取左子結點為當前子結點
NSInteger currentChildIndex = 2*i + 1;
while (currentChildIndex <= count - 1) {
NSInteger leftChildNode = [[list objectAtIndex:(currentChildIndex)] intValue];
if((currentChildIndex + 1) <= count-1) {//表示存在右子結點
//讀取右子結點
NSInteger rightChildIndex = currentChildIndex + 1;
NSInteger rightChildNode = [[list objectAtIndex:(rightChildIndex)] intValue];
//如果右子結點為最大
if(rightChildNode > leftChildNode && rightChildNode > parentNode) {
[list exchangeObjectAtIndex:parentIndex withObjectAtIndex:rightChildIndex];
currentChildIndex = rightChildIndex;//右子結點為當前子結點 繼續循環
//左子結點最大
}else if(leftChildNode > rightChildNode && leftChildNode > parentNode) {
[list exchangeObjectAtIndex:parentIndex withObjectAtIndex:currentChildIndex];
}
}else{
if(leftChildNode > parentNode) {
[list exchangeObjectAtIndex:parentIndex withObjectAtIndex:currentChildIndex];
}
}
//更新父結點和下一個子結點
parentIndex = currentChildIndex;
currentChildIndex = 2*currentChildIndex + 1;
}
}
}
希爾排序
希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進版本。但希爾排序是非穩定排序算法。
希爾排序是基于插入排序的以下兩點性質而提出改進方法的：
插入排序在對幾乎已經排好序的數據操作時， 效率高， 即可以達到線性排序的效率；
但插入排序一般來說是低效的， 因為插入排序每次只能將數據移動一位。
希爾排序的基本思想是：先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行依次直接插入排序。
算法步驟：
選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列個數k，對序列進行k 趟排序；
每趟排序，根據對應的增量ti，將待排序列分割成若干長度為m 的子序列，分別對各子表進行直接插入排序。僅增量因子為1 時，整個序列作為一個表來處理，表長度即為整個序列的長度。
#pragma mark---希爾排序---
- (void)shellSort:(NSMutableArray *)list{
NSInteger gap = [list count] / 2;
while (gap >= 1) {
for(NSInteger i = gap ; i < [list count]; i++){
NSInteger temp = [[list objectAtIndex:i] intValue];
NSInteger j = i;
while (j >= gap && temp < [[list objectAtIndex:(j - gap)] intValue]) {
[list replaceObjectAtIndex:j withObject:[list objectAtIndex:j-gap]];
j -= gap;
}
[list replaceObjectAtIndex:j withObject:[NSNumber numberWithInteger:temp]];
}
gap = gap / 2;
}
NSLog(@"%@",list);
}
歸并排序
歸并排序（Merge sort）是建立在歸并操作上的一種有效的排序算法。該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。
算法步驟：
申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合并后的序列；
設定兩個指針，最初位置分別為兩個已經排序序列的起始位置；
比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置；
重復步驟3直到某一指針達到序列尾；
將另一序列剩下的所有元素直接復制到合并序列尾。
#pragma mark---歸并排序---
- (NSArray *)mergeSortWithArray: (NSArray *)array {
if (array.count <= 1) {
return array;
}
NSInteger _number = array.count/2;
NSArray *_leftArray = [self mergeSortWithArray:
[array subarrayWithRange:NSMakeRange(0, _number)]];
NSArray *_rightArray = [self mergeSortWithArray:
[array subarrayWithRange:NSMakeRange(_number, array.count-_number)]];
return [self mergeWithLeftArray:_leftArray rightArray:_rightArray];
}
- (NSArray *)mergeWithLeftArray: (NSArray *)leftArray rightArray: (NSArray *)rightArray {
int l = 0;
int r = 0;
NSMutableArray *_resultArray = [NSMutableArray array];
while (l < leftArray.count &&
r < rightArray.count)
{
if (leftArray[l] < rightArray[r])
{
[_resultArray addObject:leftArray[l]];
l++;
}
else
{
[_resultArray addObject:rightArray[r]];
r++;
}
}
[_resultArray addObject: (leftArray.lastObject > rightArray.lastObject)?leftArray.lastObject:rightArray.lastObject];
return _resultArray;
}
基數排序
下方是基數排序的運行效果，我們先輸入1000個元素，生成1000個隨機數，選擇基數排序。如下所示：
基數排序是一種非比較型整數排序算法，其原理是將整數按位數切割成不同的數字，然后按每個位數分別比較。由于整數也可以表達字符串（比如名字或日期）和特定格式的浮點數，所以基數排序也不是只能使用于整數。
說基數排序之前，我們簡單介紹桶排序：
算法思想：是將陣列分到有限數量的桶子里。每個桶子再個別排序（有可能再使用別的排序算法或是以遞回方式繼續使用桶排序進行排序）。桶排序是鴿巢排序的一種歸納結果。當要被排序的陣列內的數值是均勻分配的時候，桶排序使用線性時間（Θ（n））。但桶排序并不是 比較排序，他不受到 O(n log n) 下限的影響。簡單來說，就是把數據分組，放在一個個的桶中，然后對每個桶里面的在進行排序。
例如要對大小為[1..1000]范圍內的n個整數A[1..n]排序。
首先，可以把桶設為大小為10的范圍，具體而言，設集合B[1]存儲[1..10]的整數，集合B[2]存儲[10..20]的整數，……集合B[i]存儲[(i-1)10, i10]的整數，i=1,2,..100。總共有100個桶。
然后，對A[1..n]從頭到尾掃描一遍，把每個A[i]放入對應的桶B[j]中。 再對這100個桶中每個桶里的數字排序，這時可用冒泡，選擇，乃至快排，一般來說任何排序法都可以。
最后，依次輸出每個桶里面的數字，且每個桶中的數字從小到大輸出，這 樣就得到所有數字排好序的一個序列了。
假設有n個數字，有m個桶，如果數字是平均分布的，則每個桶里面平均有n/m個數字。如果對每個桶中的數字采用快速排序，那么整個算法的復雜度是O(n+mn/mlog(n/m))=O(n+nlogn–nlogm)。從上式看出，當m接近n的時候，桶排序復雜度接近O(n).
當然，以上復雜度的計算是基于輸入的n個數字是平均分布這個假設的。這個假設是很強的，實際應用中效果并沒有這么好。如果所有的數字都落在同一個桶中，那就退化成一般的排序了。
前面說的幾大排序算法，大部分時間復雜度都是O（n2），也有部分排序算法時間復雜度是O(nlogn)。而桶式排序卻能實現O（n）的時間復雜度。但桶排序的缺點是：
首先是空間復雜度比較高，需要的額外開銷大。排序有兩個數組的空間開銷，一個存放待排序數組，一個就是所謂的桶，比如待排序值是從0到m-1，那就需要m個桶，這個桶數組就要至少m個空間。
其次待排序的元素都要在一定的范圍內等等。
總結
各種排序的穩定性，時間復雜度、空間復雜度、穩定性總結如下圖：
關于時間復雜度：
平方階(O(n2))排序：各類簡單排序:直接插入、直接選擇和冒泡排序。
線性對數階(O(nlog2n))排序：快速排序、堆排序和歸并排序。
O(n1+§))排序：§是介于0和1之間的常數。
線性階(O(n))排序：基數排序，此外還有桶、箱排序。
關于穩定性：
穩定的排序算法：冒泡排序、插入排序、歸并排序和基數排序；
不是穩定的排序算法：選擇排序、快速排序、希爾排序、堆排序。
