OC 排序算法（冒泡，选择，快速）

1. 选择排序，时间复杂度O(n2)

///选择排序 时间复杂度 O(n^2) 从第一个元素开始，依次查找对比，找到最小的元素与第一个元素交换，再从第二个元素开始找后面元素的最小值与第二个元素交换，以此类推，直到整个数组有序。
- (void)selectionAscendingOrderSortWithArray:(NSMutableArray *)ascendingArr
{
    for (int i = 0; i < ascendingArr.count; i ++) {
        for (int j = i+1; j < ascendingArr.count; j ++) {
            if ([ascendingArr[i] intValue] > [ascendingArr[j] intValue]) {
                [ascendingArr exchangeObjectAtIndex:i withObjectAtIndex:j];
            }
        }
    }
    NSLog(@"选择升序排序后结果：%@", ascendingArr);
}

2. 冒泡排序

/// 冒泡排序 时间复杂度 O(n^2)
/// 这种算法会重复的比较数组中相邻的两个元素，如果一个元素比另一个元素大（小），那么就交换这两个元素的位置。重复这一比较直至最后一个元素。每一趟比较都能找出未排序元素中最大或者最小的那个数字。这就如同水泡从水底逐个飘到水面一样。冒泡排序是一种时间复杂度较高，效率较低的排序方法。

- (NSMutableArray *)bubbleSort:(NSMutableArray *)arr{
    for (int i = 0; i < arr.count ; i ++ ) {
        for (int j = 0; j < arr.count - i - 1; j ++) {
            if ([arr[j] intValue] < [arr[j+1] intValue]) {
                [arr exchangeObjectAtIndex:j withObjectAtIndex:j+1];
            }
        }
    }
    return arr;
}

3. 快速排序

/// 快速排序  时间复杂度：最差O(n^2)，平均O(nlogn)  空间复杂度：O(nlogn)
/// 随机选择一个基准点，将大于此数的值放在右边，小于此数的值放到左边。递归直到数组长度为0 或1时返回数组。
-(void)quickSequence:(NSMutableArray *)arr andleft:(int)left andright:(int)right
{
    if (left >= right) {//如果数组长度为0或1时返回
        return ;
    }
    int key = [arr[left] intValue];
    int i = left;
    int j = right;
    
    while (i<j){
        while (i<j&&[arr[j] intValue]>=key) {
            j--;
        }
        arr[i] = arr[j];
        
        while (i<j&&[arr[i] intValue]<=key) {
            i++;
        }
        arr[j] = arr[i];
    }
    arr[i] = [NSString stringWithFormat:@"%d",key];
    [self quickSequence:arr andleft:left andright:i-1];
    [self quickSequence:arr andleft:i+1 andright:right];
}