数组的四种排序方式

在介绍这四种排序方法之前，我们先介绍一下Swap（a,i,j）互换函数的一种比较简洁的写法

 /*
    * 交换函数
    * 异或写法
    * */
    private  static  void swap(int[] a,int i,int j){
        /*
        * 分析：当下标i==j时，a[i]和a[j]就都指向了同一个内存块，即a[i]=a[j]。
        * 当程序第一次执行a[i] ^=a[j]时，就会使a[i]的值为0，a[i]一旦为0的话，a[2]也会变为0。
        * 所以下面的程序 a[j] ^=a[i]; a[i] ^=a[j];在执行的时候始终是a[1]=a[2]=0,这样就会导致
        * 在排序的过程中两个相同的值在执行swap（）函数后就会变为0.
        * 如：对{1，2，3，2，4，5}进行升序排序，排序后{0，0，1，3，4，5}
        *  所以通过使用if (i==j){return ;}语句来解决这个问题
        *
        * */
           if (i==j){
               return;
           }
            a[i] ^=a[j];
            a[j] ^=a[i];
            a[i] ^=a[j];
    }

1.选择排序：

 /*
    * 选择排序
    *
    * */
    private  static void sort(int[] a){
        for (int i = 0; i < a.length-1; i++) {
            int min=i;
            for (int j = i+1; j <a.length ; j++) {
                if (a[min]>a[j]){
                    min=j;
                }
            }
            if(min != i){
                swap(a,i,min);
            }
        }
    }

2.插入排序

 /*
    * 插入排序
    * */
    private static  void sort02(int[] a){
        for (int i = 1; i < a.length; i++) {
            for (int j = i-1;j >=0; j--) {
                if (a[j+1] < a[j]) {
                    swap(a,j+1,j);
                }else{
                    break;
                }
            }

        }

    }

3.冒泡排序

 /*
    * 冒泡排序
    *
    * */
    private static void sort03(int[] a){
        for (int i = a.length-1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (a[j] >a[j+1]) {
                    swap(a,j,j+1);
                }
            }
        }
    }

4.快速排序

  /*
    * 快速排序
    * 算法复杂度最低
    * */
    private static void qsort(int[] a){
        qsort(a,0,a.length-1);
    }
    private static void qsort(int[] a,int start,int end){
        int index=random.nextInt(end - start + 1)+start;
        if (start >=end) {
            return;
        }
        swap(a,index,end);
        index=start;
        for (int i = start; i < end ; i++) {
            if (a[i] < a[end]) {
                swap(a,index,i);
                index++;
            }
        }
        swap(a,index,end);
        qsort(a,start,index-1);
        qsort(a,index+1,end);
    }

快速排序的思想：就是把从一组数组之间选出一个中间值，通过交换函数把中间值交换到数组的最末端，通过遍历的方式把数组中数据一一与中间值比较，小于中间值的数字放在中间值的左边。