算法（排序）

如何分析一个“排序算法”？

排序算法的执行效率：
 1.最好情况、最坏情况、平均情况时间复杂度
 2.时间复杂度的系数、常数 、低阶
 3.比较次数和交换（或移动）次数

排序算法的内存消耗：

排序算法的稳定性：例子:订单的金额（可以相同）和时间排序。先按时间排序，再按金额排序
（如果是不稳定排序，先排好的时间顺序会乱，稳定的不会）。

冒泡排序（Bubble Sort）
冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果
不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工
作。

插入排序（Insertion Sort）

首先，我们将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第
一个元素。插入算法的核心思想是取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已
排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。

选择排序（Selection Sort）

选择排序算法的实现思路有点类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。先找出最小元素，再和1,2,3...交换。
 

 

public static void main(String[] args) {
    int array[] = {200000, 99999, 20098, 567202};
    // bubbleSort(array);
    //insertionSort(array);
    selectionSort(array);
    System.out.println(Arrays.toString(array));
}

public static void bubbleSort(int[] array) {//冒泡排序

    for (int j = array.length - 1; j > 0; j--) {

        for (int i = 0; i < j; i++) {
            if (array[i] > array[i + 1]) {
                exchange(i, i + 1, array);
            }
        }
    }
}

public static void exchange(int front, int now, int[] array) {//交换位置
    int temp = array[now];
    array[now] = array[front];
    array[front] = temp;
}

public static void insertionSort(int array[]) {//插入排序
    for (int i = 1; i < array.length; i++) {
        int temp = array[i];
        int j = i;
        for (; j > 0; j--) {
            if (temp < array[j - 1]) {
                array[j] = array[j - 1];
            } else {
                break;
            }
        }
        array[j] = temp;
    }
}

public static void selectionSort(int[] array) {//选择排序
    for (int i = 0; i < array.length; i++) {
        int j = array.length - 1;
        int temp = j;
        for (; j > i; j--) {
            if (array[j] > array[j - 1]) {
                temp = j - 1;
            }
        }
        exchange(i, temp, array);
    }
}

总结：

选择排序不稳定，使用时需要注意。插入和冒泡，时间复杂度一样，只是冒泡循环里多了几行代码，执行时间稍长，比较下来插入排序为最优。