2.排序算法

1、插入排序 （insertion-sort）

//相比于冒泡排序，选择更优。 原因：冒泡排序和选择排序严格O(n^2),而插入排序根据数据的复杂程度最优复杂度为(N)。
对于少量元素的排序，它是一个有效算法。

 public static void insertionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        //0~0有序
        //0~i 想有序
        for (int i = 1; i < arr.length; i++) {  //
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }

通过以下动图来看插入排序的整个过程，图中红色的柱子为当前要插入的数，橘黄色的柱子为当前已经排好序的数据，绿色的柱子为正在跟红色的柱子比较的数，浅蓝色的柱子为还未插入的数。

2、选择排序

//O(N^2)
//选择排序
    public static void selectionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length - 1; i++) { //i~N-1
            int minIndex = i;                           //最小值的下标
            for (int j = i + 1; j < arr.length; j++) {  //i~N-1 找最小值的下标
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;//
            }
            swap(arr, i, minIndex);
        }
    }

3、冒泡排序

 public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length == 2) {
            return;
        }
        for (int e = arr.length - 1; e > 0; e--) { //0~e //每次最大的数一定是在最后面
            for (int i = 0; i < e; i++) {
                if (arr[i] > arr[i + 1]) {
                    swap(arr, i, i + 1);
                }
            }
        }
    }

4.归并排序

在《算法导论》里讲到归并排序主要体现分治的思想策略。

//O(N*logN) //稳定性强
//归并排序
    public static void mergeSort(int[] arr) {
    	//数组中没有元素或者只有一个元素
        if (arr == null || arr.length < 2) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

//递归
    public static void process(int[] arr, int L, int R) {
        if (L == R) {  //单个数有序直接返回
            return;
        }
        int mid = L + ((R - L) >> 1);  //找到中点
        process(arr, L, mid);  //如下图所示 分为单个数实现归并
        process(arr, mid + 1, R);
        merge(arr, L, mid, R);
    }

    public static void merge(int[] arr, int Left, int Middle, int Right) {
        int[] help = new int[Right - Left + 1];
        int i = 0;
        int p1 = Left;
        int p2 = Middle + 1;
        while (p1 <= Middle && p2 <= Right) { 
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= Middle) {
            help[i++] = arr[p1++];//
        }
        while (p2 <= Right) {
            help[i++] = arr[p2++];
        }
        //拷贝数组
        for (i = 0; i < help.length; i++) {
            arr[Left+i] = help[i];
        }
    }

归并排序动态图 演示

5.快速排序

//O(NlogN)
//快排（随机快排）
public static void quickSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    quickSort(arr, 0, arr.length - 1);
}

//先随机指定一个数字作为基数
//arr[1.....r]排好序号  
public static void quickSort(int[] arr, int L, int R) {
    if (L < R) {
        swap(arr, L + (int) (Math.random() + (R - L + 1)), R); //随机数使得排序复杂度称为概率事件、
        int[] p = partition(arr, L, R); //
        quickSort(arr, L, p[0] - 1);  //<区域
        quickSort(arr, p[1] + 1,R);  //大于区域
    }
}

//这是一个处理arr[1...r]的函数
//默认以arr[r]做划分，arr[r] -> p   <p  ==p  >p
//返回等于区域（左边界，右边界），所以返回一个长度为2的数组res,res[0],res[1]
public static int[] partition(int[] arr, int L, int R) {
    int less = L - 1;  // <区域右边界
    int more = R; //>区左边界
    while(L<more){
        if (arr[L] < arr[R]) { //当前数小于划分值
            swap(arr, ++less, L++);
        } else if (arr[L] > arr[R]) { //当前数 > 划分值
            swap(arr, --more, L);
        } else {
            L++;
        }
    }
    swap(arr, more, R);
    return new int[]{ less+1;more};
}
//上面排序中swap函数同此
//交换两个数
    //若i j 是同一位置会出错
    public static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }
//

快速排序动态图演示

6.堆

//堆结构就是用数组实现的完全二叉树结构
    //优先级队列就是堆结构
    //堆操作1
    //左孩子 index*2+1  右孩子 index *2 +2
    public static void heapify(int[] arr, int index, int heapSize) {  //heapsize是判断的边界
        int left = index * 2 + 1;                  //左孩子的下标
        while (left < heapSize) {   //下方有孩子
            //两孩子中谁值最大把其下标给largest
            int largest = left + 1 < heapSize && arr[left + 1] > arr[left]
                    ? left + 1 : left;
            //父亲和较大孩子之间，谁的值大，把下标给largest给她
            largest = arr[index] > arr[largest] ? index : largest;

            if (largest == index) {
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;

        }
    }

//堆操作2

    //某个数现在处在index位置，网上继续移动

    public static void heapInsert(int[] arr, int index){
        while (arr[index] > arr[(index-1)/2]){  //与父节点进行比较
            swap(arr,index ,(index-1)/2);
            index = (index-1)/2;
        }
    }


    //堆排序
    public static void heapSort(int[] arr){
        if (arr ==null || arr.length<2){
            return;
        }
        for (int i = 0 ; i < arr.length;i++){  //O(N)
            heapInsert(arr,i); //O(logN) 调整为大根堆
        }

//        for (int i= arr.length ; i > =  0 ; i--){
//            heapify(arr,i,arr.length);
//        }
        int heapSize = arr.length;
        swap(arr,0,--heapSize);
        while (heapSize >0){  //O(N)
            heapify(arr,0,heapSize);  //O(logN)
            swap(arr,0,--heapSize); //O(1)
        }
    }




    ///有些情况下需要手写堆
    //系统提供不一定高效
//小根堆
    public void sortedArrDistanceLessK(int[] arr,int k){
        //默认小根堆
        PriorityQueue<Integer> heap = new PriorityQueue<>();//***********
        int index = 0;
        for (;index <= Math.min(arr.length,k);index++){//
            heap.add((arr[index])); //加入
        }

        int i = 0 ;
        for (;index<arr.length;i++,index++){
            heap.add(arr[index]);
            arr[i]=heap.poll(); //拿出
        }
        while(!heap.isEmpty()){
            arr[i++]=heap.poll();
        }
    }

7.桶排序

//基数排序
public static void radixSort(int[] arr){
    if(arr==null||arr.length<=2){
        return;
    }
    radixSort(arr,0,arr.length-1,maxbits(arr));
}
public static int maxbits(int[] arr){  //找最大值有几个十进制位
    int max = Integer.MIN_VALUE;
    for (int i = 0; i < arr.length; i++) {
        max = Math.max(max,arr[i]);//找数组里面的最大值
    }
    int res = 0;
    while (max!=0){
        res++;
        max/=10;
    }
    return res;
}

//arr[bengin...end]排序
public static void radixSort(int[] arr , int L , int R,int digit){
    final int radix = 10;
    int i = 0 ,j=0;
    //有多少个数准备多少个空间
    int[] bucket =new int[R-L+1];
    for (int d= 1;d<=digit;d++){ //最大数有多少位就进出多少次
        //10个空间
        //count[0]当前位是0的数字有多少个
        //count[1]当前位是0和1的数字有多少个
        //count[i]当前位是(0~1)的数字有多少个
        int[] count = new int[radix];//count[0...9]
        for (i=L; i < R; i++) {
            j=getDigit(arr[i],d);
            count[j]++;
        }
        for (i=1 ; i<radix;i++){//形成前缀和
            count[i] = count[i]+count[i-1];
        }
        for(i=R;i>=L;i--){
            j=getDigit(arr[i],d);
            bucket[count[j]-1]=arr[i];
            count[j]--;
        }
        for (i=L,j=0;i<=R;i++,j++){
            arr[i]=bucket[j];
        }

    }
}

public static int getDigit(int x , int d){
    return ((x/((int)Math.pow(10,d-1)))%d);
}

7总结

最常用快排

基于比较的排序无法低于O（N*logN）