归并排序 以及面试题

归并排序时间复杂度：O（N*logN）

解法1：递归

思路：递归拆分每次分成两个，分到不能再分，分别排序有序然后再合并

/**
	 * 归并排序
	 * @param arr
	 */
	public static void mergeSort1(int[] arr ){
		//判断 是否需要排序
		if(arr.length<2){
			return;
		}
		proess(arr,0,arr.length-1);

	}

	/**
	 * 递归分左右并且合并
	 * @param arr
	 * @param L
	 * @param R
	 */
	private static void proess(int[] arr, int L, int R) {
		//首先判断是否还可分
		if(L>=R){
			return;
		}
		//算中间
		int mid = L+(R-L)>>1;
		//左半部分拆分
		proess(arr,L,mid);
		//有半部分拆分
		proess(arr,mid+1,R);
		//合并
		merge(arr,L,mid,R);
	}

	/**
	 * 合并
	 * @param arr
	 * @param l
	 * @param mid
	 * @param r
	 */
	private static void merge(int[] arr, int l, int mid, int r) {

		//思路 使用 一个数组，将合并的放到数组上，然后再复制回去
		//1   创建数组  这里 5到10 10-5 = 5 但是排序是 5，6，7，8，9，10 6个数
		//因为前面有限定，所以这里最少又2个数字 例如 7-8  7-8 = 1 也需要加1
		int[] helpArr = new int[]{r-l+1};

		//2  合并 l到mid 和mid+1 到r 的两个数组比较并
		int p1= l;
		int p2 = mid+1;
		int i = 0;
		// 用小于等于 因为最后一个数 mid 和 r 也要比
		while (p1<=mid&&p2<=r){
			//比较需要合并的数组 谁小就放在helparr里  这里<=可以让一样的数顺序不变
			helpArr[i++] = arr[p1] <= arr[p2]?arr[p1++]:arr[p2++];
		}
		//合并L-min剩下的
		while (p1<=mid){
			helpArr[i++] = arr[p1++];
		}
		//合并min-R剩下的
		while (p2<=r){
			helpArr[i++] = arr[p2++];
		}
		//复制会原来的数组
		for (int j = 0; j < helpArr.length ; j++) {
			arr[l+j] = helpArr[j];
		}
	}

解法2：非递归

思路：步长从2开始 每次步长增长2的次方，每次步长都进行merge排序。

// 非递归方法实现
	public static void mergeSort2(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		int N = arr.length;
		// 步长
		int mergeSize = 1;
		while (mergeSize < N) { // log N
			// 当前左组的，第一个位置
			int L = 0;
			while (L < N) {
				if (mergeSize >= N - L) {
					break;
				}
				int M = L + mergeSize - 1;
				int R = M + Math.min(mergeSize, N - M - 1);
				merge(arr, L, M, R);
				L = R + 1;
			}
			// 防止溢出
			if (mergeSize > N / 2) {
				break;
			}
			mergeSize <<= 1;
		}
	}

验证代码：

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		System.out.println("测试开始");
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			mergeSort1(arr1);
			mergeSort2(arr2);
			if (!isEqual(arr1, arr2)) {
				System.out.println("出错了！");
				printArray(arr1);
				printArray(arr2);
				break;
			}
		}
		System.out.println("测试结束");
	}