前言
归并排序是数据结构的八大排序基本算法之一，本文通过两个具体的算法题来讲解归并排序的思路以及代码实现。
一、归并排序介绍
归并排序是利用归并的思想实现的排序的方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分（divide）成一些小的问题然后递归求解，而治（conquer）的阶段则将分的阶段得到的答案修补在一起，即分而治之）
二、两个归并排序的算法题
1.对一个数组进行归并排序，使其为有序数组。
代码如下（示例）：
public class MergeSort {
public static void main(String[] args) {
int[] arr = {
8, 4, 5, 7, 1, 3, 6, 2};
int[] temp = new int[arr.length];
mergeSort(arr, 0, arr.length - 1, temp);
System.out.println(Arrays.toString(arr));
}
/**
* 分解的方法+合并的方法
*/
public static int[] mergeSort(int[] arr, int left, int right, int[] temp) {
if (left < right) {
int mid = (left + right) / 2;
//向左递归进行分解
mergeSort(arr, left, mid, temp);
//向右递归分解
mergeSort(arr, mid + 1, right, temp);
//合并
merge(arr,left,mid,right,temp);
}
return arr;
}
/**
* 合并的方法
*
* @param arr 原始数组
* @param left 左索引
* @param mid 中间的索引
* @param right 右边索引
* @param temp 中转数组
* @return
*/
public static int[] merge(int[] arr, int left, int mid, int right, int[] temp) {
//初始化i，左边有序序列的初始索引
int i = left;
//初始化j，右边有序序列的初始索引
int j = mid + 1;
//指向temp数组的当前索引
int t = 0;
//一、先把左右两边（有序）的数据按照规则填充到temp数组
//直到左右两边的有序序列，有一边处理完为止
while (i <= mid && j <= right) {
if (arr[i] < arr[j]) {
//如果左边的有序序列的当前元素小于等于右边序列的当前元素
//将左边的当前元素拷贝到temp数组中
//将i，j向后移
temp[t] = arr[i];
t += 1;
i += 1;
} else {
//反之，右边的有序序列的当前元素填充到temp数组
temp[t] = arr[j];
t += 1;
j += 1;
}
}
//二、把有剩余数据的一边的数据一次全部填充到temp
while (i <= mid) {
//说明左边的有序序列还有剩余，就全部填充到temp中
temp[t] = arr[i];
t += 1;
i += 1;
}
while (j <= right) {
//说明右边的有序序列还有剩余，就全部填充到temp中
temp[t] = arr[j];
t += 1;
j += 1;
}
//三、将temp数组的元素拷贝到原始数组
//并不是每次都拷贝
//第一次合并的是分的最小的组 tempLeft = 0 right =1
//第二次 temp = 0,right = 3
//...最后一次 temp = 0 right = nums.length
t = 0;
int tempLeft = left;
while (tempLeft <= right) {
arr[tempLeft] = temp[t];
t += 1;
tempLeft += 1;
}
return arr;
}
}
输出结果：
[1, 2, 3, 4, 5, 6, 7, 8]
2.给定一个链表，使其成为有序链表。
（1）首先需要使用合并两个有序链表的方法；
（2）找到原链表的中间结点的位置，使用分治的思想分别进行排序，最后使用递归进行链表合并，使其成为有序的链表。
代码如下（示例）：
class Solution {
public ListNode sortList(ListNode head) {
return sort(head,null);
}
//归并排序
private ListNode sort(ListNode start,ListNode end){
//如果第一个结点的位置等于最后一个结点的位置，说明链表只有一个结点。
if(start == end ){
return start;
}
//创建快结点和慢结点
ListNode fast = start,slow =start;
//快指针走两个结点，慢指针走一个结点
while(fast!=end&&fast.next!=end){
fast=fast.next.next;
slow = slow.next;
}
//循环结束，快指针是最后一个结点，慢指针是中间结点
//使用递归进行排序
ListNode l2 = sort(slow.next,end);
slow.next = null;
ListNode l1 = sort(start,slow);
return merge(l1,l2);
}
//给定两个节点，合并成一个有序的结点
private ListNode merge(ListNode l1,ListNode l2){
if(l1==null||l2==null){
return l1==null?l2:l1;
}
//如果两个链表的当前节点的大小相比较
if(l1.val<l2.val){
//第一个链表的第一个结点小于第二个链表的第一个结点，
//继续与第一个结点的下一个结点比较
l1.next = merge(l1.next,l2);
return l1;
}else{
l2.next = merge(l1,l2.next);
return l2;
}
}
}