java算法

排序–comparable接口

java提供了一个接口Comparable用来定义类的排序规则
eg:
1、定义一个学生类Student，具有年龄age和姓名username连个属性，并通过Comparable接口提供比较规则；
2、定义测试类Test,在测试类中定义测试方法Comparable getMax(Comparable c1,Comparable ca)完成测试

package com.arithmetic.sort;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

//1、定义一个学生类Student，具有年龄age和姓名username连个属性，并通过Comparable接口提供比较规则；
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class Student implements Comparable<Student>{

    private String username;
    private int age;

    @Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}

package com.arithmetic.test;

import com.arithmetic.sort.Student;

//2、定义测试类Test,在测试类中定义测试方法Comparable getMax(Comparable c1,Comparable ca)完成测试
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）冒泡排序

需求：
排序前：{4,5,6,3,2,1}
排序后：{1,2,3,4,5,6}

原理：
1、比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素位置。
2、对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值

package com.arithmetic.sort;

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++){//内层循环去交换数据，冒泡
//                比较索引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;
    }

}

package com.arithmetic.test;

import com.arithmetic.sort.Bubble;

import java.util.Arrays;

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));

    }

}

总结：
外层循环决定纵冒泡次数，内层循环去交换数据，冒泡
时间复杂度分析：
冒泡排序使用了双层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).

简单排序—（2）选择排序

原理：
1、每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引处的值为最小值，最后可以找到最小值所在的索引
2、交换第一个索引处和最小值所在的索引处的值

需求：
排序前：{4,6,8,7,9,2,10,1}
排序后：{1, 2, 4, 6, 7, 8, 9, 10}

package com.arithmetic.sort;

public class Selection {

    /*
     * 对数组a中的元素进行排序
     * */
    public static void sort(Comparable[] a){
        //选择排序是按照大小顺序来的，所以外层循环可以比总数小1，就是后的那个树是自然结果
       for(int i=0; i<=a.length -2;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;
    }

}

package com.arithmetic.test;

import com.arithmetic.sort.Selection;

import java.util.Arrays;

public class SelectTest {

    public static void main(String[] args) {

        Integer[] arr = {4,6,8,7,9,2,10,1};
        Selection.sort(arr);
        System.out.println(Arrays.toString(arr));

    }

}

总结：
选择排序，就是根据该索引值得排序值，如0索引按从小到大，内存循环就要找到最小的值放在0索引处，和冒泡不同的是冒泡是相邻间相比，把大的往后面冒泡，而选择是找出最大或最小的值放在相应的索引处（按照顺序），不用每比较一下，相邻间就交换位置
时间复杂度分析：
选择排序使用了双层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).

简单排序—（3）插入排序

原理:
1、把所有的元素分为两组，已经排序的和未排序的；
2、找到未排序的组中的第一个元素，向已经排序的组中进行插入；
3、倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位；

需求：
排序前：{4,3,2,10,12,1,5,6}
排序后：{1, 2, 3, 4, 5, 6, 10, 12}

package com.arithmetic.sort;

public class Insertion {

    /*
     * 对数组a中的元素进行排序
     * */
    public static void sort(Comparable[] a){

        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0 ; j--) {
//                比较索引j处的值和索引j-1处的值，如果索引j-1处的值比索引j处的值大，则交换数据，
//                如果不大,那么就找到合适的位置了,退出循环即可;
                if(greater(a[j-1],a[j])){
                    exch(a,j-1,j);
                }else {
                    break;
                }

            }

        }

    }

    /*
     * 比较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;
    }

}

package com.arithmetic.test;

import com.arithmetic.sort.Bubble;
import com.arithmetic.sort.Insertion;

import java.util.Arrays;

public class InsertionTest {

    public static void main(String[] args) {
        Integer[] arr = {4,3,2,10,12,1,5,6};

        Insertion.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

总结：
插入排序就和打牌放牌的操作类似，将第二个数和前面排好顺序的数比较，这里是从小到大，如果现在的比前面的小，就和前面的数换位置，直到比前面的数大，就退出内层循环（这里和冒泡相似，但是有退出循环条件）

时间复杂度：
插入排序使用了双层for循环，其中内层循环体是真正完成排序的代码，所以我们分析插入排序的时间复杂度，主要分析内层循环体执行次数即可。
最坏情况：
比较次数为：
(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）希尔排序

希尔排序是插入排序的一种，又称"缩小增量排序"，是插入排序算法的一种更高效的改进版本。
主要是通过分组降低时间复杂度
原理：
1、选定一个增长量h,按照增长量h作为数据分组的依据，对数据进行分组；
2、对分组的每一组数据完成插入排序；
3、减小增长量，最小减为1，重复第二步操作。

先对数据进行分组，在进行插入排序

需求：
排序前：{9,1,2,5,7,4,8,6,3,5}
排序后：{1, 2, 3, 4, 5, 5, 6, 7, 8, 9}

package com.arithmetic.sort;

public class Shell {

    /*
     * 对数组a中的元素进行排序
     * */
    public static void sort(Comparable[] a){

//        1、根据数组a的长度，确定增长量h的初始值
        int h = 1;
        while (h < a.length/2){
            h = 2 * h +1;
        }
//        2、希尔排序
        while (h >= 1){
//            排序
//            2.1找到待插入的元素
            for (int i = h; i < a.length; i++) {
                //            2.2把待插入的元素插入到有序数列中
                for (int j = i; j >=h ; j-=h) {

//                    待插入的元素是a[j],比较a[j]和a[j-h]
                    if(greater(a[j-h],a[j])){
//                        交换元素
                        exch(a,j-h,j);
                    }else {
//                        待插入元素已经找到了合适的位置，结束循环
                        break;
                    }

                }

            }
//            减小h的值
            h = h /2;
        }



    }

    /*
     * 比较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;
    }


}

package com.arithmetic.test;

import com.arithmetic.sort.Insertion;
import com.arithmetic.sort.Shell;

import java.util.Arrays;

public class ShellTest {

    public static void main(String[] args) {
        Integer[] arr = {9,1,2,5,7,4,8,6,3,5};

        Shell.sort(arr);
        System.out.println(Arrays.toString(arr));
    }


}

总结：根据增涨量分组，根据增涨量确定排序的索引间距，但是希尔排序中，增涨量h并没有固定的规则，有很多论文研究了各种不同的递增序列，但都无法证明某个序列是最好的

**时间复杂度分析：**希尔排序时间复杂度计算非常麻烦，我们使用时候分析法对希尔排序和插入排序做性能比较
reverse_arr.txt准备100000条数据：

package com.arithmetic.test;

import com.arithmetic.sort.Insertion;
import com.arithmetic.sort.Shell;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class SortCompare {

//    调用不同的测试方法，完成测试
    public static void main(String[] args) throws IOException {
//        1、创建一个ArrayList集合，保存读取出来的整数
        ArrayList<Integer> list = new ArrayList<>();
//        2、创建缓存读取流BufferedReader,读取数据，并存储到ArrayList中；
        System.out.println(SortCompare.class.getClassLoader()
                .getResourceAsStream("reverse_arr.txt"));
        System.out.println(SortCompare.class
                .getResourceAsStream("/reverse_arr.txt"));

        BufferedReader reader = new BufferedReader(
                new InputStreamReader(SortCompare.class.getClassLoader()
                        .getResourceAsStream("reverse_arr.txt")));
        String line = null;
        while ((line = reader.readLine()) != null){
//            line 是字符串，把Line成Integer,存储到集合中
            int i = Integer.parseInt(line);
            list.add(i);
        }
        reader.close();
//        3、把ArrayList集合转换成数组
        Integer[] a = new Integer[list.size()];
        list.toArray(a);
//        4、调用测试代码完成测试
        System.out.println("执行中...");
        testInsert(a);//插入
//        testShell(a);//希尔
        System.out.println("执行结束...");


    }

//    测试希尔排序
    public static void testShell(Integer[] a){

//        1、获取执行之前的时间
        long start = System.currentTimeMillis();
//        2、执行算法代码
        Shell.sort(a);
//        3、获取执行之后的时间
        long end = System.currentTimeMillis();
//        4、算出程序执行的时间并输出
        System.out.println("希尔排序执行的时间为："+(end - start)+"毫秒");

    }
//    测试插入排序
    public static void testInsert(Integer[] a){

    //        1、获取执行之前的时间
        long start = System.currentTimeMillis();
    //        2、执行算法代码
        Insertion.sort(a);
    //        3、获取执行之后的时间
        long end = System.currentTimeMillis();
    //        4、算出程序执行的时间并输出
        System.out.println("插入排序执行的时间为："+(end - start)+"毫秒");

    }


}

插入排序结果：18057毫秒

希尔排序结果：18毫秒

复杂排序—（2）归并排序

归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并；
原理：
1、尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，知道拆分后的每个子组的元素个数是1为止
2、将相邻的两个子组进行合并成一个有序的大组；
3、不断的重复步骤2，知道最终只有一个组为止。

需求：
排序前：{8,4,5,7,1,3,6,2}
排序后：{[1, 2, 3, 4, 5, 6, 7, 8]}

merge:






代码：

package com.arithmetic.sort;

public class Merge {

//    归并所需要的辅助数组
    private static Comparable[] assist;

    /*
    * 比较v元素是否小于w元素
    * */
    private static boolean less(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;
    }


    /*
     * 对数组a中的元素进行排序
     * */
    public static void sort(Comparable[] a){

//        1、初始化辅助数组assist;
        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){
//        做安全性校验，递归退出条件
        if(hi <= lo){
            return;
        }
//        对lo到hi之间的数据进行分为两个组,得到分组中间值mid
        int mid = lo + (hi - lo)/2;//  5,9 mid = 7
//        分别对每一组数据进行排序
        sort(a,lo,mid);
        sort(a,mid + 1,hi);
//          再把两个组中的数据进行归并
        merge(a,lo,mid,hi);

    }

    /*
    * 对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
    * */
    public static void merge(Comparable[] a, int lo,int mid, int hi){
//        定义三个指针
        int i = lo;
        int p1 = lo;
        int p2 = mid + 1;
//        System.out.println("p1 =" + p1 +"  p2="+p2);
//  1      遍历，移动p1指针和p2指针，比较对应索引处的值，找出小的那个，放到辅助数组的对应索引处
        while (p1 <= mid && p2 <= hi){
//            比较对应索引处的值
            if(less(a[p1],a[p2])){
                assist[i++] = a[p1++];//将较小的值存到辅助数组中并且索引值加一
            }else {
                assist[i++] = a[p2++];
            }
        }
//  2      遍历，如果p1的指针没有走完，那么顺序移动p1指针，把对应的元素放到辅助数组的对应索引处
        while (p1 <= mid){
            assist[i++] = a[p1++];
        }

//  3      遍历，如果p2的指针没有走完，那么顺序移动p2指针，把对应的元素放到辅助数组的对应索引处
        while (p2 <= hi){
            assist[i++] = a[p2++];
        }
//        把辅助数组中的元素拷贝到原数组中
        for (int index = lo; index <= hi ; index++) {
            a[index] = assist[index];
        }

    }



}

package com.arithmetic.test;

import com.arithmetic.sort.Merge;
import com.arithmetic.sort.Shell;

import java.util.Arrays;

public class MergeTest {

    public static void main(String[] args) {

        Integer[] arr = {8,4,5,7,1,3,6,2};

        Merge.sort(arr);
        System.out.println(Arrays.toString(arr));

    }

}

总结：
采用递归的思想分组并合并，主要sort方法分组(得到分组的索引值（三个值：初、中、末）)，merge方法进行合并，合并时主要有三种情况，1、两组都有数据比较，2、a组剩下元素都比b组大，3、b组剩下元素都比a组大

时间复杂度：

归并排序的缺点：
需要申请额外的数字空间，导致空间复杂度提示，是典型的以空间换时间的操作

事后算法对归并排序进行性能测试：

package com.arithmetic.test;

import com.arithmetic.sort.Insertion;
import com.arithmetic.sort.Merge;
import com.arithmetic.sort.Shell;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class SortCompare {

//    调用不同的测试方法，完成测试
    public static void main(String[] args) throws IOException {
//        1、创建一个ArrayList集合，保存读取出来的整数
        ArrayList<Integer> list = new ArrayList<>();
//        2、创建缓存读取流BufferedReader,读取数据，并存储到ArrayList中；
        System.out.println(SortCompare.class.getClassLoader()
                .getResourceAsStream("reverse_arr.txt"));
        System.out.println(SortCompare.class
                .getResourceAsStream("/reverse_arr.txt"));

        BufferedReader reader = new BufferedReader(
                new InputStreamReader(SortCompare.class.getClassLoader()
                        .getResourceAsStream("reverse_arr.txt")));
        String line = null;
        while ((line = reader.readLine()) != null){
//            line 是字符串，把Line成Integer,存储到集合中
            int i = Integer.parseInt(line);
            list.add(i);
        }
        reader.close();
//        3、把ArrayList集合转换成数组
        Integer[] a = new Integer[list.size()];
        list.toArray(a);
//        4、调用测试代码完成测试
        System.out.println("执行中...");
//        testInsert(a);//插入
//        testShell(a);//希尔
        testMerge(a);//
        System.out.println("执行结束...");


    }

//    测试希尔排序
    public static void testShell(Integer[] a){

//        1、获取执行之前的时间
        long start = System.currentTimeMillis();
//        2、执行算法代码
        Shell.sort(a);
//        3、获取执行之后的时间
        long end = System.currentTimeMillis();
//        4、算出程序执行的时间并输出
        System.out.println("希尔排序执行的时间为："+(end - start)+"毫秒");

    }
//    测试插入排序
    public static void testInsert(Integer[] a){

    //        1、获取执行之前的时间
        long start = System.currentTimeMillis();
    //        2、执行算法代码
        Insertion.sort(a);
    //        3、获取执行之后的时间
        long end = System.currentTimeMillis();
    //        4、算出程序执行的时间并输出
        System.out.println("插入排序执行的时间为："+(end - start)+"毫秒");

    }

//    测试归并排序
public static void testMerge(Integer[] a){

    //        1、获取执行之前的时间
    long start = System.currentTimeMillis();
    //        2、执行算法代码
    Merge.sort(a);
    //        3、获取执行之后的时间
    long end = System.currentTimeMillis();
    //        4、算出程序执行的时间并输出
    System.out.println("归并排序执行的时间为："+(end - start)+"毫秒");

}


}

复杂排序—（3）快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按照此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

原理：
1、首先设定一个分界值，通过该分界值将数组分成左右两部分；
2、将大于或等于分界值得数据放到数组右边，小于分界值得数据放到数组的左边。次数左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
3、然后，左边和右边的数据可以独立排序。对于左侧的数组数据，有可以取一个分界值，将该部分数据分成左右两部分，同样在左边放在较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4、重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，在递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

需求：
排序前：{6,1,2,7,9,3,4,5,8}
排序后：{[1, 2, 3, 4, 5, 6, 7, 8, 9]}

package com.arithmetic.sort;

public class Quick {

    /*
     * 比较v元素是否小于w元素
     * */
    private static boolean less(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 static void sort(Comparable[] a){
        int lo = 0;
        int hi = a.length - 1;
        sort(a,lo,hi);
    }

    /*
     * 对数组a中索引从Lo到hi的元素进行排序,递归调用（从最开始反回数据开始理解思路）
     * */
    private static void sort(Comparable[] a,int lo,int hi){
//        做安全性校验，递归退出条件
        if(hi <= lo){
            return;
        }

//        需要对数组中lo索引到hi处的元素进行分组（左子组和右子组）；
        //返回的是分组的分界值所在的索引，分界值位置变换后的索引
        int partition = partition(a, lo, hi);
//        让左子组有序
        sort(a,lo,partition -1);
//        让右子组有序
        sort(a,partition+1,hi);



    }

    /*
     * 对数组a中，从索引lo到hi之间的元素进行分组，并返回分组界限对应的索引
     * */
    public static int partition(Comparable[] a,int lo,int hi){

//      确定分界值
        Comparable key = a[lo];
//      定义两个指针，分别指向待切分元素的最小索引处和最大索引处的下一个位置
        int left = lo;
        int right = hi + 1;
//      切分
        while (true){
            //先从右往左扫描，移动right指针，找打一个比分界值小的元素，停止
            while (less(key,a[--right])){
                if(right == lo){
                    break;
                }
            }
//            再从左往右扫描，移动left指针，找到一个比分界值大的元素，停止
            while (less(a[++left],key)){
                if(left == hi){
                    break;
                }
            }
//            判断left >= right,如果是，则证明元素扫描完毕，结束循环，如果不是，则交换元素即可
            if(left >= right){
                break;
            }else {
                exch(a,left,right);
            }

        }

//      交换分界值
        exch(a,lo,right);

        return right;

    }

}

package com.arithmetic.test;

import com.arithmetic.sort.Merge;
import com.arithmetic.sort.Quick;

import java.util.Arrays;

public class QuickTest {

    public static void main(String[] args) {
        Integer[] arr = {6,1,2,7,9,3,4,5,8};

        Quick.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

总结：主要是从右往左扫描，和从左往右扫描所有值，找到比分界值大和分界值小的，然后对找到的索引进行交换，小的在左边，大的在右边！然后进行递归！

排序稳定性

稳定性的定义：
数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保证A元素依然在B元素的前面，可以说这个该算法是稳定的。

常见排序算法的稳定性

**稳定：冒泡、插入、归并 **
不稳定：选择、希尔、快速