排序算法系列——冒泡排序

对数组array[n]，其数组长度为n，元素索引0～n-1,对其进行升序排序，针对n<=10时，可选择冒泡排序

冒泡排序要点：

1.冒泡排序有两层循环，外层循环用来计算有多少个数i不再需要比较，内存循环负责从index0~index(n-i-1)将相邻元素进行比较和交换，简单来说，第一轮排序时，内层比较完后使数组的最大的元素被交换至数组的末尾，第二轮比较时，由于第一轮排序中内存比较将数组最大值放到了数组的末尾（升序的正确位置），因此第二轮循环时内层比较只需要比较数组末尾元素之前的元素，第二轮排序后，会将数组的第二大元素排在数组的倒数第二的位置，。。。如此往复，最后一轮排序时，将只有两个元素进行比较；

有点啰嗦....，可以参考这个文章的图片介绍https://www.cnblogs.com/bigdata-stone/p/10464243.html

2.其中外层排序的轮数 i 为[0,length-1)区间，即外层循环比较length-1次,比较简单的理解就是如果数组array={2， 1}，那么i从0开始，当i<2-1时，进行第一轮排序，很显然这只需要进行一轮排序即可，；

3.内层循环在数组索引 j =0 到 j =length-i-1（左闭右开）范围内，即每一轮排序比较 length-i 次，对元素进行array[j]>array[j+1] ?的比较，因此需要比较lebgth-i-1次比较或者交换，以确保数组中任意array[j+1]>array[j]，接着上面的array={2， 1}的例子，外层进行第一轮排序，i=0，这里比较次数就是2-0-1=1次。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    int array[10];
    time_t t;
    // 初始化随机数发生器
    srand((unsigned) time(&t));

    // 使用rand产生随机数初始array[10]
    for (int i = 0; i < 10; i++) {
        array[i] = (int)rand();
    }

    printf("未排序的数组：");
    for (int i = 0; i < 10; i++) {
        printf("%d,", array[i]);
    }
    printf("\n");

    bubbleSort(array);
    
    printf("排序后的数组：");
    for (int i = 0; i < 10; i++) {
        printf("%d,", array[i]);
    }
    printf("\n");

    return 0;
    
}
// 冒泡排序函数bubbleSort()定义
void bubbleSort(int array[]) 
{
    int length = str.size();
    if (str == nullptr || length < 2) {
        return;
    }
    // 外层循环 i：[0, length-1)，决定每轮多少个数不需要进行比较
    for (int i = 0; i < length-1; ++i) {
        // 内存循环，决定多少次比较
        for (int j = 0; j < length-i-1; ++j) {
            if (array[j] > array[j+1]) { 
                // array[j]>array[j+1]，不符合升序排序要求，
                // 使用中间变量交换数组元素
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
    
}

时间复杂度分析：

	最好	最坏	平均	稳定性
时间复杂度	O(n)	O(n^2)	O(n^2)	稳定

对于数组长度为n，第1轮比较：n-1次，

                               第2轮比较：n-2次，

                               ... ..........................,

                              第n-2轮比较：2次

                               第n-1轮比较：1次

所以总共需要比较1+2+...+n-1=(n-1)(n)/2次，基本为O(n^2)次，这不是很理想，如果数组长度比较大，该方式时间效率低