C和OC的冒泡排序实现

所谓冒泡排序法，就是对一组数字进行从大到小或者从小到大排序的一种算法。具体方法是，相邻数值两两交换。从第一个数值开始，如果相邻两个数的排列顺序与我们的期望不同，则将两个数的位置进行交换（对调）；如果其与我们的期望一致，则不用交换。重复这样的过程，一直到最后没有数值需要交换，则排序完成。一般地，如果有N个数需要排序，则需要进行（N-1）趟起泡。

//冒泡排序的每一趟排序都把最大的放在最右边
//比如：
//

5,9,7,6,1,8,13,4

//5和9不交换：5 9 7 6 1 8 13 4

//9和7交换：  5 7 9 6 1 8 13 4
//6和9交换：  5 7 6 9 1 8 13 4
//1和9交换：  5 7 6 1 9 8 13 4
//8和9交换：  5 7 6 1 8 9 13 4

//13和9不交换：5 7 6 1 8 9 13 4         

//13和4交换：  5 7 6 1 8 9 4 13

 //到此第一趟排序结束最大值13在末尾，接下来的每一趟排序都是这样。
//即第一趟比较n-1次，第二趟比较n-2次，共比较n-1趟

先介绍一下C语言冒泡排序的最佳方法：

void Bubble_Sort(int *num, int n)
{
    int i, j,times = 0;
    for (i = 0; i < n - 1; i++) {//比较n-1趟
        for (j = 0; i + j < n - 1; j++) {//每趟比较 (n-1)-i次
            if (num[j] > num[j+1]) {
                int temp = num[j+1];
                num[j+1] = num[j];
                num[j] = temp;
            }
            times ++;
        }
    }
    Print(num,n);
    printf("循环次数%d\n",times);
    return;
}

num 为传入的int 型数组，n为传入的数组个数

   int main() 
{
    int num[8] = {5,9,7,6,1,8,13,4};
    int length = sizeof(num)/sizeof(num[0]);
    printf("原数组为\n");
    Print(num, length);
    printf("数组长度为:%d\n",length);
    //1.冒泡排序
    Bubble_Sort(num, length);
    
    return 0;
}
//打印数组
void Print(int *num, int n)
{
    int i;
    for (i = 0; i < n; i++) {
        printf("%d ",num[i]);
    }
    puts("\n");
    return;
}

//运行结果

原数组为
5 9 7 6 1 8 13 4 

数组长度为:8
1 4 5 6 7 8 9 13 

循环次数28

对冒泡算法的时间复杂度和空间复杂度进行分析，很明显，算法在运行时，需要的辅助空间很小，只需要两个用来遍历数组的常数i、j，然后需要一个用于交换的临时存储空间tmp，再加一个判断是否需要继续执行算法的变量flag，所以空间复杂度是常量。

再来看看时间复杂度，在最后的情况下，也就是数组已经是升序的情况下，只需要遍历一次，此时的时间复杂度为0(n)；在最坏情况下，整个数组是降序排列的，这个时候每一次都需要进行交换，时间复杂度为n(n-1)/2，空间复杂度为0（n^2）。

Object-C就直接贴上代码

//时间复杂度应为O(n^2)
-(NSArray *)bubbleSortWithArray:(NSArray *)array
{
    NSMutableArray * mArray = [[NSMutableArray alloc] initWithArray:array];
    NSUInteger arrayLength = mArray.count;
    int i,j,times = 0;
    for (i = 0; i < arrayLength - 1; i++) {
        for (j = 0; j < arrayLength - 1 - i; j++) {
            if (mArray[j] > mArray[j+1]) {
                [mArray exchangeObjectAtIndex:j withObjectAtIndex:j+1];
            }
            times ++;
        }
    }
    NSLog(@"循环次数:%d",times);
    return mArray;
}

    NSArray * array = @[@8,@1,@14,@23,@5,@9,@7,@4];
    NSArray * bubbleSortAttay = [self bubbleSortWithArray:array];
    NSLog(@"原数组:%@\n排序后的数组:%@",array,bubbleSortAttay);

运行结果

2016-07-30 11:52:11.073 iOS冒泡排序算法的实现[7356:590702] 循环次数:28
2016-07-30 11:52:11.074 iOS冒泡排序算法的实现[7356:590702] 原数组:(
    8,
    1,
    14,
    23,
    5,
    9,
    7,
    4
)
排序后的数组:(
    1,
    4,
    5,
    7,
    8,
    9,
    14,
    23
)