Java数据结构（三）排序
一、简单排序
1.1 Comparable接口介绍
由于我们这里要讲排序，所以肯定会在元素之间进行比较，而Java提供了一个接口Comparable就是用来定义排序
规则的，在这里我们以案例的形式对Comparable接口做一个简单的回顾。
需求：
1.定义一个学生类Student，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则；
2.定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable ,c2)完成测试
public class ComparableTest {
public static void main(String[] args) {
Student student1 = new Student();
student1.setUserName("张三");
student1.setAge(18);
Student student2 = new Student();
student2.setUserName("李四");
student2.setAge(20);
System.out.println(compare(student1, student2));
}
private static Comparable compare(Comparable c1,Comparable c2){
int i = c1.compareTo(c2);
if(i>=0){
return c1;
}else {
return c2;
}
}
}
class Student implements Comparable<Student> {
public String userName;
public int age;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"userName='" + userName + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student o) {
return this.getAge() - o.getAge();
}
}
Student{userName='李四', age=20}
1.2、冒泡排序
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法
案例：
- 需求： 排序前：{4,5,6,3,2,1} 排序后：
- 排序原理
- 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置
- 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值
-
API设计
类名 BubbleSort 构造方法 BubbleSort()：创建BubbleSort对象 成员方法 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处的值 -
代码实现
public class BubbleSort {
public static void main(String[] args) {
Integer[] c = {4, 5, 6, 3, 2, 1};
System.out.println("排序前：" + Arrays.toString(c));
sort(c);
System.out.println("排序后：" + Arrays.toString(c));
}
/**
* 排序
* Comparable[] c说这c是一些实现Comparable接口的类的实例数组
* @param c
*/
public static void sort(Comparable[] c) {
// 冒泡次数
for (int i = c.length - 1; i > 0; i--) {
// 每次冒泡中比较次数
for (int j = 0; j < i; j++) {
// 比较当前j与j+1的值
if (greater(c[j], c[j + 1])) {
exch(c, j, j + 1);
}
}
}
}
/**
* 比较 c1 是否大于 c2
*
* @param c1
* @param c2
* @return
*/
private static boolean greater(Comparable c1, Comparable c2) {
return c1.compareTo(c2) > 0;
}
/**
* 交换数组 c 中 i 和 j 位置的元素
*
* @param c
* @param i
* @param j
*/
private static void exch(Comparable[] c, int i, int j) {
Comparable temp = c[i];
c[i] = c[j];
c[j] = temp;
}
}
排序前：[4, 5, 6, 3, 2, 1]
排序后：[1, 2, 3, 4, 5, 6]
-
时间复杂度分析
-
冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。
-
在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么：元素比较的次数为：
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2
元素交换的次数为：
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2
总执行次数为：
(N^2 /2 -N/2) + (N^2 /2-N/2) = N^2-N
-
按照大O推导法则，保留函数中的最高阶项，那么最终冒泡排序的时间复杂度为： O(N^2) (平方阶)
-
1.3、选择排序
选择排序是一种更加简单直观的排序方法
案例：
- 需求： 排序前：{4,6,8,7,9,2,10,1} 排序后：
- 排序原理
- 每一次遍历的过程中，都假定第一个索引处的元素是最 小值，和其他索引处的值依次进行比较，如果当前索引处 的值大于其他某个索引处的值，则假定其他某个索引出 的值为最小值，最后可以找到最小值所在的索引
- 交换第一个索引处和最小值所在的索引处的值
-
API设计
类名 SelectionSort 构造方法 SelectionSort()：创建SelectionSort对象 成员方法 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处的值 -
代码实现
public class SelectionSort {
public static void main(String[] args) {
Integer[] c = {4,6,8,7,9,2,10,1};
System.out.println("排序前：" + Arrays.toString(c));
sort(c);
System.out.println("排序后：" + Arrays.toString(c));
}
/**
* 排序
* @param c
*/
public static void sort(Comparable[] c) {
// 选择趟数
for (int i = 0; i < c.length - 1; i++) {
// 定义一个变量，记录最小元素所在的素引；默认为参与排序的第一个元素的所在索引
int minindex = i;
// 每一趟中的比较次数，找出这一趟中参与排序的最小元素j
for (int j = i + 1; j < c.length; j++) {
// 比较minindex与j位置的值
if (greater(c[minindex], c[j])) {
minindex = j;
}
}
// 交换索引位置为i、minindex的值
exch(c, i, minindex);
}
}
/**
* 比较 c1 是否大于 c2
*
* @param c1
* @param c2
* @return
*/
private static boolean greater(Comparable c1, Comparable c2) {
return c1.compareTo(c2) > 0;
}
/**
* 交换数组 c 中 i 和 j 位置的元素
*
* @param c
* @param i
* @param j
*/
private static void exch(Comparable[] c, int i, int j) {
Comparable temp = c[i];
c[i] = c[j];
c[j] = temp;
}
}
排序前：[4, 6, 8, 7, 9, 2, 10, 1]
排序后：[1, 2, 4, 6, 7, 8, 9, 10]
-
时间复杂度分析
-
选择排序使用了 双层for循环，其中外层循环完成了数据交换，内层循环完成了数据比较，所以我们分别统计数据交换次数和数据比较次数：
数据比较次数：
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2 /2 - N/2;
数据交换次数：
N-1
时间复杂度：N^2 /2 - N/2+（N-1）=N^2 /2 + N/2 - 1
-
根据大O推导法则，保留最高阶项，去除常数因子，时间复杂度为：O(N^2) （平方阶）
-
1.4、插入排序
插入排序（Insertion sort）是一种简单直观且 稳定的 排序算法
插入排序的工作方式非常像人们排序一手扑克牌一样。
开始时，我们的左手为空并且桌子上的牌面朝下。然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较，如下图所示：
案例：
- 需求：排序前：{4,3,2,10,12,1,5,6} 排序后：
- 排序原理：
- 把所有的元素分为两组，已经排序的和未排序的
- 找到未排序的组中的第一个元素，向已经排序的组中进行插入
- 倒序遍历已经排序的元素，依次和待插入的元素进行比较， 直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位
-
API设计
类名 InsertionSort 构造方法 InsertionSort 成员方法 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处的值 -
代码实现
public class InsertionSort {
public static void main(String[] args) {
Integer[] c = {4,3,2,10,12,1,5,6};
System.out.println("排序前：" + Arrays.toString(c));
sort(c);
System.out.println("排序后：" + Arrays.toString(c));
}
/**
* 排序
*
* @param c
*/
public static void sort(Comparable[] c) {
// 未排序元素
for(int i=1;i<c.length;i++){
// 取出未排序元素中的第一个，依次与已排序元素比较(倒序)，找出合适的位置插入
for(int j=i;j>0;j--){
if(greater(c[j-1],c[j])){
// 前面大于后面，交换位置
exch(c,j-1,j);
}else{
// 前面不大于后面，退出内循环
break;
}
}
}
}
/**
* 比较 c1 是否大于 c2
*
* @param c1
* @param c2
* @return
*/
private static boolean greater(Comparable c1, Comparable c2) {
return c1.compareTo(c2) > 0;
}
/**
* 交换数组 c 中 i 和 j 位置的元素
*
* @param c
* @param i
* @param j
*/
private static void exch(Comparable[] c, int i, int j) {
Comparable temp = c[i];
c[i] = c[j];
c[j] = temp;
}
}
排序前：[4, 3, 2, 10, 12, 1, 5, 6]
排序后：[1, 2, 3, 4, 5, 6, 10, 12]
- 时间复杂度分析
- 插入排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析插入排序的时间复杂度，主要分析一下内层循环体的执行次数即可
- 最坏情况，也就是待排序的数组元素为{12,10,6,5,4,3,2,1}，那么：
比较的次数为：
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2 = N^2/2-N/2
交换的次数为：
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)(N-1)/2 = N^2/2-N/2
总执行次数为：
(N^2 /2 - N/2) + (N^2 /2-N /2) = N^2-N - 按照大O推导法则，保留函数中的最高阶项，时间复杂度为：O(N^2) （平方阶）
二、高级排序
之前我们学习过基础排序，包括冒泡排序，选择排序还有插入排序，并且对他们在最坏情况下的时间复杂度做了分析，发现都是O(N^2)，而平方阶通过我们之前学习算法分析我们知道，随着输入规模的增大，时间成本将急剧上升，所以这些基本排序方法不能处理更大规模的问题，接下来我们学习一些高级的排序算法，争取降低算法的时间复杂度最高阶次幂。
2.1、希尔排序
希尔排序是插入排序的一种，又称“缩小增量排序”，是插入排序算法的一种更高效的改进版本
前面学习插入排序的时候，我们会发现一个很不友好的事儿，如果已排序的分组元素为{2,5,7,9,10}，未排序的分组元素为{1,8}，那么下一个待插入元素为1，我们需要拿着1从后往前，依次和10,9,7,5,2进行交换位置，才能完成真正的插入，每次交换只能和相邻的元素交换位置。那如果我们要提高效率，直观的想法就是一次交换，能把1放到更前面的位置，比如一次交换就能把1插到2和5之间，这样一次交换1就向前走了5个位置，可以减少交换的次数，这样的需求如何实现呢？接下来我们来看看希尔排序的原理。
案例：
- 需求： 排序前：{9,1,2,5,7,4,8,6,3,5} 排序后：
- 排序原理
- 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组
- 对分好组的每一组数据完成插入排序
- 减小增长量，最小减为1，重复第二步操作
- 增长量h规则
// 确定增长量h的最大值
int h = 1
while(h < 数组长度/2){
h = 2h + 1；
}
// 增长量h的减小规则
h = h/2
-
API设计
类名 ShellSort 构造方法 ShellSort()：创建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处的值 -
代码实现
public class ShellSort {
/**
* 希尔排序
*
* @param c
*/
public static void sort(Comparable[] c) {
// 1、根据数组c的长度，确定增长量h的初始值
int h = 1;
while (h < c.length / 2) {
h = 2 * h + 1;
}
// 2、希尔排序
while (h > 0) {
// 2.1、找到待插入的元素
for (int i = h; i < c.length; i++) {
// 2.2、把待插入的元素放在合适的位置
for (int j = i; j >= h; j -= h) {
// 待插入元素是c[j]；比较c[j]、c[j-h]
if (greater(c[j - h], c[j])) {
//前面大于后面，交换位置
exch(c, j - h, j);
} else {
// 前面不大于后面，退出内循环
break;
}
}
}
// 2.3、减小h值，继续下次循环
h = h / 2;
}
}
/**
* 比较 c1 是否大于 c2
*
* @param c1
* @param c2
* @return
*/
private static boolean greater(Comparable c1, Comparable c2) {
return c1.compareTo(c2) > 0;
}
/**
* 换数组 c 中 i 和 j 位置的元素
*
* @param c
* @param i
* @param j
*/
private static void exch(Comparable[] c, int i, int j) {
Comparable temp = c[i];
c[i] = c[j];
c[j] = temp;
}
}
public class SortTest {
/**
* 希尔排序
*/
@Test
public void testShellSort(){
Integer[] c = {9,1,2,5,7,4,8,6,3,5};
System.out.println("排序前：" + Arrays.toString(c));
ShellSort.sort(c);
System.out.println("排序后：" + Arrays.toString(c));
}
}
排序前：[9, 1, 2, 5, 7, 4, 8, 6, 3, 5]
排序后：[1, 2, 3, 4, 5, 5, 6, 7, 8, 9]
-
时间复杂度分析
在希尔排序中，增长量h并没有固定的规则，在这里就不做分析了。
可以使用 事后分析法 对希尔排序和插入排序做性能比较。 -
性能测试
从100000到1的逆向数据，可以根据这个批量数据完成测试。
测试的思想：记录排序前后的时间差
public class SortTest {
/**
* 比较插入排序和希尔排序
*/
@Test
public void testInsertionAndShell() {
Integer[] c = getArray(10_0000);
long start = System.currentTimeMillis();
//InsertionSort.sort(c);//用时：17683
ShellSort.sort(c);//用时：27
long end = System.currentTimeMillis();
System.out.println("用时：" + (end - start));
}
/**
* 得到待排序数组
* 最坏情况（倒序，从大到小）
*
* @param n
* @return
*/
private Integer[] getArray(int n) {
Integer[] c = new Integer[n];
for (int i = 0; i < n; i++) {
c[i] = n - i;
}
return c;
}
}
插入排序用时：17683
希尔排序用时：27
通过测试发现，在处理大批量数据时，希尔排序的性能明显高于插入排序
2.2、归并排序
1）递归
- 定义： 定义方法时，在方法内部调用方法本身，称之为递归
public void show(){
System.out.println("aaaa");
show();
}
- 作用
它通常把一个大型复杂的问题，层层转换为一个与原问题相似的，规模较小的问题来求解。递归策略只需要少量的程序，就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量 - 注意事项
在递归中，不能无限制的调用自己，必须要有边界条件，能够让递归结束，因为每一次递归调用都会在栈内存开辟新的空间，重新执行方法，如果递归的层级太深，很容易造成 栈内存溢出
2）归并排序
归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用 分治法 的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并
案例：
- 需求：排序前：{8,4,5,7,1,3,6,2} 排序后：
- 排序原理
- 尽可能的把一组数据拆分成两个元素相等的子组， 并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止
- 将相邻的两个子组进行合并成一个有序的大组
- 不断的重复步骤2，直到最终只有一个组为止
-
API设计、
类名 Merge 构造方法 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成员变量 1.private static Comparable[] assist：完成归并操作需要的辅助数组 -
归并原理
- 代码实现
public class MergeSort {
/**
* 归并所需要的辅助数组
*/
private static Comparable[] assist;
/**
* 对数组c中的元素进行排序
*
* @param c
*/
public static void sort(Comparable[] c) {
// 1.初始化辅助数组
assist = new Comparable[c.length];
// 2.定义变量lo、hi；分别记录数组中的边界索引
int lo = 0;
int hi = c.length - 1;
// 3.调用sort重载方法，完成数组c中,从lo到hi的排序
sort(c, lo, hi);
}
/**
* 对数组c中的从 lo 到 hi 元素进行排序
*
* @param c
* @param lo
* @param hi
*/
private static void sort(Comparable[] c, int lo, int hi) {
// 1、参数有效性检查
if (hi <= lo) {
return;
}
// 2、对数组c中，从lo到hi进行分组(两个组)
int mid = lo + (hi - lo) / 2;
// 3、分别对两个分组排序
sort(c, lo, mid);
sort(c, mid + 1, hi);
// 4、归并两个分组
merge(c, lo, mid, hi);
}
/**
* 对数组c中，从 lo 到 mid 为一组，从 mid+1 到 hi 为一组，对这两组数据进行归并
*
* @param c
* @param lo
* @param mid
* @param hi
*/
private static void merge(Comparable[] c, int lo, int mid, int hi) {
// 定义三个指针：辅助数组i，左子数组p1，右子数组p2
int i = lo;
int p1 = lo;
int p2 = mid + 1;
// 遍历：移动p1、p2，比较索引位置的值，找出小的值，放入辅助数组中相应位置
while (p1 <= mid && p2 <= hi) {
if (less(c[p1], c[p2])) {
assist[i++] = c[p1++];
} else {
assist[i++] = c[p2++];
}
}
// 遍历：如果p1指针没有走完，那么顺序移动p1，把剩余元素放入辅助数组相应位置
while (p1 <= mid) {
assist[i++] = c[p1++];
}
// 遍历：如果p2指针没有走完，那么顺序移动p2，把剩余元素放入辅助数组相应位置
while (p2 <= hi) {
assist[i++] = c[p2++];
}
// 把辅助数组中的元素拷贝到原数组中相应位置
for (int index = lo; index <= hi; index++) {
c[index] = assist[index];
}
}
/**
* 比较 c1 是否小于 c2
*
* @param c1
* @param c2
*/
private static boolean less(Comparable c1, Comparable c2) {
return c1.compareTo(c2) < 0;
}
}
public class SortTest {
/**
* 归并排序
*/
@Test
public void testMergeSort(){
Integer[] c = {8,4,5,7,1,3,6,2};
System.out.println("排序前：" + Arrays.toString(c));
MergeSort.sort(c);
System.out.println("排序后：" + Arrays.toString(c));
}
}
排序前：[8, 4, 5, 7, 1, 3, 6, 2]
排序后：[1, 2, 3, 4, 5, 6, 7, 8]
-
时间复杂度分析
归并排序是 分治思想 的最典型的例子，上面的算法中，对a[lo...hi]进行排序，先将它分为a[lo...mid]和
a[mid+1...hi]两部分，分别通过递归调用将他们单独排序，最后将有序的子数组归并为最终的排序结果。该递归的出口在于如果一个数组不能再被分为两个子数组，那么就会执行merge进行归并，在归并的时候判断元素的大小进行排序
用树状图来描述归并，如果一个数组有8个元素，那么它将每次除以2找最小的子数组，共拆log8次，值为3，所以树共有3层，那么自顶向下第k层有2^k 个子数组，每个数组的长度为2^ (3-k)，归并最多需要2^(3-k)次比较。因此每层的比较次数为 2^k * 2^(3-k) = 2^3，那么3层总共为 3 * 2^3
假设元素的个数为n，那么使用归并排序拆分的次数为log2(n)，所以共log2(n)层，那么使用log2(n)替换上面3 * 2^3中的3这个层数，最终得出的归并排序的时间复杂度为：log2(n) * 2^(log2(n)) = log2(n) * n
根据大O推导法则，忽略底数，最终归并排序的时间复杂度为：O(n*logn) （对数阶）
-
缺点
需要申请额外的数组空间，导致空间复杂度提升，是典型的 以空间换时间 的操作
-
归并排序与希尔排序性能测试
public class SortTest {
/**
* 比较希尔排序和归并排序
*/
@Test
public void testMergeAndShell(){
Integer[] c = getArray(10_0000);
long start = System.currentTimeMillis();
//ShellSort.sort(c);//用时：23
MergeSort.sort(c);//用时：52
long end = System.currentTimeMillis();
System.out.println("用时：" + (end - start));
}
/**
* 得到待排序数组
* 最坏情况（倒序，从大到小）
*
* @param n
* @return
*/
private Integer[] getArray(int n) {
Integer[] c = new Integer[n];
for (int i = 0; i < n; i++) {
c[i] = n - i;
}
return c;
}
}
通过测试，发现希尔排序和归并排序在处理大批量数据时差别不是很大
2.3、快速排序
快速排序是 对冒泡排序的一种改进。它的基本思想是：通过一 趟排序将要排序的数据分割成独立的两部分，其中一部分的所 有数据都比另外一部分的所有数据都要小，然后再按此方法 对这两部分数据分别进行快速排序，整个排序 过程可以递归进行，以此达到整个数据变成有序序列
案例：
- 需求： 排序前:{6, 1, 2, 7, 9, 3, 4, 5, 8} 排序后:
- 排序原理
- 首先设定一个 分界值，通过该分界值将数组分成左右两部分
- 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值
- 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理
- 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了
-
API设计
类名 Quick 构造方法 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处的值 -
切分原理
把一个数组切分成两个子数组的基本思想：
- 找一个基准值，用两个指针分别指向数组的头部和尾部
- 先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置
- 再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置
- 交换当前左边指针位置和右边指针位置的元素
- 重复2,3,4步骤，直到左边指针的值大于右边指针的值停止
- 代码实现
public class QuickSort {
/**
* 快速排序
*
* @param c
*/
public static void sort(Comparable[] c) {
int lo = 0;
int hi = c.length - 1;
sort(c, lo, hi);
}
/**
* 对数组c中，从索引lo到hi的元素进行排序
*
* @param c
* @param lo
* @param hi
*/
private static void sort(Comparable[] c, int lo, int hi) {
// 参数有效性检查
if (hi <= lo) {
return;
}
// 对数组c进行切分
int partition = partition(c, lo, hi);
// 分别对左右子数组排序
sort(c, lo, partition - 1);
sort(c, partition + 1, hi);
}
/**
* 对数组c中，从索引lo到hi的元素进行切分，并返回最后分组界限的索引值
*
* @param c
* @param lo
* @param hi
* @return
*/
private static int partition(Comparable[] c, int lo, int hi) {
// 确认临界值
Comparable key = c[lo];
// 定义左右指针；分别指向待切分索引的最小索引处和最大索引的下一处
int left = lo;
int right = hi + 1;
// 切分
while (true) {
// 从右向左扫描，移动right指针，找到一个比临界值小的元素，停止
while (less(key, c[--right])) {
if (right <= lo) {
break;
}
}
// 从左向右扫描，移动left指针，找到一个比临界值大的元素，停止
while (less(c[++left], key)) {
if (left >= hi) {
break;
}
}
// 判断 left >= right；如果是，扫描结束；如果不是，交换元素
if (left >= right) {
break;
} else {
exch(c, left, right);
}
}
// 交换分界值
exch(c, lo, right);
// 返回分界值索引
return right;
}
/**
* 判断c1是否小于c2
*
* @param c1
* @param c2
* @return
*/
private static boolean less(Comparable c1, Comparable c2) {
return c1.compareTo(c2) < 0;
}
/**
* 交换数组c中，索引i和j处的元素
*
* @param c
* @param i
* @param j
*/
private static void exch(Comparable[] c, int i, int j) {
Comparable temp = c[i];
c[i] = c[j];
c[j] = temp;
}
}
public class SortTest {
/**
* 快速排序
*/
@Test
public void testQuickSort(){
Integer[] c = {6, 1, 2, 7, 9, 3, 4, 5, 8};
System.out.println("排序前：" + Arrays.toString(c));
QuickSort.sort(c);
System.out.println("排序后：" + Arrays.toString(c));
}
}
排序前：[6, 1, 2, 7, 9, 3, 4, 5, 8]
排序后：[1, 2, 3, 4, 5, 6, 7, 8, 9]
-
快速排序和归并排序的区别
-
快速排序是另外一种分治的排序算法，它将一个数组分成两个子数组，将两部分独立的排序
-
快速排序和归并排序是互补的：
归并排序将数组分成两个子数组分别排序，并将有序的子数组归并从而将整个数组排序，而快速排序的方式则是当两个数组都有序时，整个数组自然就有序了。在归并排序中，一个数组被等分为两半，归并调用发生在处理整个数组之前
在快速排序中，切分数组的位置取决于数组的内容，递归调用发生在处理整个数组之后
-
-
时间复杂度分析
快速排序的一次切分从两头开始交替搜索，直到left和right 重合，因此，一次切分算法的时间复杂度为O(n)，但整个快速排序的时间复杂度和切分的次数相关。
最优情况：每一次切分选择的基准数字刚好将当前序列等分。
如果我们把数组的切分看做是一个树，那么上图就是它的最优情况的图示，共切分了logn次
所以，最优情况下，快速排序的时间复杂度为：O(n*logn) 对数阶
最坏情况：每一次切分选择的基准数字是当前序列中最大数或者最小数，这使得每次切分都会有一个子组，那么总
共就得切分n次，所以，最坏情况下，快速排序的时间复杂度为：O(n^2) 平方阶
平均情况：每一次切分选择的基准数字不是最大值和最小值， 也不是中值，这种情况我们也可以用数学归纳法证 明，快速排序的平均时间复杂度为：O(n*logn) （对数阶）
2.4、排序的稳定性
-
定义
数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保证 A元素依然在B元素的前面，可以说这个该算法是稳定的
简而言之：相等元素排序后，前后位置不变，即稳定
-
稳定性的意义
-
如果一组数据只需要一次排序，则稳定性一般是没有意义的
-
如果一组数据需要多次排序，稳定性是有意义的
例如：
要排序的内容是一组商品对象，第一次排序按照价格由低到高排序，第二次排序按照销量由高到低排序，如果第二次排序使用稳定性算法，就可以使得相同销量的对象依旧保持着价格高低的顺序展现，只有销量不同的对象才需要重新排序。这样既可以保持第一次排序的原有意义，且可以减少系统开销
第一次按照价格从低到高排序：
-
第二次按照销量进行从高到低排序：
- 常见排序算法比较
| 排序算法 | 稳定性 | 时间复杂度 | 性能 | 推荐 |
|---|---|---|---|---|
| 冒泡排序 | 稳定 | O(N^2) (平方阶) | 低 | 小数据量 |
| 选择排序 | 不稳定 | O(N^2) （平方阶） | 低 | 小数据量 |
| 插入排序 | 稳定 | O(N^2) （平方阶） | 低 | 小数据量 |
| 希尔排序 | 不稳定 | - | 高 | 大数据量；单次查询推荐用 |
| 归并排序 | 稳定 | O(n*logn) （对数阶） | 高 | 大数据量；多次查询推荐用 |
| 快速排序 | 不稳定 | O(n*logn) （对数阶） | 高 | 大数据量（可能栈溢出） |
- 冒泡排序：只有当arr[i]>arr[i+1]的时候，才会交换元素的位置，而相等的时候并不交换位置
- 选择排序：给每个位置选择当前元素最小的例如有数据 {5(1)，8 ，5(2)， 2， 9 }，第一遍选择到的最小元素为2，所以5(1)会和2进行交换位置，此时5(1)到了5(2)后面， 破坏了稳定性
- 插入排序：比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比较，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么把要插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序
- 希尔排序：按照不同步长对元素进行插入排序，虽然一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱
- 归并排序：在归并的过程中，只有arr[i]<arr[i+1]的时候才会交换位置，如果两个元素相等则不会交换位置，所以并不会破坏稳定性
- 快速排序：需要一个基准值，在基准值的右侧找一个比基准值小的元素，在基准值的左侧找一个比基准值大的元 素，然后交换这两个元素，此时会破坏稳定性
