经典排序算法（正在更新）

交换排序

冒泡排序

比较相邻的两个数
越小（大）的元素会经由交换慢慢“浮”到数列的顶端。

代码：

public class Test {
    public static void main(String[] args) {
        int[] a={5, 8, 6, 3, 9, 2, 1, 7};
        int len=a.length-1;
        for (int i = 0; i < len; i++) {
            for (int j = 0; j <len-i; j++) {
                if(a[j]>a[j+1]){//这里不会跳出循环是因为上面j的范围没有取<=，而是取的<
                   int temp=a[j];
                   a[j]=a[j+1];
                   a[j+1]=temp;
                }
            }
        }
        print(a);
    }
    static void print(int a[]){
        for (int z = 0; z< a.length; z++) {
            System.out.println(a[z]);
        }
    }

}

改进冒泡排序：如果在某次移动过程中，这个数组中的数据已经是有序的了，就不需要再进行下面的操作了，此时就可以直接跳出循环了
代码：

public class Test {
    public static void main(String[] args) {
        int[] a={5, 8, 6, 3, 9, 2, 1, 7};
        int len=a.length-1;
        for (int i = 0; i < len; i++) {
            boolean isSorted =true;//他的作用是，移动过程中，前面的序列已经有序了，但是每次还都要给她比较
            for (int j = 0; j <len-i; j++) {
                if(a[j]>a[j+1]){
                   int temp=a[j];
                   a[j]=a[j+1];
                   a[j+1]=temp;
                    isSorted =false;
                }

            }
            if(isSorted ){
                break;
            }
        }
        print(a);
    }

    static void print(int a[]){
        for (int z = 0; z< a.length; z++) {
            System.out.println(a[z]);
        }
    }

}

但是如果我们在循环过程中，有后面个元素已经有序了，我们是否可以跳过他们？
代码：

public class TestPlus {
    public static void main(String[] args) {
        int[] a={6,3,7,4,5,1,2};
        int len=a.length-1;
        int lastExchangeIndex=0;//这是用来确认他最后改的位置在哪里
        int sortBorder=len;//这个用来限制j的范围的
        for (int i = 0; i <len ; i++) {
            boolean isSorted=true;
            for (int j = 0; j < sortBorder; j++) {
                if(a[j]>a[j+1]){//这里不会越界的原因就是因为j没有取<=，
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                    isSorted =false;
                    lastExchangeIndex=j;
                }
            }
            sortBorder = lastExchangeIndex;
            if(isSorted) break;
        }
        print(a);
    }
    static void print(int a[]){
        for (int z = 0; z< a.length; z++) {
            System.out.println(a[z]);
        }
    }
}

快速排序

快速排序是冒泡排序改进而得的，冒泡排序：只对相邻的两个记录进行一次交换，每次交换两个相邻记录时只能消除一个逆序
如果能通过两个（不相邻）记录的一次交换，消除多个逆序，则会大大加快排序的速度
原理，找一个数当为基准数，一般是第一个，然后用这个数和后面的数进行比较，若后面的数大于这个基准数，则high指针往前移，和倒数第二个比较，直到找到小于基准数的，此时用基准书和前面的数进行比较，若前面的数小于基准数，则low指针后移，直到找到大于基准数的，此时将后面的数和前面的数交换位置，以此类推，直到low和high重合，此时第一次循环结束，最后将基准数放到他们共同指的位置，之后运用递归，直到low>high(递归的结束条件)。
这里需要注意的一点是，如果我们将第一个数当为基准数，此时一定要先比较后面的数再比较前面的数
参考链接：
快速排序为何先要从右向左查找的原因
代码：

public class Test {
    public static void main(String[] args) {
      int[] a={5, 8, 6, 3, 9, 2, 1, 7};
        Sort(a,0,a.length-1);
        print(a);

    }

     public static void Sort(int[] a,int left,int right ){
         if(left > right) {//这步还不能省，省的话会报数组越界
             return;
                }
        int base=a[left];
        int i=left,j=right;
        while (i!=j){
            while(a[j]>=base&&i<j){ --j;}//这里的等号可以不加，他用来决定"稳定性"
            while(a[i]<=base&&i<j){ i++;}//这里的等号也必须加，不加不生效

            if(i<j){
                int temp=a[i];
                a[i]=a[j];
                a[j]=temp;
            }
        }
        a[left]=a[i];//将“中间”的数给放到a[0]
        a[i]=base;//这步是归位

         Sort(a,left,i-1);//下一次遍历左边的这个集合
         Sort(a,i+1,right);//左边全部有序过后再遍历右边的集合


    }
    public static void print(int[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}

插入排序

直接插入排序

折半插入排序

希尔排序