OC实现的各种简单常见的排序算法

//直接插入排序.每步将一个待排序的记录按其关键字的大小插到前面已经排序的序列中的适当位置，直到全部记录插入完毕为止。
-(void)initDirectChaSort:(NSMutableArray *)array{
    NSInteger j=0;
    for (NSInteger i=0; i<[array count]-1; i++) {
        if ([[array objectAtIndex:i] integerValue]>[[array objectAtIndex:i+1] integerValue]) {
            NSNumber *temp = [array objectAtIndex:i+1];
            for (j=i+1; j>0&&([[array objectAtIndex:j-1] integerValue]>[temp integerValue]); j--) {
                [array exchangeObjectAtIndex:j-1 withObjectAtIndex:j];
            }
        }
    }
    for (NSInteger i=0; icount; i++) {
        NSLog(@"直接插入排序排序后的顺序为:%@",[array objectAtIndex:i]);
    }
}

//简单选择排序 n^2
-(void)initSelectedSort:(NSArray *)arry{
    //选择数组中最小的数与待排序中的第一个数交换
    NSMutableArray *array = [arry mutableCopy];
    for (NSInteger i=0; icount; i++) {
        NSInteger j=0;
        while (jcount) {
            if ([[array objectAtIndex:i] integerValue]<[[array objectAtIndex:j] integerValue]) {
                [array exchangeObjectAtIndex:i withObjectAtIndex:j];
            }
            j++;
        }
    }
    for (NSInteger i=0; icount; i++) {
        NSLog(@"选择排序后的顺序为:%@",[array objectAtIndex:i]);
    }
}

//array是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度
//本函数功能是：根据数组array构建大根堆
-(void)HeapAdjust:(NSMutableArray *)array index:(NSInteger)i  nLength:(NSInteger)nLength{
    int nChild;
    for(;2*i+1
    {
        //子结点的位置=2*（父结点位置）+1
        nChild=2*i+1;
        //得到子结点中较大的结点
        if(nChild1&&[array[nChild+1] integerValue]>[array[nChild] integerValue])++nChild;
        //如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点
        if([array[i] integerValue]<[array[nChild] integerValue])
        {
            [array exchangeObjectAtIndex:i withObjectAtIndex:nChild];
        }
        else break; //否则退出循环
    }
}
-(void)HeapSort:(NSMutableArray *)array Count:(NSInteger)length{
    int i;
    //调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素
    //length/2-1是最后一个非叶节点，此处"/"为整除
    for(i=length/2-1;i>=0;--i)
        [self HeapAdjust:array index:i nLength:length];
    //从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
    for(i=length-1;i>0;--i)
    {
        //把第一个元素和当前的最后一个元素交换，
        [array exchangeObjectAtIndex:0 withObjectAtIndex:i];
        //不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值
        [self HeapAdjust:array index:0 nLength:i];
    }
}
//堆排序
-(void)initDuiSort:(NSMutableArray *)arry{
    [self HeapSort:arry Count:arry.count];
    for(NSInteger i=0;icount;i++)
    {
        NSLog(@"堆排序后的顺序为:%@",[arry objectAtIndex:i]);
    }
}

//冒泡排序  时间复杂度：n^2（n的平方）
-(void)initBubbleSort:(NSArray *)arry{
    //相邻的两个数做比较，如果后面的比前面的一个数小，交换位置
    NSMutableArray *array = [arry mutableCopy];
    for (NSInteger i=0; icount; i++) {
        for (NSInteger j=0;(j+1)count&&j<(array.count-i); j++) {
            if ([array[j] integerValue]>[array[j+1] integerValue]) {
                [array exchangeObjectAtIndex:j withObjectAtIndex:j+1];
            }
        }
    }
    for (NSInteger i=0; icount; i++) {
        NSLog(@"冒泡排序后的顺序为:%@",[array objectAtIndex:i]);
    }
}
//设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
//一趟快速排序的算法是：
//1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
//2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
//3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
//4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
//5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。快速排序时间复杂度下界为O(nlogn)，最坏情况为O(n^2)
-(void)quicksort:(NSMutableArray *)array Left:(NSInteger)left Right:(NSInteger)right{
    if (left>right) {
        return;
    }
    NSInteger i=left,j = right;
    NSInteger key = [array[left] integerValue];
    while (i
        while((iintegerValue] >= key)) {
            j--;
        }
        [array exchangeObjectAtIndex:i withObjectAtIndex:j];//找到第一个小于key的值A[j]，将A[j]和A[i]互换；

        while((iintegerValue]<=key)) {
            i++;
        }
        [array exchangeObjectAtIndex:j withObjectAtIndex:i];
    }
//    [array replaceObjectAtIndex:i withObject:array[i]];
    [self quicksort:array Left:left Right:i-1];
    [self quicksort:array Left:i+1 Right:right];
}
//快速排序
//一趟快速排序的算法是：
//1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
//2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
//3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
//4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
//5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
-(void)initQuicklySort:(NSArray *)arry{
    NSMutableArray *dataArray = [arry mutableCopy];
    [self quicksort:dataArray Left:0 Right:dataArray.count-1];
    for (NSInteger i=0; icount; i++) {
        NSLog(@"快速排序后的顺序为:%@",[dataArray objectAtIndex:i]);
    }
}
测试用例
    NSArray *array = @[@4,@20,@30,@1,@3,@8,@9];
    [self initBubbleSort:array];//冒泡排序
    [self initSelectedSort:array];//选择排序
    [self initQuicklySort:array];//快速排序
    [self initDirectChaSort:[array mutableCopy]];//直接插入排序

    [self initDuiSort:[array mutableCopy]];//堆排序