关于排序（冒泡&快速&插入）以及递归的部分应用

###冒泡

- (void)foolSortArray:(NSMutableArray *)arr {
    for (int i = 0; i < arr.count-1; i++) {
        for (int j = 0; j < arr.count-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                id tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
}

###选择排序
其实和冒泡差不多?

- (void)selectSortArray:(NSMutableArray *)arr {
    for (int i = 0; i < arr.count-1; i++) {
        for (int j = i+1; j < arr.count; j++) {
            if (arr[i] > arr[j]) {
                id tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

###插入排序

- (void)insertSortArray:(NSMutableArray *)arr {
    for (int i = 1; i < [arr count]; i++) {
        int j = i;
        NSInteger temp = [arr[i] integerValue];
        while (j > 0 && temp < [arr[j - 1] integerValue]) {
            [arr replaceObjectAtIndex:j withObject:arr[(j - 1)]];
            j--;
        }
        [arr replaceObjectAtIndex:j withObject:@(temp)];
    }
}

###快速排序 递归版

- (void)quickSortArray:(NSMutableArray *)arr withLeftIndex:(NSInteger)leftIndex andRightIndex:(NSInteger)rightIndex {
    if (leftIndex >= rightIndex) return ;
    
    NSInteger i = leftIndex;
    NSInteger j = rightIndex;
    NSInteger key = [arr[i] integerValue]; // 记录比较基准数
    
    while (i < j) {
        // 首先从右边j开始查找比基准数小的值 
        while (i < j && [arr[j] integerValue] >= key) { // 如果比基准数大，继续查找
            j--;
        }
        // 如果比基准数小，则将查找到的小值调换到i的位置
        arr[i] = arr[j];
        
        // 当在右边查找到一个比基准数小的值时，就从i开始往后找比基准数大的值 
        while (i < j && [arr[i] integerValue] <= key) { // 如果比基准数小，继续查找
            i++;
        }
        // 如果比基准数大，则将查找到的大值调换到j的位置
        arr[j] = arr[i];
    }
    
    // 将基准数放到正确位置
    arr[i] = @(key);
    
    // 排序基准数左边的
    [self quickSortArray:arr withLeftIndex:leftIndex andRightIndex:i - 1];
    // 排序基准数右边的
    [self quickSortArray:arr withLeftIndex:i + 1 andRightIndex:rightIndex];
}

###二分查找
只适用于已经排好序的

- (NSInteger)dichotomySearch:(NSArray *)arr target:(id)key {
    NSInteger left = 0;
    NSInteger right = [arr count] - 1;
    NSInteger middle = [arr count] / 2;
    
    while (right >= left) {
        middle = (right + left) / 2;
        
        if (array[middle] == key) {
            return middle;
        }
        
        if (arr[middle] > key) {
            right = middle - 1;
        }else if (arr[middle] < key) {
            left = middle + 1;
        }
    }
    return -1;
}

###斐波那契数列问题

- (NSInteger)recursion0:(NSInteger) n {
    if (n <= 1) return n;
    return [self recursion0:n-1] + [self recursion0:n-2];
}

###阶乘

- (NSInteger)recursion1: (NSInteger)n {
    if (n == 0) return 1;
    return n*[self recursion1:(n-1)];//递归公式
}

什么希尔排序、堆排序、归并排序的,容我再学学???原文在此