一.Comparable 接口介绍
Java 提供了一个接口 Comparable 用来定义排序规则
二.冒泡排序 （ Bubble Sort ）
排序原理：
1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
简单来说，就是相邻的元素相互比较，直到排序结束。
冒泡排序的方法：
Bubble() ：创建 Bubble 对象
1.public static void sort(Comparable[] a)：对数组内的元素进行排序
2.private static boolean greater(Comparable v,Comparable w):判断v 是否大于 w
3.private static void exch(Comparable[] a,int i,int j)：交换a 数组中，索引 i 和索引 j 处的值
冒泡排序的时间复杂度分析 冒泡排序使用了双层 for循环，其中内层循环的循环体是真正完成排序的代码，所以我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。保留函数中的最高阶项那么最终冒泡排序的时间复杂度为 O(N^2).
代码实现及测试：
三.选择排序（Selection sort ）
排序原理：
1. 每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引处的值为最小值，最后可以找到最小值所在的索引
2.交换第一个索引处和最小值所在的索引处的值
选择排序的方法：
Selection() ：创建 Selection 对象
1.public static void sort(Comparable[] a) ：对数组内的元素进行排序
2.private static boolean greater(Comparable v,Comparable w): 判断 v 是否大于 w
3.private static void exch(Comparable[] a,int i,int j) ：交换 a 数组中，索引 i 和索引 j 处的值
选择排序的时间复杂度分析：
选择排序使用了双层 for循环，其中外层循环完成了数据交换，内层循环完成了数据比较，所以我们分别统计数据 交换次数和数据比较次数。保留最高阶项，去除常数因子，时间复杂度为 O(N^2);
代码实现：
四.插入排序（Insertion sort ）
排序原理：
1.把所有的元素分为两组，已经排序的和未排序的，刚开始时将数组的首元素作为已排序区间的第一个元素，然后每次取未排序区间的元素在已排序区间找到合适的位置插入 ；
2. 找到未排序的组中的第一个元素，向已经排序的组中进行插入；
3. 倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位；
插入排序方法：
构造方法：Insertion()：创建Insertion对象
成员方法：
1.public static void sort(Comparable[] a) ：对数组内的元素进行排序
2.private static boolean greater(Comparable v,Comparable w): 判断 v 是否大于 w
3.private static void exch(Comparable[] a,int i,int j) ：交换 a 数组中，索引 i 和索引 j 处的值
插入排序的时间复杂度分析
插入排序使用了双层 for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析插入排序的时间复 杂度，主要分析一下内层循环体的执行次数即可。保留函数中的最高阶项那么最终插入排序的时间复杂度为 O(N^2).
代码实现：
五.希尔排序（Shell sorting）
排序原理：即对插入排序的优化，插排的 元素是一个一个往后搬，损耗较大；现在是一次走好几步；
1.选定一个增长量h ，按照增长量 h 作为数据分组的依据，对数据进行分组；
2.对分好组的每一组数据完成插入排序；
3.减小增长量，最小减为1 ，重复第二步操作。
4.增量h一般公式：h=n/2，向下取整；增量缩小公式：h=h/2,向下取整，直到增量为1排序结束
希尔排序方法：
构造方法：Shell()：创建Shell对象
成员方法：1.public static void sort(Comparable[] a)：对数组内的元素进行排序
2.private static boolean greater(Comparable v,Comparable w):判断v是否大于w
3.private static void exch(Comparable[] a,int i,int j)：交换a数组中，索引i和索引j处的值
代码实现：
六.归并排序
排序原理：先分后治
1. 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。
2.将相邻的两个子组进行合并成一个有序的大组；
3. 不断的重复步骤 2 ，直到最终只有一个组为止。
归并排序方法：
构成方法： Merge() ：创建 Merge 对象
成员方法：
1.public static void sort(Comparable[] a) ：对数组内的元素进行排序
2.private static void sort(Comparable[] a, int lo, int hi) ：对数组 a 中从索引 lo 到索引 hi 之间的元素进
行排序
3.private static void merge(Comparable[] a, int lo, int mid, int hi): 从索引 lo 到所以 mid 为一个子组，从索引mid+1 到索引 hi 为另一个子组，把数组 a 中的这两个子组的数据合并成一个有序的大组（从索引lo 到索引 hi ）
4.private static boolean less(Comparable v,Comparable w): 判断 v 是否小于 w
5.private static void exch(Comparable[] a,int i,int j) ：交换 a 数组中，索引 i 和索引 j 处的值
成员变量：private static Comparable[] assist ：完成归并操作需要的辅助数组
时间复杂度分析： 假设元素的个数为 n ，那么使用归并排序拆分的次数为 log2(n), 所以 共log2(n)层 ，
最终得出的归并排序的时间复杂度为：层数* 2^层数=n*层数，即log2(n)* 2^(log2(n))= log2(n)*n ,根据大 O 推导法则，忽略底数，最终归并排序的时间复杂度为O(nlogn);
代码实现：
七.快速排序：
排序原理：
1. 首先 设定一个分界值 ，通过该分界值将数组分成左右两部分,为了方便，分界值可以取第一个数；
2. 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边 。
3.然后，左边和右边的数据独立排序。对于左边数据，再取一个分界值，再分成左右两部分，同样在左边放置较小值，右边放置较大值。右边数据也做相同操作。
4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
快速排序方法：
构造方法：
Quick() ：创建 Quick 对象
成员方法：
1.public static void sort(Comparable[] a) ：对数组内的元素进行排序
2.private static void sort(Comparable[] a, int lo, int hi) ：对数组 a 中从索引 lo 到索引 hi 之间的元素
进行排序
3.public static int partition(Comparable[] a,int lo,int hi): 对数组 a 中，从索引 lo 到索引 hi 之间的元
素进行分组，并返回分组界限对应的索引
4.private static boolean less(Comparable v,Comparable w): 判断 v 是否小于 w
5.private static void exch(Comparable[] a,int i,int j) ：交换 a 数组中，索引 i 和索引 j 处的值
时间复杂度分析：
快速排序的一次切分从两头开始交替搜索，直到left 和 right 重合。所以一次切分算法的时间复杂度为 O(n), 但整个快速排序的时间复杂度和切分的次数相关。
最优情况 ：每一次切分选择的基准数字刚好将当前序列等分， 共切分 logn 次，所以 时间复杂度为 O(nlogn)；
最坏情况 ：每次切分选择的数是数组n中的最大或最小数，那么总共就得切分n 次，所以，最坏情况下，快速排序的时间复杂度为 O(n^2)；
代码实现：
八.排序算法的稳定性
在使用某种排序算法排序后，依旧能够保证A元素在B元素的前面，那么就说该算法是稳定的。
常见的算法中，冒泡排序，插入排序，归并排序都是稳定的；
而选择排序，希尔排序，快速排序都是不稳定的。
九.排序算法的时空复杂度总结
