常用排序算法之归并

归并排序

一、思想：假设有待排序列R[0,……,n-1]，首先将R[0,……,n-1]看成n个长度为1的有序表，将相邻的有序表成对归并，得到n/2个长度为2的有序表，然后再将这些有序表成对归并得到n/4个长度为的有序表，如此反复的进行下去，最后得到一个长度为n的有序表。

二、一次归并排序的代码如下:

// 一次归并排序
	public static void merge(int[] array, int low, int mid, int high) {
		int[] arrayTemp = new int[high + 1];// 临时表
		int i = low;// 第一段子表的下标
		int j = mid + 1;// 第二段子表的下标
		int k = 0;// 临时表的下标

		while (i <= mid && j <= high) {// 两段子表都没有剩余就循环对比
			if (array[i] <= array[j]) {
				arrayTemp[k] = array[i];
				i++;
				k++;
			} else {
				arrayTemp[k] = array[j];
				j++;
				k++;
			}
		}
		// 第一段子表有剩余
		while (i <= mid) {
			arrayTemp[k] = array[i];
			i++;
			k++;
		}
		// 第二段子表有剩余
		while (j <= high) {
			arrayTemp[k] = array[j];
			j++;
			k++;
		}
		for (k = 0, i = low; i <= high; k++, i++) {
			array[i] = arrayTemp[k];
		}
	}

merge函数实现了一次归并排序，调用merge函数进行归并时必须对子表的个数可能是奇数个、最后一个子表的长度小于length者两种特殊情况进行区分。实现方式如下;

// 一趟归并排序
	public static void mergeOneTime(int[] array, int length, int n) {
		int i;
		for (i = 0; i + 2 * length - 1 < n; i = i + 2 * length) {
			merge(array, i, i + length - 1, i + 2 * length - 1);
		}
		if (i + length - 1 < n) {
			merge(array, i, i + length - 1, n - 1);
		}
	}

最后，二路归并算法实现如下：

// 二路归并排序
	public static void mergeSort(int[] array, int n) {
		int length;
		for (length = 1; length < n; length = 2 * length) {
			mergeOneTime(array, length, n);
		}
	}

三、测试结果：

package baohuajie.sort;

import java.util.Arrays;

public class MergeSort {

	public static void main(String[] args) {
		int[] array = { 52, 38, 47, 24, 69, 05, 17, 38, 73 };
		// int[] array = { 5, 17, 24, 38, 38, 47, 52, 69 };
		mergeSort(array, array.length);
		System.out.println("最终排序结果：" + Arrays.toString(array));
	}

	// 二路归并排序
	public static void mergeSort(int[] array, int n) {
		int length;
		for (length = 1; length < n; length = 2 * length) {
			mergeOneTime(array, length, n);
		}
	}

	// 一趟归并排序
	public static void mergeOneTime(int[] array, int length, int n) {
		int i;
		for (i = 0; i + 2 * length - 1 < n; i = i + 2 * length) {
			merge(array, i, i + length - 1, i + 2 * length - 1);
		}
		if (i + length - 1 < n) {
			merge(array, i, i + length - 1, n - 1);
		}
	}

	// 一次归并排序
	public static void merge(int[] array, int low, int mid, int high) {
		int[] arrayTemp = new int[high + 1];// 临时表
		int i = low;// 第一段子表的下标
		int j = mid + 1;// 第二段子表的下标
		int k = 0;// 临时表的下标

		while (i <= mid && j <= high) {// 两段子表都没有剩余就循环对比
			if (array[i] <= array[j]) {
				arrayTemp[k] = array[i];
				i++;
				k++;
			} else {
				arrayTemp[k] = array[j];
				j++;
				k++;
			}
		}
		// 第一段子表有剩余
		while (i <= mid) {
			arrayTemp[k] = array[i];
			i++;
			k++;
		}
		// 第二段子表有剩余
		while (j <= high) {
			arrayTemp[k] = array[j];
			j++;
			k++;
		}
		for (k = 0, i = low; i <= high; k++, i++) {
			array[i] = arrayTemp[k];
		}
	}
}

最终排序结果：[5, 17, 24, 38, 38, 47, 52, 69, 73]

【上一篇】常用排序算法之快速排序