feat: 归并排序

Author: ScoutYin

leetcode/排序/归并排序/mergeSort1.js

@@ -0,0 +1,61 @@
+/**
+ * 递归法（自顶向下）
+ * 返回新数组
+ * 这个方法在代码上理解起来更容易
+ * 但是需要开辟left和right数组的内存空间，且排序后的是一个新数组，非原数组
+ */
+
+/**
+ * 归并排序
+ * 1、将包含n个数字的数组分成n个子数组，每个子数组中仅有一项，此时可认为它是有序的
+ * 2、两个有序的子数组两两合并，得到一个有序的数组
+ * 3、重复进行2步骤，最终得到一个数组，这个数组就是有序的
+ */
+
+/**
+ * 合并两个子序列
+ */
+const merge = (left, right) => {
+	const result = [];
+
+	while (left.length && right.length) {
+		// 因为left和right都是有序的，比较两个数组中谁的头部数字小，就先放进结果数组，保证result是从小到大的顺序
+		if (left[0] < right[0]) {
+			result.push(left.shift());
+		} else {
+			result.push(right.shift());
+		}
+	}
+
+	// 当一个数组已经空了，就把另一个数组依次push进result中
+	while (left.length) {
+		result.push(left.shift());
+	}
+
+	while (right.length) {
+		result.push(right.shift());
+	}
+
+	return result;
+};
+
+const mergeSort = (arr) => {
+	const len = arr.length;
+	// 如果仅有1项或者0项，无需排序
+	if (len < 2) return arr;
+
+	// 在中间位置，将序列分成两个子序列
+	const mid = Math.floor(len / 2);
+	const left = arr.slice(0, mid);
+	const right = arr.slice(mid);
+
+	// 使两个子数组有序，
+	// 再将这两个有序子数组合并成一个有序的数组
+	return merge(mergeSort(left), mergeSort(right));
+};
+
+// test case:
+const arr = Array.from({ length: 30 }).map(() =>
+	Math.floor(Math.random() * 1000)
+);
+console.log(mergeSort(arr));

leetcode/排序/归并排序/mergeSort2.js

@@ -0,0 +1,63 @@
+/**
+ * 递归法（自顶向下）
+ * 对原数组排序（不返回新数组）
+ */
+
+/**
+ * 合并两个子序列
+ * 子序列是数组中的[left, right]区间内以mid为界被分开的两个子序列
+ */
+const merge = (arr, left, mid, right) => {
+	let i = left;
+	let j = mid + 1;
+	// 用于临时存放合并好的结果
+	const result = [];
+
+	// 判断两个子序列的头部元素，哪个更小，就优先放进result数组
+	while (i <= mid && j <= right) {
+		if (arr[i] <= arr[j]) {
+			result.push(arr[i++]);
+		} else {
+			result.push(arr[j++]);
+		}
+	}
+
+	// 将剩下的一个子序列中的剩余元素依次放进result数组
+	while (i <= mid) {
+		result.push(arr[i++]);
+	}
+	while (j <= right) {
+		result.push(arr[j++]);
+	}
+
+	// 将result中保存的元素依次复制到arr中的对应位置
+	// 此处我们从后往前复制
+	while (right >= left) {
+		arr[right] = result[right - left];
+		right--;
+	}
+};
+
+const sort = (arr, left, right) => {
+	// 如果子序列仅有1项或者0项，无需排序
+	if (right <= left) return;
+
+	const mid = left + Math.floor((right - left) / 2);
+
+	// 使两个子数组有序，
+	sort(arr, left, mid);
+	sort(arr, mid + 1, right);
+	// 再将这两个有序的子序列合并成一个大的有序序列
+	merge(arr, left, mid, right);
+};
+
+const mergeSort = (arr) => {
+	sort(arr, 0, arr.length - 1);
+};
+
+// test case:
+const arr = Array.from({ length: 30 }).map(() =>
+	Math.floor(Math.random() * 1000)
+);
+mergeSort(arr);
+console.log(arr);

leetcode/排序/归并排序/mergeSort3.js

@@ -0,0 +1,71 @@
+/**
+ * 迭代法（自底向上）
+ */
+
+/**
+ * 合并两个子序列
+ * 子序列是数组中的[left, right]区间内以mid为界被分开的两个子序列
+ */
+const merge = (arr, left, mid, right) => {
+	let i = left;
+	let j = mid + 1;
+	// 用于临时存放合并好的结果
+	const result = [];
+
+	// 判断两个子序列的头部元素，哪个更小，就优先放进result数组
+	while (i <= mid && j <= right) {
+		if (arr[i] <= arr[j]) {
+			result.push(arr[i++]);
+		} else {
+			result.push(arr[j++]);
+		}
+	}
+
+	// 将剩下的一个子序列中的剩余元素依次放进result数组
+	while (i <= mid) {
+		result.push(arr[i++]);
+	}
+	while (j <= right) {
+		result.push(arr[j++]);
+	}
+
+	// 将result中保存的元素依次复制到arr中的对应位置
+	// 此处我们从后往前复制
+	while (right >= left) {
+		arr[right] = result[right - left];
+		right--;
+	}
+};
+
+const mergeSort = (arr) => {
+	const len = arr.length;
+	if (len < 2) return;
+
+	// 子序列元素个数，为1时，子序列仅有1个元素，如[3]和[5]合并，以此类推
+	let k = 1;
+
+	while (k < len) {
+		// 两个完整子序列（完整：子序列元素个数为k）合并完后的元素个数
+		const count = 2 * k;
+		let i;
+		// i < len - count是为了保证在这个for循环中的合并都是完整子序列合并
+		for (i = 0; i < len - count; i += count) {
+			merge(arr, i, i + k - 1, i + count - 1);
+		}
+
+		// 最后可能存在一个子序列，则不需要合并，因为每个子序列已是有序的；
+		// 最后如果存在两个子序列（i + k < len 的情况），两个子序列可能不全是完整子序列，比如[3,5,8,16]和[2,7]，
+		// 如果按照上面的for循环中right传入i + count - 1的话，将会超出arr的长度，故单独处理
+		if (i + k < len) {
+			merge(arr, i, i + k - 1, len - 1);
+		}
+		k *= 2;
+	}
+};
+
+// test case:
+const arr = Array.from({ length: 90 }).map(() =>
+	Math.floor(Math.random() * 1000)
+);
+mergeSort(arr);
+console.log(arr);