算法-排序

冒泡排序

冒泡排序比较任何相邻的两个元素，如果第一个比第二个大，则交换他们，元素向上移动至正确的位置，像冒泡一样，因此而得名。复杂度O(n²)

function List(){
	// 辅助函数，交换元素位置
	function swap(id1, id2) {
		const aux = arr[id1];
		arr[id1] = arr[id2];
		arr[id2] = aux;
	}
	const arr = [];
	this.insert = (item) => {
		arr.push(item);
	}
	this.toString = () => {
		return arr.join(',');
	}
	this.BubbleSort = () => {
		const len = arr.length;
		for (let i = 0; i < len; i++) {
			for (let j = 0; j < len - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					swap(j, j + 1);
				}
			}
		}
	}
	// 普通的冒泡排序当程序执行到外循环的第二轮时，已经有正确排序的元素。尽管如此，在后续比较中，他们还会进行着比较。
	// 优化后的冒泡排序，减少运行时间，跳过已排序的元素
	this.ModifiedBubbleSort = () => {
		const len = arr.length;
		for (let i = 0; i < len; i++) {
			for (let j = 0; j < len - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					swap(j, j + 1);
				}
			}
		}
	}
}

选择排序

选择排序是一种原址比较排序。选择数组中最小的值，将其放在第一位，再选择第二小的值，放在第二位，依次类推。

this.selectSort = () => {
	const len = arr.length;
	let indexMin; // 初始化最小值
	for (let i = 0; i < len - 1; i++) {
		indexMin = i; // 设置最小值
		for (let j = i; j < len; j++) {
			if (arr[indexMin] > arr[j]) { // 比较最小值
				indexMin = j;
			}
		}
		if (indexMin !== i) {
			swap(i, indexMin); // 交换位置
		}
	}
}

插入排序

插入排序每次排一个数组项，以此方式构建最后一个数组项。假定第一项已排序，接着和第二项进行比较，判断第二项是需要呆在原位还是排在第一项前面，接着和第三项进项比较，以此类推。

this.insertSort  = () => {
	const len  = arr.length;
	let j;
	let temp;
	for (let i = 1; i < len; i++) {
		j = i;
		temp = arr[i];
		while (j > 0 && arr[j - 1] > temp) {
			arr[j] = arr[j - 1];
			j--;
		}
		arr[j] = temp;
	}
}

归并排序

归并排序是一种分治算法。它将数组分为若干个小数组，直到每个小数组只有一个位置，然后将小数组归并为一个大数组，直到最后只有一个排序后的数组。

this.mergeSort = () => {
	arr = merSortRec(arr);
}
function mergeSordRec(arr) {
	const len = arr.length;
	if (len === 1) {
		return arr;
	}
	const index = Math.floor(len / 2);
	const left = arr.slice(0, index);
	const right = arr.slice(index, len);
	return merge(mergeSordRec(left), mergeSordRec(right));
}
function merge(left, right) {
	const result = [];
	let il = 0;
	let ir = 0;
	while (il < left.length && ir < right.length) {
		if (left[il] < right[ir]) {
			result.push(left[il++]);
		} else {
			result.push(right[ir++]);
		}
	}
	while (il < left.length) {
		result.push(left[il++]);
	}
	while (ir < right.length) {
		result.push(right[ir++]);
	}
	return result;
}