ios排序算法

1.冒泡排序 O(n2)

相邻的两个元素比较，如果第一个比第二个大，就交换，从第一个元素到倒数第二个

- (void)BubbleSort:(NSMutableArray *)array{
    
    for (int i = 0; i<array.count; i++) {
        
        for (int j = 0; j<array.count-1-i; j++) {
            
            if ([array[j+1] integerValue]<[array[j] integerValue]) {
                
                NSNumber *temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}

2.选择排序 O(n2)

从循环找到最小的元素，与循环的起始位置交换

- (void)SelectionSort:(NSMutableArray *)array{
    
    for (int i = 0; i<array.count; i++) {
        
        int min = i;
        for (int j=i; j<array.count; j++) {
            
            if ([array[j] integerValue]<[array[min] integerValue]) {
                min = j;
            }
        }
        NSNumber *temp = array[min];
        array[min] = array[i];
        array[i] = temp;
    }
}

3.插入排序 O(n2)

1.将后一个元素N(i+1)与之前的元素P(i)依次比较

2.如果N<P,将P后移，然后比较P的上一个元素P(i-1)，

3.重复2

4.将N插入到P(i-x)的位置，也就是移完元素以后空出的位置

- (void)InsertSort:(NSMutableArray *)array{
    
    for (int i = 0; i<array.count-1; i++) {
    
        NSNumber *currnt = array[i+1];
        int pre = i;
        while (pre>=0 && [currnt integerValue]< [array[pre] integerValue]) {
            array[pre+1] = array[pre];
            pre--;
        }
        array[pre+1] = currnt;
    }
}

4.希尔排序 O(n logn)

其实是一个升级版的插入排序，区别是，插入排序是第二个元素开始(间隔为1)与前面的元素依次比较，循环作用是元素+1；而希尔排序是第length/2个元素开始，与前面的元素（间隔为length/2）比较，循环的作用是元素+1，并且length=length/2。

- (void)xier:(NSMutableArray *)array{
    int len = (int)array.count;
    int gap = (int)len/2;
    while (gap>0) {
        
        for (int i = gap; i<len; i++) {
            int tmp = [array[i] intValue];;
            int pre = i-gap;
            
            while (pre>=0 && tmp < [array[pre] intValue]) {
                array[pre+gap] = array[pre];
                pre -= gap;
            }
            array[pre +gap] = @(tmp);
            
        }
        gap = gap/2;
    }
    
}

5.快速排序 O(n logn)

可以理解为两头凑的插入排序。

1.记录一个元素i为基准数，最后一个元素j开始与基准数比较，遇到j比基准数小时，停止遍历，把i的值替换为j的值。

2.从i开始与基准数比较，遇到i比基准数大时，停止遍历，把j的值替换为i的值。此时i的位置值是空的，放入基准数。

3.递归把数组以i-1和i+1为分界线，前后分为2段，重复1、2。直到i(位置)>=j(位置)

- (void)quickSortArray:(NSMutableArray *)array withLeftIndex:(NSInteger)leftIndex andRightIndex:(NSInteger)rightIndex
{
    if (leftIndex >= rightIndex) {
        return;
    }
    
    NSInteger i = leftIndex;
    NSInteger j = rightIndex;
    NSInteger value = [array[leftIndex] integerValue];
    
    while (i<j) {
        
        while (i<j && [array[j] integerValue] >=value) {
            j--;
        }
        array[i] = array[j];
        
        while (i<j && [array[i] integerValue] <= value) {
            i ++;
        }
        array[j] = array[i];
    }
    array[i] = @(value);
    
    [self quickSortArray:array withLeftIndex:leftIndex andRightIndex:i-1];
    [self quickSortArray:array withLeftIndex:i+1 andRightIndex:rightIndex];
    
}

6.归并排序  O(n logn)

可以理解为每个元素都是一个已排好的序列，两两排序后合并为一个序列，直到数组里面所有元素都合并为一个序列。

- (void)megerSortAscendingOrderSort:(NSMutableArray *)ascendingArr
{
    NSMutableArray *tmpArr = [NSMutableArray arrayWithCapacity:1];
    for (NSNumber *num in ascendingArr) {
        NSMutableArray *oneArr = [NSMutableArray arrayWithObject:num];
        [tmpArr addObject:oneArr];
    }
    
    while (tmpArr.count>1) {
        
        NSInteger start = 0;
        
        while (start < tmpArr.count-1) {
            
            tmpArr[start] = [self mergeArrayFirstList:tmpArr[start] secondList:tmpArr[start +1]];
            [tmpArr removeObjectAtIndex:start+1];
            start ++;
        }
    }
    ascendingArr = tmpArr[0];
    

}

- (NSArray *)mergeArrayFirstList:(NSArray *)array1 secondList:(NSArray *)array2 {
    
    NSMutableArray *arr = [NSMutableArray arrayWithCapacity:0];
    NSInteger leftIndex = 0,rightIndex = 0;
    
    while (leftIndex<array1.count && rightIndex<array2.count) {
        
        if ([array1[leftIndex] integerValue] < [array2[rightIndex] integerValue]) {
            [arr addObject:array1[leftIndex]];
            leftIndex ++;
        }else{
            [arr addObject:array2[rightIndex]];
            rightIndex ++;
        }
        
    
        
        
    }
    
    while (leftIndex<array1.count) {
        [arr addObject:array1[leftIndex]];
        leftIndex ++;
    }
    while (rightIndex<array2.count) {
        [arr addObject:array2[rightIndex]];
        rightIndex ++;
    }
    return arr;
    
}