幾個基本算法

概覽

　　1，冒泡排序；

　　2，選擇排序；

　　3，快速排序；

　　4，歸並排序；

　　5，插入排序；

冒泡排序

　　比較兩個元素、交換它們的位置
　　算法原理：冒泡排序算法的運作如下：（從后往前）比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該會是最大的數。 針對所有的元素重復以上的步驟，除了最后一個。 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

- (void)bubbleSort {
    int a[] = {2,5,3,6,1,8};
    int tmp;
    int num = sizeof(a)/sizeof(int);
    for (int i = 0; i < num - 1; i++) { //外層循環控制排序趟數
        for (int j = 0; j < num - 1 - i; j++) {//內層循環控制每一趟排序多少次
            if (a[j] > a[j+1]) {
                tmp = a[j];
                a[j] = a[j+1];
                a[j+1] = tmp;
            }
        }
    }
    
    //查看排序結果
    for (int i = 0; i < num; i++) {
        NSLog(@"%d",a[i]);
    }
} 

選擇排序

　　每一趟從待排序的數據元素中選出最小（或最大）的一個元素，順序放在已排好序的數列的最后，直到全部待排序的數據元素排完
　　算法原理：對比數組中前一個元素跟后一個元素的大小，如果后面的元素比前面的元素小則用一個變量k來記住他的位置，接着第二次比較，前面“后一個元素”現變成了“前一個元素”，繼續跟他的“后一個元素”進行比較如果后面的元素比他要小則用變量k記住它在數組中的位置(下標)，等到循環結束的時候，我們應該找到了最小的那個數的下標了，然后進行判斷，如果這個元素的下標不是第一個元素的下標，就讓第一個元素跟他交換一下值，這樣就找到整個數組中最小的數了。然后找到數組中第二小的數，讓他跟數組中第二個元素交換一下值，以此類推。

- (void)selectSort {
    int a[] = {2,5,3,6,1,8};
    int tmp;
    int num = sizeof(a)/sizeof(int);
    for (int i = 0; i < num - 1; i++) {
        for (int j = i + 1; j < num; j++) {
            if (a[i] > a[j]) {
                tmp = a[i];
                a[i] = a[j];
                a[j] = tmp;
            }
        }
    }
    
    //查看排序結果
    for (int i = 0; i < num; i++) {
        NSLog(@"%d",a[i]);
    }
}

快速排序

通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列

- (void)quickSort:(NSMutableArray *)sortArr leftIndex:(NSInteger)left rightIndex:(NSInteger)right  {
    if (left >= right) {
        return;
    }
    
    NSInteger i = left;
    NSInteger j = right;
    
    NSInteger key = [sortArr[i] integerValue];
    while (i < j) {
        while (i < j && [sortArr[j] integerValue] >= key) {
            j--;
        }
        sortArr[i] = sortArr[j];
        
        while (i < j && [sortArr[i] integerValue] <= key ) {
            i++;
        }
        sortArr[j] = sortArr[i];
    }
    sortArr[j] = @(key);
    
    [self quickSort:sortArr leftIndex:left rightIndex:j - 1];
    [self quickSort:sortArr leftIndex:i + 1 rightIndex:right];
}

歸並排序

　　歸並排序是利用歸並的思想實現的排序方法，該算法采用經典的分治策略（分治法將問題分(divide)成一些小的問題然后遞歸求解，而治(conquer)的階段則將分的階段得到的各答案"修補"在一起，即分而治之)。

- (void)megerSortAscendingOrderSort:(NSMutableArray *)ascendingArr
{
    //tempArray數組里存放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(@"歸並升序排序結果：%@", tempArray[0]);
}

- (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;
}

 

插入排序

　　插入排序的基本操作就是將一個數據插入到已經排好序的有序數據中，從而得到一個新的、個數加一的有序數據
　　算法原理：每次處理就是將無序數列的第一個元素與有序數列的元素從后往前逐個進行比較，找出插入位置，將該元素插入到有序數列的合適位置中。

+ (void)inserSort:(NSMutableArray *)array{
    //插入排序的原理：始終定義第一個元素為有序的，將元素逐個插入到有序排列之中，其特點是要不斷的
    
    //移動數據，空出一個適當的位置，把待插入的元素放到里面去。
    for (int i = 0; i < array.count; i++) {
        
        NSNumber *temp = array[i];
        //temp 為待排元素 i為其位置 j為已排元素最后一個元素的位置（即取下一個元素，在已經排好序的元素序列中從后向前掃描）
        
        int j = i-1;

        //當j < 0 時， i 為第一個元素 該元素認為已經是排好序的 所以不進入while循環
        //  [array[j] compare:temp] == NSOrderedDescending與[array[j] intValue] > [temp intValue] 作用相同
        while (j >= 0 && [array[j] compare:temp] == NSOrderedDescending) {
            //如果已經排好序的序列中元素大於新元素，則將該元素往右移動一個位置
            [array replaceObjectAtIndex:j+1 withObject:array[j]];
            j--;
        }
        //跳出while循環時，j的元素小於或等於i的元素(待排元素)。插入新元素 i= j+1
        [array replaceObjectAtIndex:j+1 withObject:temp];
        NSLog(@"插入排序排序中:%@",array);
    }
}