基础算法学习笔记—归并排序_坐在马桶上看算法归并排序-CSDN博客

本文链接：https://blog.csdn.net/arivn_jianming/article/details/50401405

由于最近本人要参加面试，复习了一下本科学习过的一些重要的基础算法，在此总结归纳知识点，内容主要参考自百度百科并做了一些相应的修改。

归并排序

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

归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

2）算法介绍：归并操作(merge)，也叫归并算法，指的是将两个顺序序列合并成一个顺序序列的方法。

如　设有数列{6，202，100，301，38，8，1}

初始状态：6,202,100,301,38,8，1

第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；

第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；

第三次归并后：{1,6,8,38,100,202,301},比较次数：4；

总的比较次数为：3+4+4=11,；

逆序数为14；

归并操作的工作原理如下：

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

重复步骤3直到某一指针超出序列尾

将另一序列剩下的所有元素直接复制到合并序列尾

3）用途：

速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列。

4）代码实现：

public classMergeSort {
         /**
          * 归并排序
          * 简介:将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列
          * 时间复杂度为O(nlogn)
          * 稳定排序方式
          * @param nums 待排序数组
          * @return 输出有序数组
          */
         public static int[] sort(int[] nums,int low, int high) {
                   int mid = (low + high) / 2;
                   if (low < high) {
                            // 左边
                            sort(nums, low,mid);
                            // 右边
                            sort(nums, mid + 1,high);
                            // 左右归并
                            merge(nums, low,mid, high);
                   }
                   return nums;
         }
 
         public static void merge(int[] nums,int low, int mid, int high) {
                   int[] temp = new int[high -low + 1];
                   int i = low;// 左指针
                   int j = mid + 1;// 右指针
                   int k = 0;
 
                   // 把较小的数先移到新数组中
                   while (i <= mid &&j <= high) {
                            if (nums[i] <nums[j]) {
                                     temp[k++] =nums[i++];
                            } else {
                                     temp[k++] =nums[j++];
                            }
                   }
 
                   // 把左边剩余的数移入数组
                   while (i <= mid) {
                            temp[k++] =nums[i++];
                   }
 
                   // 把右边边剩余的数移入数组
                   while (j <= high) {
                            temp[k++] =nums[j++];
                   }
 
                   // 把新数组中的数覆盖nums数组
                   for (int k2 = 0; k2 <temp.length; k2++) {
                            nums[k2 + low] =temp[k2];
                   }
         }
}

5）复杂度分析

归并排序的最好、最坏和平均时间复杂度都是O(nlogn)，而空间复杂度是O(n)，归并排序算法比较占用内存，但却是效率高且稳定的排序算法。（若从空间复杂度来考虑：首选堆排序，其次是快速排序，最后是归并排序。若从稳定性来考虑，应选取归并排序，因为堆排序和快速排序都是不稳定的。若从平均情况下的排序速度考虑，应该选择快速排序。

）

可以说合并排序是比较复杂的排序，特别是对于不了解分治法基本思想的同学来说可能难以理解。总时间=分解时间+解决问题时间+合并时间。分解时间就是把一个待排序序列分解成两序列，时间为一常数，时间复杂度o(1).解决问题时间是两个递归式，把一个规模为n的问题分成两个规模分别为n/2的子问题，时间为2T(n/2).合并时间复杂度为o（n）。总时间T(n)=2T(n/2)+o(n).这个递归式可以用递归树来解，其解是o(nlogn).此外在最坏、最佳、平均情况下归并排序时间复杂度均为o(nlogn).从合并过程中可以看出合并排序稳定。

用递归树的方法解递归式T(n)=2T(n/2)+o(n):假设解决最后的子问题用时为常数c，则对于n个待排序记录来说整个问题的规模为cn。