七大排序--可优化

以下是七大排序，部分排序已优化。还差堆排序，我会写一个有关堆的文章，堆排序也在其中。

1.选择排序

选择排序是一个不稳定的排序 selectionsort
* 每次从无序区间中选择一个最大或最小值，存放在无序区间的最前或者最后位置（此位置的元素已经有序），直到所有的数据都排序完成为止。
* 我们以选择最小值为例
* 已排序区间[]
* 未排序区间[0....n]

以下是选择排序的代码：

public class select_sort {
    public static void selectionSort(int[] arr) {
        //最开始，无序区间[0..n] 有序区间[]
        //当无序区间只剩下一个元素时，整个集合已经有序
        for (int i = 0; i < arr.length; i++) {
            // min变量存储了当前的最小值
            int min = i;
            //从剩下的元素中选择最小值
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            //min这个索引一定对应了当前无序区间中找到的最小值索引，换到无序区间的最前面i
            swap(arr, min, i);
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int t = arr[a];
        arr[a] = arr[b];
        arr[b] = t;
    }

2.冒泡排序

比较基础的排序，需要设置一个标志位，满足条件时，跳出循环

public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            boolean isSwaped = false;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                    isSwaped = true;
                }
            }
            if (!isSwaped) {
                break;
            }
        }
    }

3.双向选择排序

一次排序过程中同时选出最大和最小值，放在无序区间的最后和最前位置，这是一个效率很高的排序

代码如下：

 public static void selectionSortOP(int[] arr) {
        int low = 0;
        int high = arr.length - 1;
        //当low=high，无序区间只剩下一个元素，整个数组已经有序
        while (low < high) {
            int min = low;
            int max = low;
            //因为是arr.length-1,所以此时要取等号
            for (int i = low + 1; i <= high; i++) {
                if (arr[i] < arr[min]) {
                    //更改下标
                    min = i;
                }
                if (arr[i] > arr[max]) {
                    max = i;
                }
            }
            //min这个索引一定是当前无序区间的最小值索引，与low交换位置
            swap(arr, low, min);
            //判断边界条件，存在特殊情况
            if (max == low) {
                //此时最大值已经被换到min这个位置
                max = min;
            }
            swap(arr, max, high);
            low += 1;
            high -= 1;
        }
    }

4.插入排序

插入排序和选择排序最大的不同在于：插入排序当前遍历的元素>前驱元素时，可以提前结束内层循环， 极端情况下，当集合石一个完全有序的集合，插入排序内层循环一次都不走，插入排序变为o(n)
***插入排序常用作高阶排序算法的优化手段之一

 public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
 for (int j = i; j >=1 && arr[j] < arr[j - 1]; j--) {
                swap(arr, j, j - 1);
            }
        }
    }

5.二分插入或折半插入，在有序区间中选择插入位置，有序左闭右开[0..i）,无序区间[i...n]

public static void insertionSortBS(int[]arr){
        for (int i = 1; i < arr.length; i++) {
            int val=arr[i];
            int left =0;
            int right =i;
            while(left<right){
                int mid = left+((right - left)>>1);
                if(val<arr[mid]){
                    right = mid;
                }else{
                    //val>= arr[mid]
                    left = mid+1;
                }
            }
            //搬移left...i的元素
            for (int j = i; j >left; j--) {
                arr[j]=arr[j-1];
            }
            //left就是val插入的位置
            arr[left]=val;
        }
    }

6.希尔排序，也叫缩小增量排序。先选顶一个整数(gap)，一般都选数组长度的一般或者1/3

将待排序的数组先按照gap分组，不同组之间使用插入排序，排序之后，再将gap/=2或者3，重复上述流程，直至gap=1，
整个数组已经被调整的近乎有序，此时就是插入排序最好的场景，最后在已排序数组上进行一个插入排序即可

是一个不稳定的排序

public static void shellSort(int[]arr){
        int gap= arr.length >>1;
        while(gap>1){
            //预处理，分成小数组
            insertionSortByGap(arr,gap);
            gap= gap>>1;
        }
        //此时gap=1,整个集合已经接近有序，只需要全集合来一次插入排序即可
    insertionSort(arr);
}
//按gap分组进行插入排序
    private static void insertionSortByGap(int[] arr, int gap) {
        //小分组[0,gap,2*gap...]
        for (int i = gap; i <arr.length; i++) {
            //不断向前扫描相同的gap元素
            //j-gap 从j位置开始向前还有相同步数的元素
            for (int j = i; j-gap >=0&& arr[j]<arr[j-gap]; j-=gap) {
                //只看gap相同步数的元素
                //j-gap>=0  表示已经走到第一个元素了
                swap(arr,j,j-gap);
            }
        }
    }

7.归并排序 nlogn
将原数组不断拆分，直到每个子数组只有一个元素时，第一阶段结束，归而为1 这个阶段结束将相邻的两个数组合并为一个有序的数组，直到整个数据有序

public static void mergeSort(int[] arr){
        mergeSortInternal(arr,0,arr.length -1);
    }
//在arr[l...r]上进行归并排序
    private static void mergeSortInternal(int[] arr,int l,  int r) {
        if(l>=r){
            //当前数组只剩一个元素，归并过程就结束
            return;
        }
        int mid = 1+((r-l)>>1);
    }

8.快速排序

从待排序区间选择一个数，作为基准值pivot

Partition:遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值左边，将比基准值大的防盗基准值右边

采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度==1，代表已经有序，或者小于区间的长度==0，代表没有数据

public static void  quickSort(int[] arr){
        quickSortInternal(arr,0,arr.length -1);
    }

    private static void quickSortInternal(int[] arr, int l, int r) {
       if(l >=  r){
        return;
    }
            //先获取分区点
            //所谓的分区点就是经过分区函数后，某个元素落在了最终位置
            //分区点左侧全都是小于该元素的区间，分区点右侧全都是大于等于该元素的区间
            int p = pratition(arr, l, r);//数组遍历
            //重复在做区间和右区间上重复上述流程
         quickSortInternal(arr, l, p - 1);
         quickSortInternal(arr, p + 1, r);

    }

    //这是一个分区函数
    private static int pratition(int[] arr, int l, int r) {
        //在arr[l...r]上的分区函数，返回分区点的索引
        //基准值
        int v = arr[l];
        //arr[l+1 ...j] <v
       //arr[j+1 ...i) >= v
        //i 表示当前正在扫描的元素
        int j =l;//左闭右闭，是一个空区间
        for (int i = l+1; i <= r; i++) {
            if (arr[i] < v) {
                swap(arr, j + 1, i);
                j++;//左边区间扩充了一个元素
            }
        }
        // 将基准值和最后一个小于v的元素交换，基准值就落在了最终位置
        swap(arr,l,j);
        return j;
    }

}

排序中还包括堆排序，我将它放在堆的一个博客中。

以下是排序的帮助类，帮助类用于生成一个很大的数组。帮助类中用到了反射，我还掌握不精。测试时，我遇到一个问题，快速排序只能在第一个位置进行测试，如果将它放在后面，会出现异常，系统自动返回一个异常，我还没有弄明白为什么出现异常。

import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.ThreadLocalRandom;
import java.util.Arrays;
import java.lang.reflect.Method;
public class SortHelper {
    //获取随机数的对象
    private static final ThreadLocalRandom random = ThreadLocalRandom.current();

    //在[letf,right]区间生成一个数组大小为N的随机数数组
    public static int[] generateRandomArray(int n,int left ,int right){
        int[] arr = new int[n];
        for (int i = 0; i <arr.length; i++) {
            arr[i]= random.nextInt(left,right);
        }
        return arr;
    }


    //生成一个大小为N的几乎有序的数组1234 65 78
    //times是交换的次数，次数越小，越有序
    public static int[] generateSortedArray(int n,int times){
        int []arr= new int[n];
        for (int i = 0; i <n; i++) {
            arr[i]=i;
        }
        //交换部分元素，交换次数越少，越有序
        for (int i = 0; i <times; i++) {
            //生成一个0-n上的随机数
            int a=random.nextInt(n);
            int b= random.nextInt(n);
            int temp=arr[a];
            arr[a]=arr[b];
            arr[b]=temp;
        }
        return arr;
    }



    //根据传入的方法名称就能调用这个方法，需要借助反射（类似函数指针）
    //根据方法名称调用相应的排序方法，对arr数组进行排序操作
public static void testSort(String sortName,int[]arr){
        Class<select_sort> cls = select_sort.class;
        //获取该类的一个class对象
        //用到反射
    try {
        Method method = cls.getDeclaredMethod(sortName,int[].class);
        long start = System.nanoTime();
        method.invoke(null,arr);
        //排序算法的调用，静态方法无对象，所以这里是null
        long end =System.nanoTime();
        if(isSorted(arr)){
            //算法正确
            System.out.println(sortName+"排序结束，共耗时："+(end - start)/1000000.0+"ms");
        }
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}





    //生成一个arr的深拷贝数组
    //为了测试不同排序算法的性能，需要在相同的数据集上进行测试
    public static int[] arrCopyOf(int[]arr){
        return Arrays.copyOf(arr,arr.length);
    }

以下是测试类

public class SortTest {
    public static void main(String[] args) {
        int n= 50000;
        int[]arr = SortHelper.generateRandomArray(n,0,Integer.MAX_VALUE);
        //近乎有序数组
        int []arr1 =SortHelper.generateSortedArray(n,10);
        int[]arrCopy1 = SortHelper.arrCopyOf(arr);
        int[]arrCopy2 = SortHelper.arrCopyOf(arr);
        int[]arrCopy3 = SortHelper.arrCopyOf(arr);
        int[]arrCopy4 = SortHelper.arrCopyOf(arr);
        int[]arrCopy5 = SortHelper.arrCopyOf(arr);
        SortHelper.testSort("quickSort",arrCopy5);
        SortHelper.testSort("selectionSort", arr);
//        SortHelper.testSort("bubbleSort",arrCopy1);
//        //SortHelper.testSort("heapSort",arrCopy2);
//        SortHelper.testSort("selectionSortOP",arrCopy2);
//       SortHelper.testSort("insertionSort",arrCopy3);
        SortHelper.testSort("insertionSort",arr1);
//        SortHelper.testSort("insertionSortBS",arrCopy4);
        SortHelper.testSort("shellSort",arrCopy5);


    }
}