七大排序算法——详细介绍（上）

前言

这一章主要是对七大排序算法进行详解，并对其稳定性及复杂度进行分析。那么什么是稳定性呢？其指的是即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

常见的排序算法

注记：为了方便介绍，下面排序算法默认都是以升序作为演示！

一、插入排序

1、插入排序思想

基本思想：把待排序的记录其数值逐一插入到已经排好序的有序序列中，知道所有的序列插入为止。

2、代码实现

// 插入排序
    public static void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i;
            //找到j的前一个比当前tmp小的，并插入
            while (j - 1 >= 0 && array[j - 1] > tmp) {
                array[j] = array[j - 1];
                j--;
            }
            array[j] = tmp;
        }
    }

3、特性

直接插入排序的特性总结：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定

二、希尔排序

1、希尔排序基本思想

基本思想：在插入排序的基础上，把待排序文件中所有值分为多个组，并对每一组的值进行排序，然后减小分组的大小，重复排序，直到剩下最后一大组，即排序完成。

2、代码实现

// 希尔排序
    public static void shellSort(int[] array) {
    //一般我们每次都是每次把gap/2
        int gap = array.length;
        while (gap > 1) {
            gap /= 2;
            shell(array, gap);
        }
    }

    public static void shell(int[] array, int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i;
            while (j - gap >= 0 && array[j - gap] > tmp) {
                array[j] = array[j - gap];
                j -= gap;
            }
            array[j] = tmp;
        }
    }

3、特性

希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算。
4. 稳定性：不稳定

三、选择排序

1、选择排序基本思想

基本思想：每一次从待排序的数据元素中找到最小的元素，存放在此次排序的起始位置，直到全部排完。

2、代码实现

	// 选择排序
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            swap(array, i, minIndex);
        }
    }
    public static void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

选择排序的优化：同时找最小值和最大值

public static void selectSort(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            int minIndex = left;
            int maxIndex = left;
            for (int i = left + 1; i <= right; i++) {
                if (array[i] < array[minIndex]) {
                    minIndex = i;
                }
                if (array[i] > array[maxIndex]) {
                    maxIndex = i;
                }
            }
            swap(array, left, minIndex);
            //如果要交换最大值的下标是left，则需要注意其值在上一步就已经被换到为minIndex的下标
            if (maxIndex == left) {
                maxIndex = minIndex;
            }
            swap(array, right, maxIndex);
            left++;
            right--;
        }
    }

3、特性

直接选择排序的特性总结

1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

四、堆排序

1、堆排序基本思想

基本思想：利用堆这种数据结构，升序就建大根堆（降序建小根堆），交换根节点和最后一个节点的数据，然后对根节点进行向下调整，下一轮就交换根节点和倒数第二个节点，循环直到排到根节点。

2、代码实现

// 堆排序
    public static void heapSort(int[] array) {
        // write code  here
        createBigHeap(array);
        int end = array.length - 1;
        while (end > 0) {
            swap(array, 0, end);
            siftDown(array, 0, end);
            end--;
        }
    }

    //排序从小到大————建立大根堆
    public static void createBigHeap(int[] array) {
        for (int parent = (array.length - 1 - 1) / 2; parent >= 0; parent--) {
            siftDown(array, parent, array.length);
        }
    }

    public static void siftDown(int[] array, int parent, int end) {
        int child = parent * 2 + 1;
        while (child < end) {
            if (child + 1 < end && array[child] < array[child + 1]) {
                child++;
            }
            //child此时是两个孩子节点最大的那个
            if (array[child] > array[parent]) {
                swap(array, child, parent);
                parent = child;
                child = parent * 2 + 1;
            } else {
                break;
            }
        }
    }

3、特性

直接选择排序的特性总结

1. 堆排序使用堆来选数，效率就高了很多。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

五、冒泡排序

1、冒泡排序思想

基本思想：这个排序想必大家再熟悉不过了，毕竟大多数程序猿学习的第一个排序就是冒泡排序，其思想就是两两比较把最大值沉底

2、代码实现

在实现其代码时，我进行了一个小小的优化，就是如果用flag判断走过一轮后没有发生交换，则说明此时序列已经有序，即可以退出循环了

// 冒泡排序
    public static void bubbleSort(int[] array) {
        // write code  here
        for (int i = 0; i < array.length; i++) {
            boolean flag = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                    flag = true;
                }
            }
            if (!flag) {
                break;
            }
        }
    }

3、特性

冒泡排序的特性总结

1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定

小结

此章先介绍了前五个排序算法，还算是比较简单，在七大排序算法——详细介绍（下）中会介绍最后的两种排序算法-> 快速排序和归并排序