iOS 開發中常用的排序（冒泡、選擇、快速、插入、希爾、歸並、基數）算法

　　1、冒泡排序：

　　冒泡算法是一種基礎的排序算法，這種算法會重復的比較數組中相鄰的兩個元素。如果一個元素比另一個元素大（小），那么就交換這兩個元素的位置。重復這一比較直至最后一個元素。這一比較會重復n-1趟，每一趟比較n-j次，j是已經排序好的元素個數。每一趟比較都能找出未排序元素中最大或者最小的那個數字。這就如同水泡從水底逐個飄到水面一樣。冒泡排序是一種時間復雜度較高，效率較低的排序方法。其空間復雜度是O(n)。

　　1, 最差時間復雜度 O(n^2)
　　2, 平均時間復雜度 O(n^2)

　　實現思路
　　1，每一趟比較都比較數組中兩個相鄰元素的大小
　　2，如果i元素小於i-1元素，就調換兩個元素的位置
　　3，重復n-1趟的比較

　　C 語言寫法：

//*********** 冒泡降序排序 **********//
int array[10] = {24, 17, 85, 13, 9, 54, 76, 45, 5, 63};
int num = sizeof(array)/sizeof(int);
for(int i = 0; i < num-1; i++) {
    for(int j = 0; j < num - 1 - i; j++) {
        if(array[j] < array[j+1]) {
            int tmp = array[j];
            array[j] = array[j+1];
            array[j+1] = tmp;
        }
    }
}
for(int i = 0; i < num; i++) {
    printf("%d\t", array[i]);
}

　　Objective-C 寫法：

#pragma mark - 冒泡降序排序
- (void)bubbleDescendingOrderSortWithArray:(NSMutableArray *)descendingArr
{
    for (int i = 0; i < descendingArr.count; i++) {
        for (int j = 0; j < descendingArr.count - 1 - i; j++) {
            if ([descendingArr[j] intValue] < [descendingArr[j + 1] intValue]) {
                int tmp = [descendingArr[j] intValue];
                descendingArr[j] = descendingArr[j + 1];
                descendingArr[j + 1] = [NSNumber numberWithInt:tmp];
            }
        }
    }
    NSLog(@"冒泡降序排序后結果：%@", descendingArr);
}

#pragma mark - 冒泡升序排序
- (void)bubbleAscendingOrderSortWithArray:(NSMutableArray *)ascendingArr
{
    for (int i = 0; i < ascendingArr.count; i++) {
        for (int j = 0; j < ascendingArr.count - 1 - i;j++) {
            if ([ascendingArr[j+1]intValue] < [ascendingArr[j] intValue]) {
                int temp = [ascendingArr[j] intValue];
                ascendingArr[j] = ascendingArr[j + 1];
                ascendingArr[j + 1] = [NSNumber numberWithInt:temp];
            }
        }
    }
    NSLog(@"冒泡升序排序后結果：%@", ascendingArr);
}

　　2、選擇排序：

　　實現思路：

　　  1. 設數組內存放了n個待排數字，數組下標從1開始，到n結束。

　　 2. i=1

　　 3. 從數組的第i個元素開始到第n個元素，尋找最小的元素。（具體過程為:先設arr[i]為最小，逐一比較，若遇到比之小的則交換）

　　 4. 將上一步找到的最小元素和第i位元素交換。

　　 5. 如果i=n－1算法結束，否則回到第3步

 

  　復雜度：

　　 平均時間復雜度：O(n^2)

　　平均空間復雜度：O(1)

 

#pragma mark - 選擇升序排序
- (void)selectionAscendingOrderSortWithArray:(NSMutableArray *)ascendingArr
{
    for (int i = 0; i < ascendingArr.count; i ++) {
        for (int j = i + 1; j < ascendingArr.count; j ++) {
            if ([ascendingArr[i] integerValue] > [ascendingArr[j] integerValue]) {
                int temp = [ascendingArr[i] intValue];
                ascendingArr[i] = ascendingArr[j];
                ascendingArr[j] = [NSNumber numberWithInt:temp];
            }
        }
    }
    NSLog(@"選擇升序排序后結果：%@", ascendingArr);
}

#pragma mark - 選擇降序排序
- (void)selectionDescendingOrderSortWithArray:(NSMutableArray *)descendingArr
{
    for (int i = 0; i < descendingArr.count; i ++) {
        for (int j = i + 1; j < descendingArr.count; j ++) {
            if ([descendingArr[i] integerValue] < [descendingArr[j] integerValue]) {
                int temp = [descendingArr[i] intValue];
                descendingArr[i] = descendingArr[j];
                descendingArr[j] = [NSNumber numberWithInt:temp];
            }
        }
    }
    NSLog(@"選擇降序排序后結果：%@", descendingArr);
}

 

　　3、快速排序：

　　實現思路：

　　1. 從數列中挑出一個元素，稱為 "基准"（pivot），

　　2. 重新排序數列，所有元素比基准值小的擺放在基准前面，所有元素比基准值大的擺在基准的后面（相同的數可以到任一邊）。在這個分割之后，該基准是它的最后位置。這個稱為分割（partition）操作。

　　3. 遞歸地（recursive）把小於基准值元素的子數列和大於基准值元素的子數列排序。 

　　快速排序是基於分治模式處理的，對一個典型子數組A[p...r]排序的分治過程為三個步驟：
　　　　1.分解：
　　　　A[p..r]被划分為倆個（可能空）的子數組A[p ..q-1]和A[q+1 ..r]，使得
　　　　A[p ..q-1] <= A[q] <= A[q+1 ..r]
　　　　2.解決：通過遞歸調用快速排序，對子數組A[p ..q-1]和A[q+1 ..r]排序。
　　　　3.合並。

　　遞回的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞回下去，但是這個算法總會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。

　　復雜度：

　　平均時間復雜度：O(n^2)

　　平均空間復雜度：O(nlogn)       O(nlogn)~O(n^2)

　　偽代碼：

QUICK_SORT(A,p,r)
    if(p<r)
        then q <—— PARTITION(A,p,r)
             QUICK_SORT(A,p,q-1)
             QUICK_SORT(A,q+1,r)
 
//核心函數，對數組A[p,r]進行就地重排，將小於A[r]的數移到數組前半部分，將大於A[r]的數移到數組后半部分。
PARTITION(A,p,r)
    pivot <—— A[r]
    i <—— p-1
    for j <—— p to r-1
        do if A[j] < pivot
            i <—— i+1
            exchange A[i]<——>A[j]
    exchange A[i+1]<——>A[r]
return i+1

 

　　C 語言實現：

#include <stdio.h>
int partition(int *arr, int low, int high)
{
    int pivot = arr[high];
    int i = low - 1;
    int j, tmp;
    for(j = low; j< high; ++j)
        if(arr[j] < pivot) {
            tmp = arr[++i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    tmp = arr[i+1];
    arr[i+1] = arr[high];
    arr[high] = tmp;
    return i+1;
}
void quick_sort(int *arr, int low, int high)
{
    if(low < high){
        int mid = partition(arr, low, high);
        quick_sort(arr, low, mid-1);
        quick_sort(arr, mid+1, high);
    }
}
//test
int main()
{
    int arr[10]={1,4,6,2,5,8,7,6,9,12};
    quick_sort(arr,0,9);
    int i;
    for(i=0;i<10;++i)
        printf("%d ",arr[i]);
}

 

　　Objective-C 實現：

#pragma mark - 快速升序排序
- (void)quickAscendingOrderSort:(NSMutableArray *)arr leftIndex:(NSInteger)left rightIndex:(NSInteger)right
{
    if (left < right) {
        NSInteger temp = [self getMiddleIndex:arr leftIndex:left rightIndex:right];
        [self quickAscendingOrderSort:arr leftIndex:left rightIndex:temp - 1];
        [self quickAscendingOrderSort:arr leftIndex:temp + 1 rightIndex:right];
    }
    NSLog(@"快速升序排序結果：%@", arr);
}

- (NSInteger)getMiddleIndex:(NSMutableArray *)arr leftIndex:(NSInteger)left rightIndex:(NSInteger)right
{
    NSInteger tempValue = [arr[left] integerValue];
    while (left < right) {
        while (left < right && tempValue <= [arr[right] integerValue]) {
            right --;
        }
        if (left < right) {
            arr[left] = arr[right];
        }
        while (left < right && [arr[left] integerValue] <= tempValue) {
            left ++;
        }
        if (left < right) {
            arr[right] = arr[left];
        }
    }
    arr[left] = [NSNumber numberWithInteger:tempValue];
    return left;
}

 

　　4、插入排序：　　

　　實現思路：

　　1. 從第一個元素開始，認為該元素已經是排好序的。

　　2. 取下一個元素，在已經排好序的元素序列中從后向前掃描。

　　3. 如果已經排好序的序列中元素大於新元素，則將該元素往右移動一個位置。

　　4. 重復步驟3，直到已排好序的元素小於或等於新元素。

　　5. 在當前位置插入新元素。

　　6. 重復步驟2。

　　復雜度：

　　平均時間復雜度：O(n^2)

　　平均空間復雜度：O(1)

　　

#pragma mark - 插入升序排序
- (void)insertionAscendingOrderSort:(NSMutableArray *)ascendingArr
{
    for (NSInteger i = 1; i < ascendingArr.count; i ++) {
        NSInteger temp = [ascendingArr[i] integerValue];
        for (NSInteger j = i - 1; j >= 0 && temp < [ascendingArr[j] integerValue]; j --) {
            ascendingArr[j + 1] = ascendingArr[j];
            ascendingArr[j] = [NSNumber numberWithInteger:temp];
        }
    }
    NSLog(@"插入升序排序結果：%@",ascendingArr);
}

 

　　五、堆排序： 

　　

#pragma mark - 堆排序
- (void)heapsortAsendingOrderSort:(NSMutableArray *)ascendingArr
{
    NSInteger endIndex = ascendingArr.count - 1;
    ascendingArr = [self heapCreate:ascendingArr];
    while (endIndex >= 0) {
//        NSLog(@"將list[0]:\%@與list[\(endIndex)]:\%@交換", ascendingArr[0], ascendingArr[endIndex]);
        NSNumber *temp = ascendingArr[0];
        ascendingArr[0] = ascendingArr[endIndex];
        ascendingArr[endIndex] = temp;
        endIndex -= 1;
        ascendingArr = [self heapAdjast:ascendingArr withStartIndex:0 withEndIndex:endIndex + 1];
    }
    NSLog(@"堆排序結果：%@", ascendingArr);
}

- (NSMutableArray *)heapCreate:(NSMutableArray *)array
{
    NSInteger i = array.count;
    while (i > 0) {
        array = [self heapAdjast:array withStartIndex:i - 1 withEndIndex:array.count];
        i -= 1;
    }
    return array;
}

- (NSMutableArray *)heapAdjast:(NSMutableArray *)items withStartIndex:(NSInteger)startIndex withEndIndex:(NSInteger)endIndex
{
    NSNumber *temp = items[startIndex];
    NSInteger fatherIndex = startIndex + 1;
    NSInteger maxChildIndex = 2 * fatherIndex;
    while (maxChildIndex <= endIndex) {
        if (maxChildIndex < endIndex && [items[maxChildIndex - 1] floatValue] < [items[maxChildIndex] floatValue]) {
            maxChildIndex++;
        }
        if ([temp floatValue] < [items[maxChildIndex - 1] floatValue]) {
            items[fatherIndex - 1] = items[maxChildIndex - 1];
        } else {
            break;
        }
        fatherIndex = maxChildIndex;
        maxChildIndex = fatherIndex * 2;
    }
    items[fatherIndex - 1] = temp;
    return items;
}

 

　　六、歸並排序：

　　把序列分成元素盡可能相等的兩半。

　　把兩半元素分別進行排序。

　　把兩個有序表合並成一個。

　　

#pragma mark - 歸並升序排序
- (void)megerSortAscendingOrderSort:(NSMutableArray *)ascendingArr
{
    NSMutableArray *tempArray = [NSMutableArray arrayWithCapacity:1];
    for (NSNumber *num in ascendingArr) {
        NSMutableArray *subArray = [NSMutableArray array];
        [subArray addObject:num];
        [tempArray addObject:subArray];
    }
    while (tempArray.count != 1) {
        NSInteger i = 0;
        while (i < tempArray.count - 1) {
            tempArray[i] = [self mergeArrayFirstList:tempArray[i] secondList:tempArray[i + 1]];
            [tempArray removeObjectAtIndex:i + 1];
            
            i++;
        }
    }
    NSLog(@"歸並升序排序結果：%@", ascendingArr);
}

- (NSArray *)mergeArrayFirstList:(NSArray *)array1 secondList:(NSArray *)array2 {
    NSMutableArray *resultArray = [NSMutableArray array];
    NSInteger firstIndex = 0, secondIndex = 0;
    while (firstIndex < array1.count && secondIndex < array2.count) {
        if ([array1[firstIndex] floatValue] < [array2[secondIndex] floatValue]) {
            [resultArray addObject:array1[firstIndex]];
            firstIndex++;
        } else {
            [resultArray addObject:array2[secondIndex]];
            secondIndex++;
        }
    }
    while (firstIndex < array1.count) {
        [resultArray addObject:array1[firstIndex]];
        firstIndex++;
    }
    while (secondIndex < array2.count) {
        [resultArray addObject:array2[secondIndex]];
        secondIndex++;
    }
    return resultArray.copy;
}

　　七、希爾排序：

　　

#pragma mark - 希爾排序
- (void)shellAscendingOrderSort:(NSMutableArray *)ascendingArr
{
    NSMutableArray *buckt = [self createBucket];
    NSNumber *maxnumber = [self listMaxItem:ascendingArr];
    NSInteger maxLength = numberLength(maxnumber);
    for (int digit = 1; digit <= maxLength; digit++) {
        // 入桶
        for (NSNumber *item in ascendingArr) {
            NSInteger baseNumber = [self fetchBaseNumber:item digit:digit];
            NSMutableArray *mutArray = buckt[baseNumber];
            [mutArray addObject:item];
        }
        NSInteger index = 0;
        for (int i = 0; i < buckt.count; i++) {
            NSMutableArray *array = buckt[i];
            while (array.count != 0) {
                NSNumber *number = [array objectAtIndex:0];
                ascendingArr[index] = number;
                [array removeObjectAtIndex:0];
                index++;
            }
        }
    }
    NSLog(@"希爾升序排序結果：%@", ascendingArr);
}

- (NSMutableArray *)createBucket {
    NSMutableArray *bucket = [NSMutableArray array];
    for (int index = 0; index < 10; index++) {
        NSMutableArray *array = [NSMutableArray array];
        [bucket addObject:array];
    }
    return bucket;
}

- (NSNumber *)listMaxItem:(NSArray *)list {
    NSNumber *maxNumber = list[0];
    for (NSNumber *number in list) {
        if ([maxNumber integerValue] < [number integerValue]) {
            maxNumber = number;
        }
    }
    return maxNumber;
}

NSInteger numberLength(NSNumber *number) {
    NSString *string = [NSString stringWithFormat:@"%ld", (long)[number integerValue]];
    return string.length;
}

- (NSInteger)fetchBaseNumber:(NSNumber *)number digit:(NSInteger)digit {
    if (digit > 0 && digit <= numberLength(number)) {
        NSMutableArray *numbersArray = [NSMutableArray array];
        NSString *string = [NSString stringWithFormat:@"%ld", [number integerValue]];
        for (int index = 0; index < numberLength(number); index++) {
            [numbersArray addObject:[string substringWithRange:NSMakeRange(index, 1)]];
        }
        NSString *str = numbersArray[numbersArray.count - digit];
        return [str integerValue];
    }
    return 0;
}

 

　　8、基數排序：

　　

#pragma mark - 基數排序
- (void)radixAscendingOrderSort:(NSMutableArray *)ascendingArr
{
    NSMutableArray *buckt = [self createBucket];
    NSNumber *maxnumber = [self listMaxItem:ascendingArr];
    NSInteger maxLength = numberLength(maxnumber);
    for (int digit = 1; digit <= maxLength; digit++) {
        // 入桶
        for (NSNumber *item in ascendingArr) {
            NSInteger baseNumber = [self fetchBaseNumber:item digit:digit];
            NSMutableArray *mutArray = buckt[baseNumber];
            [mutArray addObject:item];
        }
        NSInteger index = 0;
        for (int i = 0; i < buckt.count; i++) {
            NSMutableArray *array = buckt[i];
            while (array.count != 0) {
                NSNumber *number = [array objectAtIndex:0];
                ascendingArr[index] = number;
                [array removeObjectAtIndex:0];
                index++;
            }
        }
    }
    NSLog(@"基數升序排序結果：%@", ascendingArr);
}