数据结构与算法学习刷题 冒泡排序

几天前加入算法刷题知识星球，开始数据结构与算法之旅，在CSDN上记录一下刷题过程

基本思想：比较相邻两个数的大小，较大的数下沉，较小的数冒起来。
算法过程：
1、比较相邻两个数的大小，如果前者大于后者，则两数位置交换，否则，继续依次找下一对相邻的两个数进行比较。
注意：这里每次比较的是相邻的两个数，不是某一个数与其他数比较。
2、第一轮遍历是第一个数与第二个数比较、交换，然后是第二个数与第三个数比较、交换，直到倒数第二个数与最后一个数进行完比较、交换后，第一轮遍历就结束了，最大的数已经交换到了序列的最后一位。
3、第二轮遍历将第二大的数交换到了倒数第二的位置上。
4、依次进行n-1轮遍历，最后的序列顺序就是从小打到排列了。

动图演示

Python实现

#自己写的
def bubbleSelect(lst):
    n = len(lst)
    for i in range(n):
        for j in range(n - 1):
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
    return lst
    
#参考星友代码
def bubbleSelect_optimised(lst):
    n = len(lst)
    lastchageIndex = n
    sortBorder = n - 1 #待排序序列的边界
    for i in range(n):
        isSorted = True
        for j in range(sortBorder):
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
                lastchageIndex = j
                isSorted = False
        sortBorder = lastchageIndex
        if isSorted:
            break
    return lst

优化：
1、加一个是否排序的标签，若已排好序，则退出遍历。
2、每轮遍历的边界是动态变化的，依次前移一位。

Java实现

public int[] bubbleSort(int[] array) {
        int length = array.length;
        for (int i = 0; i < length; i++) {
            boolean isSorted = true;
            //length - 1 - 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;
                    isSorted = false;
                }
            }
            if (isSorted) {
                break;
            }
        }
        return array;
    }

复杂度
1、时间复杂度
最坏情况：$O(n^2)$
最好情况：$O(n)$
平均：$O(n^2)$
2、空间复杂度：$O(1)$
3、稳定性：稳定