C-025.数组的冒泡排序，升序排列

冒泡排序的思路

比如有一个数组 array[5] = {1，3，2，4，0}；

第一趟比较

第一次比较后得到：1，3，2，4，0（0下标和1下标比较）

第二次比较后得到：1，2，3，4，0（1下标和2下标比较）

第三次比较后得到：1，2，3，4，0（2下标和3下标比较）

第四次比较后得到：1，2，3，0，4（3下标和4下标比较） 这时候已经可以确定最后的数字为最大，所以下一趟比较只需要比较前4个数字

第二趟比较

第一次比较后得到：1，2，3，0，4（0下标和1下标比较）

第二次比较后得到：1，2，3，0，4（1下标和2下标比较）

第三次比较后得到：1，2，0，3，4（2下标和3下标比较）确定倒数第二大得数字，下一趟只需要比较前面3个数字

第三趟比较

第一次比较后得到：1，2，0，3，4（0下标和1下标比较）

第二次比较后得到：1，0，2，3，4（1下标和2下标比较）确定倒数第3位大得数字，下一趟只需要比较前面2个数字

第四趟比较

第一次比较后得到：0，1，2，3，4（0下标和1下标比较）排序完成

总结：

以n个元素的数组为例：元素个数为n ，外层循环为 = n - 1 次，每一次内层比较次数 = n - 第几次外层循环（有点晕）

void printArray(int array[],int length){  //打印数组的函数
    printf("[");
    for (int i = 0; i < length; i++) {
        printf("%d",array[i]);
        if (i != length - 1) {
            printf(",");
        }
    }
    printf("]\n");
}

void sortArray(int array[],int length){   //排序函数
    
    //  冒泡排序规则：两两比较大的下沉小的上浮
    //  外层循环控制一共比较几次
    for (int i = 0; i < length ; i++) {
        //内循环两两比较，小的上浮，大得下沉
        for (int j = 0; j < length - 1 - i; j++) {
            //如果前面大于后面，交换位置
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

int main(int argc, const char * argv[]) {
    int array[] = {1,3,7,4,2,5,10,25,24,31};
    int length = sizeof(array) / sizeof(int);
    printArray(array, length); //输出排序之前数组
    sortArray(array, length);  //排序
    printArray(array, length); //输出排序之后数组

    return 0;
}

同样是排序，OC中就比较方便，因为系统中已经有了排序的方法：

方法有3：1.通过选择器：@se'lector

                 2.通过比较器：block封装代码

                 3.通过属性描述器：NSSortDescriptor属性描述

这里只介绍第一种选择器，后面的在OC中介绍：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
       
        NSArray *array = @[@8,@6,@10,@2,@1];//创建一个数组对象，基本数据类型通过@包装
        NSLog(@"前：%@",array);//打印array数组
        array = [array sortedArrayUsingSelector:@selector(compare:)];//通过比较器对象方法排序，可以重写比较方法来进行想要的排序
        NSLog(@"后：%@",array);//打印排序后的数组
    
    }
    return 0;
}