归并排序
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。
一次归并操作的工作原理如下:
第一步:申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
第二步:设定两个指针,最初位置分别为两个已经排序序列的起始位置
第三步:比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
重复步骤3直到某一指针超出序列尾
将另一序列剩下的所有元素直接复制到合并序列尾
递归法代码
package algorithm;
import java.util.Arrays;
/**
* Created by obite on 15/11/11.
* E-Mail:zhanlanstar@163.com
*/
public class TestMergeSort2 {
public static void main(String[] args) {
// int[] nums = IntStream.range(0, 20).map(item -> RandomUtils.nextInt(0, 100)).toArray();
int[] nums = new int[]{9, 8, 7, 6, 5, 4, 3, 2, 10};
int[] result = new int[nums.length];
System.out.println("Origin:" + Arrays.toString(nums));
new MergeSort().sort(nums, result, 0, nums.length - 1);
System.out.println("Result:" + Arrays.toString(result));
}
/**
* 归并排序
* <p/>
* 一次归并操作的工作原理如下:
* 第一步:申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
* 第二步:设定两个指针,最初位置分别为两个已经排序序列的起始位置
* 第三步:比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
* 重复步骤3直到某一指针超出序列尾
* 将另一序列剩下的所有元素直接复制到合并序列尾
* <p/>
* 归并排序把数组分为只包含一个数字的组,然后一次次归并成最终结果。
* <p/>
* 这个是递归版本的,更容易理解一些。
*/
static class MergeSort {
/**
* @param origin 原始数组,也是最终排序正确排序的数组
* @param result 辅助数组,也是最终排序正确排序的数组
* @param start 起始位置,开始是0
* @param end 结束位置,开始是数组长度-1,即最后一个下标
*/
public void sort(int[] origin, int[] result, int start, int end) {
//浪费了我几乎昨天一个下午,再加上今天上午的时间的一个算法。归并排序,原因只是因为我少写了一个括号。
//运算符的优先级:+ - 为4,* / % 为3,<< >> 为5,所以写成 int half = start + (end - start) >>> 1;是错的。
int half = start + ((end - start) >>> 1);
if (start >= end) {
return;
}
// 递归排序子序列1和子序列2
sort(origin, result, start, half);
sort(origin, result, half + 1, end);
// 归并每次排序后的两个子串
merge(origin, result, start, half + 1, end);
}
/**
* @param origin 是原始数组,每次合并后会把b的结果复制到a中
* @param result 辅助作用,也是最终的结果集。
* @param start 是第一个待合并子数组的起始位置。
* @param half 是第二个子数组的结束位置。
* @param end 第二个子数组的起始位置,也是当前已经排序到的位置
*/
public void merge(int[] origin, int[] result, int start, int half, int end) {
// 归并两个排序结果
int i = start, j = half, k = start;
while (i < half && j <= end) {
result[k++] = origin[i] <= origin[j] ? origin[i++] : origin[j++];
}
// 剩下的元素,直接写入(只会有一个数组会有剩下的元素)
while (i < half) {
result[k++] = origin[i++];
}
while (j <= end) {
result[k++] = origin[j++];
}
// 这里把新合并的结果写入到原始数组中,必须写入
for (int x = start; x < k; x++) {
origin[x] = result[x];
}
display(origin, result, start, k);
}
/**
* 展示结果,并无其他用处
*/
public void display(int[] origin, int[] result, int start, int end) {
System.out.println(String.format("{%s},{%s},{%s}",
displayArrayToString(Arrays.copyOfRange(origin, 0, start)),// 先前已排序
displayArrayToString(Arrays.copyOfRange(result, start, end)),// 当前排序
displayArrayToString(Arrays.copyOfRange(origin, end, origin.length))));// 未排序
}
public String displayArrayToString(int[] array) {
String s = Arrays.toString(array);
return s.substring(1, s.length() - 1);
}
}
}
递归法排序演算(程序输出)
Origin:[9, 8, 7, 6, 5, 4, 3, 2, 10]
{},{8, 9},{7, 6, 5, 4, 3, 2, 10}
{},{7, 8, 9},{6, 5, 4, 3, 2, 10}
{7, 8, 9},{5, 6},{4, 3, 2, 10}
{},{5, 6, 7, 8, 9},{4, 3, 2, 10}
{5, 6, 7, 8, 9},{3, 4},{2, 10}
{5, 6, 7, 8, 9, 3, 4},{2, 10},{}
{5, 6, 7, 8, 9},{2, 3, 4, 10},{}
{},{2, 3, 4, 5, 6, 7, 8, 9, 10},{}
Result:[2, 3, 4, 5, 6, 7, 8, 9, 10]
容易理解的版本
上述写法是原始算法的版本,由于是在同一个数组中操作,不易理解,这里通过创建多个数组产生更容易理解的版本,但是会浪费一些空间,仅供参考。
public class TestMergeSort {
public static void main(String[] args) {
int[] nums = IntStream.range(0, 20).map(item -> RandomUtils.nextInt(0, 100)).toArray();
// int[] nums = new int[]{9, 8, 7, 6, 5, 4, 3, 2, 10};
int[] newNums = mergeSort(nums, 0, nums.length - 1);
System.out.println(Arrays.toString(newNums));
}
/**
* 这个写法很好理解,但会浪费比较多空间,产生了很多int[]数组
*/
public static int[] mergeSort(int[] nums, int l, int h) {
if (l == h)
return new int[]{nums[l]};
int mid = l + (h - l) / 2;
int[] leftArr = mergeSort(nums, l, mid); //左有序数组
int[] rightArr = mergeSort(nums, mid + 1, h); //右有序数组
int[] newNum = new int[leftArr.length + rightArr.length]; //新有序数组
// 归并两个排序结果
int m = 0, i = 0, j = 0;
while (i < leftArr.length && j < rightArr.length) {
newNum[m++] = leftArr[i] < rightArr[j] ? leftArr[i++] : rightArr[j++];
}
// 剩下的元素,直接写入(只会有一个数组会有剩下的元素)
while (i < leftArr.length)
newNum[m++] = leftArr[i++];
while (j < rightArr.length)
newNum[m++] = rightArr[j++];
return newNum;
}
}