09_排序（下）
归并排序（Merge Sort）
归并排序原理
核心思想：要排序一个数组，先把数组分成前后两部分，然后对前后两部分分别排序，再将排好的两部分合并在一起，这样整个数组就有序了。
归并排序使用的是分治思想。顾名思义，将一个大问题分解成小的子问题来解决。
而分治算法一般是用递归来实现的。分治是一种解决问题的处理思想，递归是一种编程技巧。
递推公式：
merge_sort(p...r) = merge(merge_sort(p...q), merge_sort(q+1...r))
终止条件：
p >= r 不用再继续分解
将分开的子问题进行合并
归并排序性能分析
第一，归并排序是稳定的排序算法吗？
在合并的过程中，如果A[p...q]和A[q+1...r]之间有值相同的元素，那我们可以像伪代码中那样，先把A[p...q]中的元素放入tmp数组。这样就保证了值相同的元素，在合并前后的先后顺序不变。所以，归并排序是一个稳定的排序算法。
第二，归并排序的时间复杂度是多少？
假设对n个元素进行归并排序需要的时间是T(n)，那分解成两个子数组排序的时间都是T(n/2)。我们知道，merge()函数合并两个有序子数组的时间复杂度是O(n)。所以，套用前面的公式，归并排序的时间复杂度的计算公式就是：
T(1) = C； n=1时，只需要常量级的执行时间，所以表示为C。
T(n) = 2*T(n/2) + n； n>1
进一步拆分：
T(n) = 2*T(n/2) + n
= 2*(2*T(n/4) + n/2) + n = 4*T(n/4) + 2*n
= 4*(2*T(n/8) + n/4) + 2*n = 8*T(n/8) + 3*n
= 8*(2*T(n/16) + n/8) + 3*n = 16*T(n/16) + 4*n
......
= 2^k * T(n/2^k) + k * n
......
通过这样一步一步分解推导，我们可以得到T(n) = 2^kT(n/2^k)+kn。当T(n/2^k)=T(1)时，也就是n/2^k=1，我们得到k=log2n 。我们将k值代入上面的公式，得到T(n)=Cn+nlog2n 。如果我们用大O标记法来表示的话，T(n)就等于O(nlogn)。所以归并排序的时间复杂度是O(nlogn)。
第三，归并排序的空间复杂度是多少？
归并排序并没有像快排那样，应用广泛，这是为什么呢？因为它有一个致命的“弱点”，那就是归并排序不是原地排序算法。
尽管每次合并操作都需要申请额外的内存空间，但在合并完成之后，临时开辟的内存空间就被释放掉了。在任意时刻，CPU只会有一个函数在执行，也就只会有一个临时的内存空间在使用。临时内存空间最大也不会超过n个数据的大小，所以空间复杂度是O(n)。
归并排序代码实现
public class Main {
public static void main(String[] args) {
int[] arr = {11,44,23,67,88,65,34,48,9,12};
int[] tmp = new int[arr.length]; //新建一个临时数组存放
mergeSort(arr,0,arr.length-1,tmp);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
public static void mergeSort(int[] arr,int low,int high,int[] tmp){
if(low<high){
int mid = (low+high)/2;
mergeSort(arr,low,mid,tmp); //对左边序列进行归并排序
mergeSort(arr,mid+1,high,tmp); //对右边序列进行归并排序
merge(arr,low,mid,high,tmp); //合并两个有序序列
}
}
public static void merge(int[] arr,int low,int mid,int high,int[] tmp){
int i = 0;
int j = low,k = mid+1; //左边序列和右边序列起始索引
while(j <= mid && k <= high){
if(arr[j] < arr[k]){
tmp[i++] = arr[j++];
}else{
tmp[i++] = arr[k++];
}
}
//若左边序列还有剩余，则将其全部拷贝进tmp[]中
while(j <= mid){
tmp[i++] = arr[j++];
}
while(k <= high){
tmp[i++] = arr[k++];
}
for(int t=0;t<i;t++){
arr[low+t] = tmp[t];
}
}
}
快速排序（Quick Sort）
快速排序原理
快排的思想是这样的：如果要排序数组中下标从p到r之间的一组数据，我们选择p到r之间的任意一个数据作为pivot（分区点）。
我们遍历p到r之间的数据，将小于pivot的放到左边，将大于pivot的放到右边，将pivot放到中间。经过这一步骤之后，数组p到r之间的数据就被分成了三个部分，前面p到q-1之间都是小于pivot的，中间是pivot，后面的q+1到r之间是大于pivot的。
根据分治、递归的处理思想，我们可以用递归排序下标从p到q-1之间的数据和下标从q+1到r之间的数据，直到区间缩小为1，就说明所有的数据都有序了。
如果我们不考虑空间消耗的话，partition()分区函数可以写得非常简单。我们申请两个临时数组X和Y，遍历A[p...r]，将小于pivot的元素都拷贝到临时数组X，将大于pivot的元素都拷贝到临时数组Y，最后再将数组X和数组Y中数据顺序拷贝到A[p....r]。
原地完成分区操作，通过游标i把A[p...r-1]分成两部分。A[p...i-1]的元素都是小于pivot的，我们暂且叫它“已处理区间”，A[i...r-1]是“未处理区间”。我们每次都从未处理的区间A[i...r-1]中取一个元素A[j]，与pivot对比，如果小于pivot，则将其加入到已处理区间的尾部，也就是A[i]的位置。
处理技巧，就是交换，在O(1)的时间复杂度内完成插入操作。这里我们也借助这个思想，只需要将A[i]与A[j]交换，就可以在O(1)时间复杂度内将A[j]放到下标为i的位置。
快速排序性能分析
第一，快速排序是稳定的排序算法吗？
因为分区的过程涉及交换操作，如果数组中有两个相同的元素，比如序列6，8，7，6，3，5，9，4，在经过第一次分区操作之后，两个6的相对先后顺序就会改变。所以，快速排序并不是一个稳定的排序算法。
第二，快速排序的时间复杂度是多少？
我前面总结的公式，这里也还是适用的。如果每次分区操作，都能正好把数组分成大小接近相等的两个小区间，那快排的时间复杂度递推求解公式跟归并是相同的。所以，快排的时间复杂度也是O(nlogn)。
第三，快速排序的空间复杂度是多少？
原地排序，O（1）。
快速排序代码实现
public class QuickSort {
public static void quickSort(int[] array){
if (array == null || array.length < 2) {
return; //array为空或者该数组元素为一，没有排序的意义
}
quickSort(array, 0, array.length - 1);
}
private static void quickSort(int[] array, int l, int r) {
if ( l >= r){
return; //数据不合法，退出程序
}
//要向使l --> r中有序，先找到一个基准数,取数组的最后一个数为基准数
int num = array[r];
//找到基准数在数组中的位置，使得 < 基准数的在左边 ,等于基准数的在中间, > 基准数的在右边。
int[] index = quick_sort(array, l, r,num); //此时中间的 = sum的已经拍好序了
quickSort(array,l,index[0]); //使左边的有序
quickSort(array,index[1],r); //使右边的有序
}
private static int[] quick_sort(int[] array, int l, int r, int num) {
//找到基准数在数组中的位置，使得 < 基准数的在左边 ,等于基准数的在中间, > 基准数的在右边。
int p1 = l - 1;
int p2 = r + 1;
while (l < p2) {
if (array[l] < num){
//1.第一种情况，如果小于num的时候，将该元素与 < 范围的前一个交换，i++
int temp = array[l];
array[l] = array[p1 + 1];
array[p1 + 1] = temp;
l++;
p1++;
}else if (array[l] == num){
//2.第二种情况，如果[l]==sum的时候，l++
l++;
}else {
//3.第三种情况,如果[l] > sum的时候，[l] 与 > 范围的前一个元素交换
int temp = array[l];
array[l] = array[p2 - 1];
array[p2 - 1] = temp;
p2--;
}
}
return new int[]{p1,p2}; //此时中间的 = sum的已经拍好序了、
}
public static void main(String[] args) {
int[] array = new int[]{1,5,3,6,3,5,8,10,3};
quickSort(array);
for (int i : array) {
System.out.println(i);
}
}
}
归并排序与快速排序的区别
可以发现，归并排序的处理过程是由下到上的，先处理子问题，然后再合并。而快排正好相反，它的处理过程是由上到下的，先分区，然后再处理子问题。归并排序虽然是稳定的、时间复杂度为O(nlogn)的排序算法，但是它是非原地排序算法。我们前面讲过，归并之所以是非原地排序算法，主要原因是合并函数无法在原地执行。快速排序通过设计巧妙的原地分区函数，可以实现原地排序，解决了归并排序占用太多内存的问题。
标签：tmp,归并,int,09,arr,array,排序 来源： https://www.cnblogs.com/l12138h/p/16418186.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。