数据结构--排序（一）

1. 排序的基本概念

1.1 什么是排序？

排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

通常意义上的排序，都是指的原地排序(in place sort)。

1.2 稳定性

两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。

2. 插入排序

2.1 直接插入排序原理

将整个区间被分为有序区间和无序区间，然后每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入

2.2 插入排序实现

public static void insertSort(int[] arr) {
    int bound = 1;
    // [0, bound) 已排序区间
    // [bound, length) 待排序区间
    for (; bound < arr.length; bound++) {
        int v = arr[bound];
        int cur = bound - 1;
        for (; cur >= 0; cur--) {
            if (arr[cur] > v) {
                arr[cur + 1] = arr[cur];
            } else {
                break;
            }
        }
        arr[cur + 1] = v;
    }
}

注意：
1.插入排序是稳定的
2.时间复杂度：O(n^2)
3.空间复杂度：O(1)

插入排序的两个特点：
1.如果数组长度比较短，排序效率很高
2.如果数组相对有序，排序效率也很高

3. 希尔排序

3.1 希尔排序原理

先选定一个整数 gap ，把待排序文件中所有记录分成个组，所有距离为 gap 的分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序

gap 取值一般为：size / 2 , size / 4 , size / 8, … 1

3.2 希尔排序实现

// 希尔排序
public static void shellSort(int[] arr) {
    int gap = arr.length / 2;
    while (gap >= 1) {
        _shellSort(arr, gap);
        gap /= 2;
    }
}

public static void _shellSort(int[] arr, int gap) {
    // 进行分组插排. 分组依据就是 gap.
    // gap 同时也表示分的组数.
    // 同组的相邻元素, 下标差值就是 gap
    // 下面的代码其实和插入排序是一样的. 尤其是把 gap 设为 1
    int bound = gap;
    for (; bound < arr.length; bound++) {
        int v = arr[bound];
        int cur = bound - gap;
        for (; cur >= 0; cur -= gap) {
            if (arr[cur] > v) {
                // 进行搬运
                arr[cur + gap] = arr[cur];
            } else {
                break;
            }
        }
        arr[cur + gap] = v;
    }
}

注意：
1.希尔排序是不稳定的
2.时间复杂度：O(n^1.3)
3.空间复杂度：O(1)

4. 选择排序

4.1 选择排序原理

先将整个数组分成两个区间：待排序区间和已排序区间。通过遍历待排序区间，选出最大（最小）元素，放到已排序区间最后（最前）

4.2 选择排序实现

// 选择排序
public static void selectSort(int[] arr) {
    // 创建 bound 变量， 表示已排序区间的边界
    // (0, bound] 已排序区间
    // [bound, arr.length) 待排序区间
    int bound = 0;
    for (; bound < arr.length; bound++) {
        // 外循环表示遍历
        // 内循环进行比较
        for (int cur = bound + 1; cur < arr.length; cur++) {
            if (arr[cur] < arr[bound]) {
                // 交换元素
                swap(arr, cur, bound);
            }
        }
    }
}
public static void swap(int[] arr, int x, int y) {
    int tmp = arr[x];
    arr[x] = arr[y];
    arr[y] = tmp;
}

注意：
1.选择排序是不稳定
2.时间复杂度：O(n^2)
3.空间复杂度：O(1)