一、简单排序
1.1 Comparable接口介绍
在元素之间进行比较，而Java提供了一个接口Comparable就是用来定义排序规则的，在这里我们以案例的形式对Comparable接口做一个简单的回顾。（同时记住Comparator对应的定制排序方法）
**需求：**1.定义一个学生类Student，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则；
2.定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)完成测试
下面展示一些 定义一个学生类Student。
//1.定义一个学生类Student，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则；
public class Student implements Comparable<Student>{
private String username;
private 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();
}
}
下面展示一些 定义Comparable测试类。
//2.定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)完成测试
public class TestComparable {
public static void main(String[] args) {
//创建两个Student对象，并调用getMax方法，完成测试
Student s1 = new Student();
s1.setUsername("张三");
s1.setAge(18);
Student s2 = new Student();
s2.setUsername("李四");
s2.setAge(20);
Comparable max = getMax(s1, s2);
System.out.println(max);
}
public static Comparable getMax(Comparable c1,Comparable c2){
int result = c1.compareTo(c2);
//如果result<0,则c1比c2小；
//如果result>0，则c1比c2大；
//如果result==0,则c1和c2一样大；
if (result>=0){
return c1;
}else{
return c2;
}
}
}
1.2 冒泡排序
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
排序原理：
- 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
- 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
需求：
排序前：{4,5,6,3,2,1}
排序后：{1,2,3,4,5,6}
冒泡排序API设计：
下面展示一些 冒泡排序代码实现O(n^2)。
public class Bubble {
/*
对数组a中的元素进行排序
*/
public static void sort(Comparable[] a){
for(int i=a.length-1;i>0;i--){
for(int j=0;j<i;j++){
//{6,5,4,3,2,1}
//比较索引j和索引j+1处的值
if (greater(a[j],a[j+1])){
exch(a,j,j+1);
}
}
}
}
/*
比较v元素是否大于w元素
*/
private static boolean greater(Comparable v,Comparable w){
return v.compareTo(w)>0;
}
/*
数组元素i和j交换位置
*/
private static void exch(Comparable[] a,int i,int j){
Comparable temp;
temp = a[i];
a[i]=a[j];
a[j]=temp;
}
}
下面展示一些 冒泡排序测试。
public class BubbleTest {
public static void main(String[] args) {
Integer[] arr = {4,5,6,3,2,1};
Bubble.sort(arr);
System.out.println(Arrays.toString(arr));//{1,2,3,4,5,6}
}
}
下面展示一些 冒泡排序的数组实现方式。
public static void main(String[] args) {
int[] arr = new int[]{4,5,6,3,2,1};
//冒泡排序
for(int i = 0;i < arr.length - 1;i++){
for (int j = 0;j < arr.length - i - 1;j++){
if (arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
}
1.3 选择排序
选择排序是一种更加简单直观的排序方法。
排序原理：
1.每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引
2.交换第一个索引处和最小值所在的索引处的值
选择排序API设计：
需求：
排序前：{4,6,8,7,9,2,10,1}
排序后：{1,2,4,5,7,8,9,10}
下面展示一些 快速排序的实现O（n^2）。
public class Selection {
/*
对数组a中的元素进行排序
*/
public static void sort(Comparable[] a){
for(int i=0;i<a.length -1;i++){
//定义一个变量，记录最小元素所在的索引，默认为参与选择排序的第一个元素所在的位置
int minIndex = i;
for(int j=i+1;j<a.length;j++){
//需要比较最小索引minIndex处的值和j索引处的值；
if (greater(a[minIndex],a[j])){
minIndex=j;
}
}
//交换最小元素所在索引minIndex处的值和索引i处的值
exch(a,i,minIndex);
}
}
/*
比较v元素是否大于w元素
*/
private static boolean greater(Comparable v,Comparable w){
return v.compareTo(w)>0;
}
/*
数组元素i和j交换位置
*/
private static void exch(Comparable[] a,int i,int j){
Comparable temp;
temp = a[i];
a[i]=a[j];
a[j]=temp;
}
}
下面展示一些 快速排序代码测试。
public class SelectionTest {
public static void main(String[] args) {
//原始数据
Integer[] a = {4,6,8,7,9,2,10,1};
Selection.sort(a);
System.out.println(Arrays.toString(a));//{1,2,4,5,7,8,9,10}
}
}
1.4 插入排序
插入排序（Insertion sort）是一种简单直观且稳定的排序算法。
排序原理：
1.把所有的元素分为两组，已经排序的和未排序的；
2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；
3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位；
插入排序API设计：
下面展示一些 插入排序代码实现，时间复杂度O(n^2）。
/*
1.把所有的元素分为两组，已经排序的和未排序的；
2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；
3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待
插入元素放到这个位置，其他的元素向后移动一位；
*/
public class InsertionSort {
/*
对数组a中的元素进行排序
*/
public static void sort(Comparable[] a){
for (int i = 1; i < a.length; i++) {
//当前元素为a[i]，依次和i前面的元素进行比较，找到小于a[i]的元素
for (int j = i; j > 0; j--) {
if (greater(a[j - 1],a[j])){
exch(a,j - 1,j);
}else {
//找到了该元素，则结束循环
break;
}
}
}
}
/*
比较a元素是否大于b元素
*/
private static boolean greater(Comparable a, Comparable b){
return a.compareTo(b) > 0;
}
/*
数组元素a和b交换位置
*/
private static void exch(Comparable[] a, int i,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
下面展示一些 插入排序的测试。
public class InsertionTest {
public static void main(String[] args) {
Integer[] array = {4,3,2,10,12,1,5,6};
InsertionSort.sort(array);
System.out.println(Arrays.toString(array));
}
}
二、高级排序
基础排序，包括冒泡排序，选择排序还有插入排序，并且对他们在最坏情况下的时间复杂度做了分
析，发现都是O(N^2)，而平方阶通过我们之前学习算法分析我们知道，随着输入规模的增大，时间成本将急剧上升，所以这些基本排序方法不能处理更大规模的问题，接下来我们学习一些高级的排序算法，争取降低算法的时间复杂度最高阶次幂。
2.1希尔排序
希尔排序是插入排序的一种，又称“缩小增量排序”，是插入排序算法的一种更高效的改进版本。
排序原理：
1.选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
2.对分好组的每一组数据完成插入排序；
3.减小增长量，最小减为1，重复第二步操作。
增长量h的确定
增长量h的值每一固定的规则，我们这里采用以下规则：
下面展示一些 增长量h的确定。
int h=1
while(h<5){
h=2h+1；//3,7
}
//循环结束后我们就可以确定h的最大值；
h的减小规则为：
h=h/2
希尔排序的API设计：
下面展示一些 希尔排序的代码实现。
/*
1.选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
2.对分好组的每一组数据完成插入排序；
3.减小增长量，最小减为1，重复第二步操作。
*/
public class ShellSort {
/*
对数组a中的元素进行排序
*/
public static void sort(Comparable[] a){
int N = a.length;
int h = 1;
//确定h的最大值
while (h < N/2){
h = 2 * h + 1;
}
//当增量h小于1时，排序结束
while (h >= 1){
//找到待插入的元素
for (int i = h; i < N; i++) {
//a[i]就是待插入的元素
//需要把a[i]插入到a[i - h],a[i - 2h].....之中
for (int j = i; j >= h ; j-=h) {
//此时的待插入元素就是a[j],需要将它与a[j - h],a[j - 2h]....进行比较，如果a[j]小，那么就要交换位置，反之不需要交换
if (greater(a[j - h],a[j])){
exch(a,j - h,j);
}else {
break;
}
}
}
h /=2;
}
}
/*
比较a元素是否大于b元素
*/
private static boolean greater(Comparable a, Comparable b){
return a.compareTo(b) > 0;
}
/*
数组元素a和b交换位置
*/
private static void exch(Comparable[] a, int i,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
下面展示一些 希尔排序的代码实现测试。
public class ShellTest {
public static void main(String[] args) {
Integer[] array = {9,1,2,5,7,4,8,6,3,5};
ShellSort.sort(array);
System.out.println(Arrays.toString(array));
}
}
希尔排序的时间复杂度分析
对于希尔排序的时间复杂度分析，在网上有多种版本，由于其中涵盖的数学原理只是较为复杂繁琐，为了便于理解，采用事后分析法与插入排序来进行比较来对其进行性能评估。在这里要使用到测试数据reverse_arr.txt文件，里面存放的是从100000到1的逆向数据，根据这个批量数据完成测试。文件百度云盘链接： 链接：https://pan.baidu.com/s/128RPUDuWuqMd5spBOfv5Nw
提取码：1234.
下面展示一些 希尔排序和其它排序性能比较测试代码。
public class PerformanceTest {
//调用不同的测试方法完成测试
public static void main(String[] args) throws Exception {
//1.创建一个ArrayList集合,保存读取出来的整数
ArrayList<Integer> arrayList = new ArrayList<>();
//创建缓存读取流BufferedReader，读取数据，并存储ArrayList
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(new File("reverse_arr.txt"))));
String line = null;
while ((line = bufferedReader.readLine()) != null){
//line是字符串，把line转换成Integer.存储到集合中
int i = Integer.parseInt(line);
arrayList.add(i);
}
//关闭I/O流
bufferedReader.close();
//3.把ArrayList集合转换成数组
Integer[] a = new Integer[arrayList.size()];
arrayList.toArray(a);
//4.调用测试代码完成测试
// testBubble(a);//46984秒!
// testInsertion(a);//9秒!
// testMerge(a);//101秒!
//testQuick(a);
testSelection(a);//13600秒!
}
//冒牌排序
public static void testBubble(Integer[] a) {
//1.获取之行前的时间
long start = System.currentTimeMillis();
//2.执行算法代码
BubbleSort.sort(a);
//3.获取之行后的时间
long end = System.currentTimeMillis();
System.out.println("冒泡排序所耗费的时间是：" + (end - start) + "秒！");
}
//插入排序
public static void testInsertion(Integer[] a) {
//1.获取之行前的时间
long start = System.currentTimeMillis();
//2.执行算法代码
InsertionSort.sort(a);
//3.获取之行后的时间
long end = System.currentTimeMillis();
System.out.println("插入排序所耗费的时间是：" + (end - start) + "秒！");
}
//选择排序
public static void testSelection(Integer[] a) {
//1.获取之行前的时间
long start = System.currentTimeMillis();
//2.执行算法代码
SelectionSort.sort(a);
//3.获取之行后的时间
long end = System.currentTimeMillis();
System.out.println("选择排序所耗费的时间是：" + (end - start) + "秒！");
}
//归并排序
public static void testMerge(Integer[] a) {
//1.获取之行前的时间
long start = System.currentTimeMillis();
//2.执行算法代码
MergeSort.sort(a);
//3.获取之行后的时间
long end = System.currentTimeMillis();
System.out.println("归并排序所耗费的时间是：" + (end - start) + "秒！");
}
//快速排序
public static void testQuick(Integer[] a) {
//1.获取之行前的时间
long start = System.currentTimeMillis();
//2.执行算法代码
QuickSort.sort(a);
//3.获取之行后的时间
long end = System.currentTimeMillis();
System.out.println("快速排序所耗费的时间是：" + (end - start) + "秒！");
}
}
由代码的比较测试可以发现，在处理大批量数据时，希尔排序的效率远远高于插入排序。
2.2 归并排序
2.2.1 递归
定义：定义方法时，在方法内部调用方法本身，称之为递归.
作用：它通常把一个大型复杂的问题，层层转换为一个与原问题相似的，规模较小的问题来求解。递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
注意事项：在递归中，不能无限制的调用自己，必须要有边界条件，能够让递归结束，因为每一次递归调用都会在栈内存开辟新的空间，重新执行方法，如果递归的层级太深，很容易造成栈内存溢出。
需求：请定义一个方法，使用递归完成求N的阶乘；
下面展示一些 使用递归完成求N的阶乘。
// A code block
var foo = 'bar';
// An highlighted block
var foo = 'bar';
2.2.2 归并排序
归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
排序原理：
1.尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。
2.将相邻的两个子组进行合并成一个有序的大组；
3.不断的重复步骤2，直到最终只有一个组为止。
归并排序API设计：
下面展示一些 归并排序代码实现，时间复杂度O(nlogn)。
/*
1.尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是
1为止。
2.将相邻的两个子组进行合并成一个有序的大组；
3.不断的重复步骤2，直到最终只有一个组为止。
*/
public class MergeSort {
/*
归并所需要的辅助数据
*/
private static Comparable[] assist;
/*
对数组a中的元素进行排序(利用递归对自己进行调用)
*/
public static void sort(Comparable[] a){
//1.初始化辅助数组
assist = new Comparable[a.length];//定义最后排序好的数组长度与原数组长度一致
//2.定义一个lo变量和hi变量，分别记录数组中的最大索引和最小索引
int lo = 0;
int hi = a.length - 1;
//3.调用sort重载方法完成数组a中，从索引lo到hi之间的元素排序
sort(a,lo,hi);
}
/*
对数组a中从索引lo到索引hi之间的元素进行排序
*/
private static void sort(Comparable[] a,int lo,int hi){
//假设数组长度为0，就没有排序的必要（安全检验）
if (hi <= lo){
return;
}
int mid = (lo + hi) / 2;
//对索引lo到索引mid之间的元素进行排序
sort(a, lo, mid);
//对索引mid + 1到hi之间的元素进行排序
sort(a, mid + 1, hi);
//利用merge对lo以上两个子组进行归并
merge(a,lo, mid,hi);
}
/*
从索引lo到到索引mid为一个子组，从索引mid+1到索引hi为另一个子组，
把数组a中的这两个子组的数据合并成一个有序的大组（从索引lo到hi）
*/
private static void merge(Comparable[] a,int lo,int mid,int hi){
//将lo到mid以及mid+1到hi两组数据归并到辅助数组assist对应的索引
int i = lo;//定义一个指针，指向assist数组中开始填充数据的索引中
int p1 = lo;//定义指针，指向第一组数据的第一个元素
int p2 = mid + 1;//定义一个指针，指针指向第二组数据的第一个元素
//比较左边和右边子组的元素大小，那个小就把那个数据填充到assist数组中
while (p1 <= mid && p2 <= hi){
if (less(a[p1],a[p2])){
assist[i++] = a[p1++];
}else {
assist[i++] = a[p2++];
}
}
//上面的循环结束后，如果p1 <= mid && p2 <= hi中有一个条件不满足,则表示左边小组或者右边小组归并完毕
//将未填充完毕的数据继续填充到assist中，根据左右子组的规避情况进行以下循环的执行
while (p1 <= mid){
assist[i++] = a[p1++];
}
while (p2 <= hi){
assist[i++] = a[p2++];
}
//到现在为止，assit辅助数组中从lo到hi的元素都是有序的，在把数据拷贝到a数组中对应的索引处
for (int index = lo; index <= hi; index++) {
a[index] = assist[index];
}
}
/*
比较a元素是否大于b元素
*/
private static boolean less(Comparable a, Comparable b){
return a.compareTo(b) < 0;
}
/*
数组元素a和b交换位置
*/
private static void exch(Comparable[] a, int i,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
下面展示一些 归并排序代码实现测试。
public class MergeTest {
public static void main(String[] args) {
Integer[] array = {4, 6, 8, 7, 9, 2, 10, 1,12};
MergeSort.sort(array);
System.out.println(Arrays.toString(array));
}
}
归并排序时间复杂度分析：
归并排序是分治思想的最典型的例子，上面的算法中，对a[lo…hi]进行排序，先将它分为a[lo…mid]和a[mid+1…hi]两部分，分别通过递归调用将他们单独排序，最后将有序的子数组归并为最终的排序结果。该递归的出口在于如果一个数组不能再被分为两个子数组，那么就会执行merge进行归并，在归并的时候判断元素的大小进行排序。
假设元素的个数为n，那么使用归并排序拆分的次数为log2(n),所以共log2(n)层，最终得出的归并排序的时间复杂度为：log2(n)* 2^(log2(n))=log2(n)*n,根据大O推导法则，忽略底数，最终归并排序的时间复杂度为O(nlogn);
归并排序与希尔排序的性能比较：类同希尔排序的性能比较
下面展示一些 归并排序与希尔排序的性能比较。
// A code block
var foo = 'bar';
// An highlighted block
var foo = 'bar';
归并排序的缺点：
由于在调用归并排序的算法时，需要申请额外的数组空间assist，导致空间复杂度提升，是典型的以空间换时间的操作。在Java的程序开发中可以忽略这个问题，但是在嵌入式开发的过程中，归并排序算法要慎重使用。
2.3 快速排序
快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
排序原理：
1.首先设定一个分界值，通过该分界值将数组分成左右两部分；
2.将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
3.然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4.重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
快速排序API设计:
切分原理：
把一个数组切分成两个子数组的基本思想：
1.找一个基准值，用两个指针分别指向数组的头部和尾部；
2.先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置；
3.再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；
4.交换当前左边指针位置和右边指针位置的元素；
5.重复2,3,4步骤，直到左边指针的值大于右边指针的值停止。
下面展示一些 快速排序代码实现。
/*
1.首先设定一个分界值，通过该分界值将数组分成左右两部分；
2.将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于
或等于分界值，而右边部分中各元素都大于或等于分界值；
*/
public class QuickSort {
/*
比较a元素是否大于b元素
*/
private static boolean less(Comparable a, Comparable b){
return a.compareTo(b) < 0;
}
/*
数组元素a和b交换位置
*/
private static void exch(Comparable[] a, int i,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
/*
对数组a中的元素进行排序
*/
public static void sort(Comparable[] a){
int lo = 0;
int hi = a.length - 1;
sort(a,lo,hi);
}
private static void sort(Comparable[] a,int lo,int hi){
//对数组进行检验
if (hi <= lo){
return;
}
//对数组a从lo到hi进行切分
//需要对数组中lo索引到hi索引处的元素进行分组
int partition = partition(a, lo, hi);
//对左子祖进行排序
sort(a,lo,partition - 1);
//对右子组进行排序
sort(a,partition + 1,hi);
}
//对数组a中,从索引lo到
public static int partition(Comparable[] a,int lo,int hi){
Comparable key = a[lo];//将索引为0的元素当做基准值
int left = lo;//定义一个左侧指针,初始指针指向最左边元素
int right = hi + 1;//定义一个右侧指针,初始指针指向最右边元素向右一位
//切分
while (true){
//从先右往左扫描,找到一个比基准值小的值
while (less(key,a[--right])){
if (right == lo){
break;
}
}
//再从左往右扫描,找到一个比基准值大的值
while (less(a[++left],key)){
if (left == hi){
break;
}
}
if (left >= right){
break;//扫描结束
}else {
//交换left和right索引处的元素
exch(a,right,left);
}
}
//交换最后由rirht指针索引处和基准值所在的索引处的值
exch(a,lo,right);
return right;//返回right此为切分的索引值界限
}
}
下面展示一些 快速排序代码实现测试。
public class QuickTest {
public static void main(String[] args) {
Integer[] array = {4, 6, 8, 7, 9, 2, 10, 1,12,10};
QuickSort.sort(array);
System.out.println(Arrays.toString(array));
}
}
快速排序时间复杂度分析：
快速排序的一次切分从两头开始交替搜索，直到left和right重合，因此，一次切分算法的时间复杂度为O(n),但整个快速排序的时间复杂度和切分的次数相关。
最优情况：每一次切分选择的基准数字刚好将当前序列等分，最优情况下快速排序的时间复杂度为O(nlogn);
最坏情况：每一次切分选择的基准数字是当前序列中最大数或者最小数，这使得每次切分都会有一个子组，那么总共就得切分n次，所以，最坏情况下，快速排序的时间复杂度为O(n^2);
快速排序和归并排序的异同：
快速排序是另外一种分治的排序算法，它将一个数组分成两个子数组，将两部分独立的排序。快速排序和归并排序是互补的：归并排序将数组分成两个子数组分别排序，并将有序的子数组归并从而将整个数组排序，而快速排序的方式则是当两个数组都有序时，整个数组自然就有序了。在归并排序中，一个数组被等分为两半，归并调用发生在处理整个数组之前，在快速排序中，切分数组的位置取决于数组的内容，递归调用发生在处理整个数组之后。
2.4 排序的稳定性
稳定性的定义：
数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保证A元素依然在B元素的前面，可以说这个该算法是稳定的。
稳定性的意义：
如果一组数据只需要一次排序，则稳定性一般是没有意义的，如果一组数据需要多次排序，稳定性是有意义的。例如要排序的内容是一组商品对象，第一次排序按照价格由低到高排序，第二次排序按照销量由高到低排序，如果第二次排序使用稳定性算法，就可以使得相同销量的对象依旧保持着价格高低的顺序展现，只有销量不同的对象才需要重新排序。这样既可以保持第一次排序的原有意义，而且可以减少系统开销。
常见排序算法的稳定性：
冒泡排序：
只有当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]的时候才会交换位置，如果两个元素相等则不会交换位置，所以它并不会破坏稳定性，归并排序是稳定的。
快速排序：
快速排序需要一个基准值，在基准值的右侧找一个比基准值小的元素，在基准值的左侧找一个比基准值大的元素，然后交换这两个元素，此时会破坏稳定性，所以快速排序是一种不稳定的算法。
498
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
