排序（Java实现）

一：排序

1：排序的概念

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

**稳定性：**假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。（例如：放在磁盘中，u盘中）

2：常见的排序算法

3：常见排序算法的实现

1：插入排序：

直接插入排序是一种简单的插入排序法，其基本思想是：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。实际中我们玩扑克牌时，就用了插入排序的思想。

1.1：直接插入排序

当插入第i(i>=1)个元素时，前面的array[0],array[1],...,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],...的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。

实现：

定义j和i，j=i--，然后用j和i遍历数组，如果i小于j就交换否则继续遍历，i走一步，j跟着走一步。

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

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

时间复杂度（最坏情况）：

9 8 7 6 5 4 3 2 1，全是倒叙的情况时最坏的情况，因为每一个元素都要与它后边的所有元素都进行比较一次。

所以用等差求和：

1.2：希尔排序( 缩小增量排序）

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成多个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达1时，所有记录在统一组内排好序。

希尔排序的特性总结：

1：希尔排序是对直接插入排序的优化。
2：当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3：希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定

4：希尔排序不稳定，空间复杂度为O（1），时间复杂度为n^1.3------n^1.5

2：选择排序：

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完

2.1：直接选择排序:

选择排序动画演示

1：在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素

2：若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换

3：剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

时间复杂度：

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

直接选择排序第二种:

用left和right记录最左边的值和最右边的值，默认min与max开始在最左边，然后遍历i，找到比array[min]小的就将min指向这个小的值的下标，最大值原理相同。

2.2：堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

排升序，建大堆：

排序的整个流程图：

首先先调用createHeap方法创建大根堆，因为升序要建大根堆，然后再调用堆排序，进行排序。

【直接选择排序的特性总结】：
1：堆排序使用堆来选数，效率就高了很多。
2：时间复杂度：O(N*logN)
3：空间复杂度：O(1)
4：稳定性：不稳定

3：交换排序

3.1：冒泡排序：

对数组两两比较，交换排序。

优化后：

优化后时间复杂度为：O（N）

定义一个flg变量，如果交换了flg就置为true，当flg没有交换，flg==false，此时说明序列已经有序，所以提前结束遍历，这样时间复杂度就降低了。

冒泡排序的特性总结：

1：时间复杂度：O(N^2)（没有优化的）
2：空间复杂度：O(1)
3：稳定性：稳定

3.2：快速排序（递归）：

Hoare法，挖坑法，前后指针法；这三种方法都是递归的方式

**三种方法优先使用****挖坑法，**另外两种方法了解

3.2.1：Hoare法：

定义一个基准，left和right，然后right与left向中间靠拢，必须right先动然后left才能动，因为最后的效果是，当left与right相遇后，这两个对应的下标的值与基准对应的值交换，此时保证基准的左边都比基准小，基准的右边都比基准大。

如果是left先动，right在动，那么是left向ight，那么就会存在一种科恩那个最后是left再找比基准大的值的时候与right相遇，此时相遇的值比基准要大，那么此时再交换相遇值与基准值时，基准的左边就比基准大了，与要求不符。

所以整个流程就相当进行了递归操作，当left与righ相遇时递归结束，那么只相遇时结束吗？？

例如：

时间复杂度：

nlog**(n****)**

源代码：

上述整个过程再递归过程中都会开辟新的内存进行递归，如果数据过大会导致运行失败。

3.2.2：挖坑法：

先用tmp临时储存基准array[left]，然后数组的最右边right向左移动，找比tmp小的值停下，然后将此时leftd对应的值变为right的值；数组最左边left向右移动找比tmp大的值停下，然后此时right对应的值变为left对应的值，然后重复刚才的过成，right走，left走，直到相遇，然后与此时相遇的值变为tmp。

因为基准时最左边，所以需要right先走，这样才能将array【0】填上，如果left先走，那么array[0]就不会变，一直是tmp。

源码：

源码只需要改变找基准pivot方法的代码即可，其他操作一样，因为只有找基准的方式不同。

3.2.3：前后指针法：

定义一个key基准，key=array[left]，在定义一个prev和cur，prev为left，cur为left+1，然后比较array[cur**]与array[left]的值，如果cur小，则prev往后移一个在比较array[prev]与array[cur],是否相等，如果不想等则cur与prev对应的值交换，然后cur再往后走一步，不管交不交换cur都往后走。（注意：只有比较的array[cur]《array[left]的值，prev才往后走，否则prev不走****）**

总结：

上述三种方法都是递归的方式，所以都会开辟新的内存，如果整个数组是倒序，例如：

优化：

（注意：下列方法的patition方法默认用的挖坑法）

所以开辟的空间高度会很大，那么可以进行优化：

**1：**三数取中法选key
**2：**递归到小的子区间时，可以考虑使用插入排序

1：三数取中法：

用上述的取中法递归就会缩小，递归的树大概类似下面这种，不会出现单一左树或是右树情况，大概递归方式：

2：递归到小的子区间时，可以考虑使用插入排序

因为插入排序的特点是，序列越有序，排序越快，所以快速排序在分的过程中序列越来越有序。

在快速排序的过程时，定义一个长度，当序列长度为7时，这时候不在使用快速排序，而是直接使用插入排序，然后然后到上一个递归，判断基准的右边长度是否也<7,这样递归的速度就会变快，效率得到提高。

3.2：快速排序（非递归）：

用栈的形式，记录序列的start和end，pivot+1和pivot-1，因为pivot+1与pivot-1，会在快排后的左右序列形成新的start和end，然后逐一进行快排。

总结：

1：快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序。
2：时间复杂度：O(N*logN）

3：空间复杂度：O(logN)（相当于开辟的内存是树的高度）

4：稳定性：不稳定

4：归并排序（递归）：

4.1：基本思想：

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序核心步骤：

分解过程：

合并过程：

6和10分解完后6 10合并，1和7分解完后，1 7合并，6 10， 1 7，这两组一起合并，3 9分解完后39合并，2 4分解完后2 4合并，然后3 9，2 4，这两组一起合并，然后1 6 7 0， 2 3 4 9，这两组一起合并。

完整过程举例（4个元素的）：