java算法之冒泡排序、选择排序、插入排序

冒泡排序

重复访问数列
，一次比较相邻两个元素，如果前一个元素比后一个元素大，那么交换他们的顺序，多次交换之后得出正确排序。

假设有这样一个数组{7, 3, 6, 1, 9, 2, 5, 4, 0, 8}，使用冒泡排序进行排序，每次循环从最后一个元素开始，相邻的两个元素进行比较，如果前一个元素大于后一个元素，则两者互换

1. 第一次排序的结果为{7, 3, 6, 1, 9, 2, 5, 4, 0, 8}，其实就是把最小的元素0放到数组的第一个

2. 第二次排序的结果为{0, 1, 7, 3, 6, 2, 9, 4, 5, 8}，其实就是把第二小的元素1放到数组的第二个

3. 第三次排序的结果为{0, 1, 2, 7, 3, 6, 4, 9, 5, 8}，其实就是把第三小的元素3放到数组的第三个

4. 以此类推即可得出最终结果

使用java实现为：

int[] a = {7, 3, 6, 1, 9, 2, 5, 4, 0, 8};
for (int i = 0; i < a.length; i++) {
    for (int j = a.length - 1; j > i; j--) {
        if (a[j] < a[j - 1]) {
            int temp = a[j];
            a[j] = a[j - 1];
            a[j - 1] = temp;
        }
    }
    System.out.println("第" + (i + 1) + "次排序结果：" + Arrays.toString(a));
}

结论：假设数列长度为n，执行交换的总次数为：n+(n-1)+(n-2)+…+1，简化后的结果为n*(n-1)/2，忽略常数，所以它的时间复杂度是O(n^2)

选择排序

每一次从待排序的数列中选出最大或最小的元素放到起始位置

假设有数组{3, 7, 6, 1, 9, 2, 5, 4, 0, 8}，选择排序每次循环会假设一个最小值，然后找到真正的最小值再与其交换。

1. 我们假设数组中最小的元素为第一个元素3，经过第一次排序发现真正最小的是最后一个元素0， 第一次排序的结果为{0, 7, 6, 1, 9, 2, 5, 4, 3, 8}

2. 我们假设数组中最小的元素为第二个元素7，经过第二次排序发现真正最小的是第四个元素1，所以第二次排序的结果为{0, 1, 6, 7, 9, 2, 5, 4, 3, 8}

3. 我们假设数组中最小的元素为第3个元素6，经过第二次排序发现真正最小的是最后一个元素3，所以第三次排序的结果为{0, 1, 2, 7, 9, 6, 5, 4, 3, 8}

用java实现为：

int[] array = {3, 7, 6, 1, 9, 2, 5, 4, 0, 8};
for (int i = 0; i < array.length; i++) {
    // 假设最小值的下标为i
    int min = i;
    // 查找当次循环中真正的最小值下标
    for (int j = i + 1; j < array.length; j++) {
        if (array[min] > array[j]) {
            min = j;
        }
    }
    // 交换
    int temp = array[i];
    array[i] = array[min];
    array[min] = temp;
    System.out.println("第" + (i + 1) + "次排序结果：" + Arrays.toString(array));
}

结论：相比于冒泡算法，选择排序的交换次数为N，但是冒泡排序是相邻元素交换，交换次数很明显是多余选择排序的。但是尽管这样，他的时间复杂度依然是O(n^2)

插入排序

可以把插入算法想象成一个拔萝卜的游戏，有一串萝卜{3, 7, 6, 1, 9, 2, 5, 4, 0}，使用插入排序进行排序。

1. 第一次排序，把萝卜7拔出来，因为萝卜3比萝卜7要小，所以把萝卜3放到萝卜7前面，结果就为{3, 7, 6, 1, 9, 2, 5, 4, 0, 8}

2. 第二次排序，把萝卜6拔出来，因为萝卜6大于萝卜3，但是萝卜6小于萝卜7，所以把萝卜6放在萝卜3后面，萝卜7前面，结果为{3, 6, 7, 1, 9, 2, 5, 4, 0, 8}

3. 第三次排序，把萝卜1拔出来，因为萝卜1小于萝卜3，所以把萝卜1放到萝卜3前面，结果为{1, 3, 6, 7, 9, 2, 5, 4, 0, 8}

4. 按照以上规律以此类推即可得到最终排序{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

java代码实现：

int[] array = {3, 7, 6, 1, 9, 2, 5, 4, 0, 8};
for (int i = 1; i < array.length; i++) {
    int j;
    int temp = array[i];
    for (j = i; j > 0 && array[j - 1] > temp; j--) {
        array[j] = array[j - 1];
    }
    array[j] = temp;
    System.out.println("第" + i + "次排序结果：" + Arrays.toString(array));
}

结论：插入排序从代码上来看也是用了2个循环，所以他的时间复杂度依然是O(n^2)，但是由于它每次排序之后，前面一部分元素都是有序的，所以交换元素的次数和循环的次数是会少于选择排序和冒泡排序的，所以按照速度来说三种排序的顺序为：插入排序最快，选择排序第二，冒泡排序最慢。