排序-CSDN博客

本文链接：https://blog.csdn.net/weixin_45124488/article/details/115413393

1，冒泡排序

冒泡排序算法的运作如下：

比较两个相邻的数，如果前面的数大于后面的数，则将这两个数交换位置。第一次遍历后，最大的数会被放到数组的最后位置，即array[length - 1]。
第二次遍历时跳过最后一个元素，因为该元素通过第一次遍历已经确定是最大值。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码：


public static void bubbleSort(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

2，选择排序

选择排序的思想：

每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
第一次循环时，i = 0，首先将代表着“最小值下标”的minIndex赋值为第一个数字的数组下标，即minIndex = 0。然后从第2个元素开始与array[minIndex]进行比较，如果有比array[minIndex]小的数，则将minIndex赋值为这个数的下标。当所有元素比较完后，再将array[0]与array[minIndex]交换位置，则arary[0]的值即为最小的数。
第二次循环时，从array[1]开始处理，最后比较出最小的数与array[1]交换位置，过程同步骤1。
直至处理完倒数第二个，结束处理。

代码

public class SelectSort {
    public static void selectSort(int[] array) {
        if (array == null || array.length == 0) {
            return;
        }
        for (int i = 0; i < array.length - 1; i++) {
            // 记录当次遍历值最小的数的位置
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                // 如果array[j]比array[minIndex]小, 则将minIndex修改为j
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            if (i != minIndex) {
                // 将当次遍历的最小值交换到对应位置
                int temp = array[i];
                array[i] = array[minIndex];
                array[minIndex] = temp;
            }
        }
    }
}

3，快速排序

快速排序（QuickSort）是对冒泡排序的一种改进。快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：

从要排序的数据中取一个数为“基准数”。
通过一趟排序将要排序的数据分割成独立的两部分，其中左边的数据都比“基准数”小，右边的数据都比“基准数”大。
然后再按步骤2对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
该思想可以概括为：挖坑填数 + 分治法。

代码

public class QuickSort {
    private static void quickSort(int[] array, int low, int high) {
        if (low >= high) {
            return;
        }
        int i = low, j = high, index = array[i]; // 取最左边的数作为基准数
        while (i < j) {
            while (i < j && array[j] >= index) { // 向左寻找第一个小于index的数
                j--;
            }
            if (i < j) {
                array[i++] = array[j]; // 将array[j]填入array[i]，并将i向右移动
            }
            while (i < j && array[i] < index) {// 向右寻找第一个大于index的数
                i++;
            }
            if (i < j) {
                array[j--] = array[i]; // 将array[i]填入array[j]，并将j向左移动
            }
        }
        array[i] = index; // 将基准数填入最后的坑
        quickSort(array, low, i - 1); // 递归调用，分治
        quickSort(array, i + 1, high); // 递归调用，分治
    }
 
    public static void quickSort(int[] array) {
        if (array == null || array.length == 0) {
            return;
        }
        quickSort(array, 0, array.length - 1);
    }
}

4，插入排序

插入排序的思想：

将一个数插入一个已经排好序的数据中。
第一次循环时，从第2个数开始处理。我们将第1个数作为已经排好序的数据：当第2个数 > 第1个数时，将第2个数放在第1个数后面一个位置；否则，将第2个数放在第1个数前面。此时，前两个数形成了一个有序的数据。
第二次循环时，我们处理第3个数。此时，前两个数形成了一个有序的数据：首先比较第3个数和第2个数，当第3个数 > 第2个数时，将第3个数放在第2个数后面一个位置并结束此次循环；否则，再和第1个数比较。如果第3个数 > 第1个数，则将第3个数插入第1个数和第2个数中间；否则，第3个数 < 第1个数，则将第3个数放在第1个数前面。此时，前三个数形成了一个有序的数据。
后续的数据同理处理，直至结束。

代码

public class InsertSort {
    public static void insertSort(int array[]) {
        if (array == null || array.length == 0) {
            return;
        }
        for (int i = 1; i < array.length; i++) {
            // 当array[i]比arra[i - 1]小时才进入处理
            if (array[i] < array[i - 1]) {
                // 临时变量存储array[i]的值
                int temp = array[i];
                // 从当前位置开始处理
                int j = i;
                // 将比temp大的数往后挪一个位置，为temp腾出一个合适位置
                while (j > 0 && temp < array[j - 1]) {
                    array[j] = array[j - 1];
                    j--; // 填充完后, 继续向前比较
                }
                // 将temp放在属于它的位置上
                array[j] = temp;
            }
        }
    }
}