主要排序方法

选择排序是指拿第一个数和后面的数进行比较，如果后面的数小于这个数，将两个数进行位置交换，依次进行比较从而得到排好序的数组。

实现代码如下：

public class SelectionSort {


    public static void main(String[] args) {
        int [] a={5,9,7,4,1,3,2,8};
        selects(a);
    }

    private static void selects(int[] a) {
        //i表示每轮最小元素交换的目标索引
        for (int i=0;i < a.length - 1;i++){
         //s表示最小值的索引,默认为i
            int s=i;
            //令j为其后面一个数
            for (int j=s+1;j<a.length;j++){
                //如果后面的数小与前面的数
                if (a[s]>a[j]){
                    //令最小值索引改为后面你那个数的索引
                    s=j;
                }
            }
            //若最小值索引和i不相等，交换两个数的位置
            if (s!=i){
                swap(a,s,i);
            }
            System.out.println(Arrays.toString(a));
        }
    }
    private static void swap(int[] a, int i, int j) {
        int t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
}

选择排序和冒泡排序的比较：选择排序在一般情况下比冒泡排序的速度快（前提是数组元素是没有顺序的），但是冒泡排序比较稳定，选择排序不稳定

快速排序

1.1单边快速排序（i，j都从左边开始，i找大于边界值的，j找小于边界值的然后找到之后进行交换，pv在最右边）

public class quicksort {
    public static void main(String[] args) {
        int a[]={5,3,7,2,9,8,1,4};
        quick(a,0,a.length-1);
    }
    private static void quick(int[] a, int l, int h) {
        if (l>=h){
            return;
        }
        int p=parttion(a, l, h);//定义索引值
        quick(a,l,p-1);//左
        quick(a,p+1,h);

    }
    private static int parttion(int[] a, int l, int h) {
        //定义左右边界
        int pv=a[h];
        int i=l;
        for (int j=l;j<h;j++){
            if (a[j]<pv){
                swap(a,i,j);
                i++;
            }
        }
        swap(a,h,i);
        //返回值代表下一个边界值，用于下一轮遍历
        System.out.println(Arrays.toString(a));
        return i;
    }
    private static void swap(int[] a, int i, int j) {
        int t=a[i];
        a[i]=a[j];
        a[j]=t;
    }


}

1.2双边快速排序（边界值在最左边，i从左边出发，j从右边出发，i找大于边界值的，j找小于边界值的，之后两者进行交换）

public class quicksort2{
    public static void main(String[] args) {
        int a[]={5,3,7,2,9,8,1,4};
        quick(a,0,a.length-1);
    }
    private static void quick(int[] a, int l, int h) {
        if (l>=h){
            return;
        }
        int p=parttion(a, l, h);//定义索引值
        quick(a,l,p-1);//左
        quick(a,p+1,h);

    }
    private static int parttion(int[] a, int l, int h) {
       int pv=a[l];
       int i=l;
       int j=h;
       while (i<j){
           //j找比边界值大的元素，i找比边界值小的元素，找到之后进行交换
           while (a[j]>pv && i<j)
           {
               j--;
           }
           //如果找到大于pv的值，等着和j进行交换
           while (a[i]<=pv && i<j){
               i++;
           }
           swap(a,i,j);
       }
       swap(a,l,j);
        System.out.println(Arrays.toString(a));
       return j;
    }
    private static void swap(int[] a, int i, int j) {
        int t=a[i];
        a[i]=a[j];
        a[j]=t;
    }


}