归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并

先一步一步递归直到l与h相遇,

也就是只剩下一个元素的情况

比如要合并1670 这两组,就要在4个一组的时候找到对应的下标

注意要对应上原数组的下标,而不是这次递归的开始

2.代码实现

public static void mergeSort(int[] array){mergeSortInternal(array,0,array.length-1);
}
public static void mergeSortInternal(int [] array,int low,int high){//递归终止条件if(low>=high) return;int mid=low+((high-low)>>>1);//加号 的优先级比较高//递归左边的mergeSortInternal(array,low,mid);//递归右边的mergeSortInternal(array,mid+1,high);//走到这就需要合并  所合并的参数应该是上次递归的merge(array,low,mid,high);
}
/*** g归并*/
private static void merge(int[] array,int low,int mid,int high){int s1=low;int e1=mid;int s2=mid+1;int e2=high;int[] tmp=new int[high-low+1];int k=0;while(s1<=e1&&s2<=e2){if(array[s1]<=array[s2]){tmp[k++]=array[s1++];}else{tmp[k++]=array[s2++];}}while(s1<=e1){tmp[k++]=array[s1++];}while(s2<=e2){tmp[k++]=array[s2++];}//还要把tmp拷贝到原来的数组for (int i = 0; i < k; i++) {array[i+low]=tmp[i];}
}

3.分析

时间复杂度:一直递归每个数据都要递归到树的高度那么多,所以就是n*logn

空间复杂度就是额外开一个tmp数组所以就是o(n)

并且是一个稳定的排序

/*** 归并排序：* 时间复杂度：O(N*logN)* 空间复杂度：O(N)* 稳定性：稳定的排序* 如果 array[s1] <= array[s2] 不取等号  那么就是不稳定的排序** 学过的排序 只有3个是稳定的：* 冒泡   插入   归并* @param array*/

4.非递归

先定义一个gap每组从1个元素开始然后加倍

当每组一个时候.

找到相邻两个数据段的下标

进行归并

然后再往前走找下两个数据段

直到遍历完

再让gap加倍

继续进行循环

直到gap等于数组长度或者大于/

/*** 非递归实现归并排序*/
public static void mergeSort1(int[] arr){int gap=1;//每组的数据个数while(gap= arr.length){mid=arr.length-1;}int right=mid+gap;//防止越界if(right>=arr.length){right=arr.length-1;}//小标确立后,进行合并merge(arr,left,mid,right);}gap*=2;}
}

5.海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序

前提：内存只有 1G，需要排序的数据有 100G

因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

1. 先把文件切分成 200 份，每个 512 M
2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
3. 进行 200 路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

外部排序就是在磁盘上排序,

内部排序就是在内存上排序

三.排序总结

四.非比较的排序

1.基数排序

因为是十进制的,构成0-9的十个队列

把一组数据从个位数到最高位分别进行排序

先尾插进,头出

个位

然后在从0-9按照顺序头出来

可以发现个位已经有序

在来排序十位数

再分别拿出来

再排序百位数

1.10 基数排序 | 菜鸟教程 (runoob.com)

2.桶排序

桶排序（最快最简单的排序） - 知乎 (zhihu.com)

3.计数排序

1.原理

定义一个计数数组.找数组每个元素出现的次数,然后遍历计数数组.从头开始,

但是有疑问?

计数数组建立好后

把技术数组的数据覆盖到原数组

就先遍历计数数组

把不是0的数据进行循环

这里就需要定义一个index

因为很有可能一个数据出现好几次

循环一次,index就往后一位

直到计数数组对应的值为0

那我们如果放进去原数组的值呢

其实很简单就是计数数组的下标

但是如果是900-926各元素

我们防止内存冗余 就减去了900存放

那么我们遍历计数数组放元素的时候也需要加上900也就是minval.

2.代码

public static void countingSort(int[] array) {int maxVal = array[0];int minVal = array[0];for (int i = 1; i < array.length; i++) {if(array[i] < minVal) {minVal = array[i];}if(array[i] > maxVal) {maxVal = array[i];}}//说明，已经找到了最大值和最小值int[] count = new int[maxVal-minVal+1];//默认都是0//统计array数组当中，每个数据出现的次数for (int i = 0; i < array.length; i++) {int index = array[i];//为了空间的合理使用 这里需要index-minVal  防止923-900count[index-minVal]++;}//说明，在计数数组当中，已经把array数组当中，每个数据出现的次数已经统计好了//接下来，只需要，遍历计数数组，把数据写回arrayint indexArray = 0;for (int i = 0; i < count.length; i++) {while (count[i] > 0) {//这里一定要加minVal，因为不一定就是i出现了count[i]array[indexArray] = i+minVal;count[i]--;//拷贝一个之后，次数也就少一个indexArray++;//下标得向后移动}}
}

3.分析

/*** 计数排序*/
/*** 计数排序：* 时间复杂度：O(N)* 空间复杂度：O(M) M:代表 当前数据的范围900 - 999* 稳定性：当前代码是不稳定的，但是本质是稳定的** 一般适用于 有n个数，数据范围是0-n之间的* @param array*/