数据结构与算法:冒泡排序

原理

从前到后,连续相连两个数对比,如果前一个数大于后一个数,则交换。

第一次:
arr[0] 和 arr[1] 对比,若arr[0] 大于 arr[1], 交换两个值。
arr[1] 和 arr[2]对比,若arr[1] 大于 arr[2], 交换两个值。
arr[2] 和 arr[3]对比,若arr[2]大于 arr[3],交换两个值。

arr[i] 和 arr[i +1]对比,若arr[i]大于 arr[i+1],交换两个值。
arr[n-2]和arr[n-1]对比,若arr[n-2]大于arr[n-2],交换两个值。

至此,arr[n-1]存储的是最大值。

第二次:
确定出 arr[n-2]的值。

第n-1次:
确定出 arr[1]的值,同时确定了arr[0]的值。

图解

数据结构与算法:冒泡排序_第1张图片

复杂度

时间复杂度 O(n²)
额外空间复杂度 O(1)

代码实现

java 版本
public static void bubbleSort(int[] array) {  
    if (array == null || array.length < 2) {  
        return;  
    }  
  
    for (int i = 0; i < array.length; i ++) {  // 控制第几次循环  
        for (int j = 0; j < array.length - i - 1; j ++) {  // 控制循环的范围  第一次 是 0 到 n-1, 第二次是 0 到 n -2            if (array[j] > array[j + 1]) {  
                swap(array, j, j +1);  
            }  
        }  
    }  
}
kotlin版本
fun bubbleSort(array: IntArray) {  
    if (array.size < 2) {  
        return  
    }  
  
    for (i in array.indices.reversed()) {  // i 从 N-1 到 0        for (j in (0) until i) {  
            if (array[j] > array[j + 1]) {  // 每次把最大的冒到最后。  
                // 把最小的值换到最前边来。  
                swap(array, j, j + 1)  
            }  
        }  
    }  
}

你可能感兴趣的:(数据结构与算法,排序,冒泡排序)