算法篇--------排序基础算法

以下算法均使用数据arr作为数据模板，将数据从小到大 

const arr = [23, 34, 12, 23, 2, 45, 0, 4, 23, 1, 444];

冒泡排序

for (let i  =  0;  i < arr.length - 1; i += 1) {
	for (let j = 0; j < arr.length - 1 - i; j += 1) {
		if (arr[j] > arr[j + 1]) {
			 [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
		}
	}
}

// 也可以使用一个flag，如果一次排序flag没有发生变化，说明数组已经是有序的，直接
结束循环。

选择排序：每一次循环要拿到从当前位置开始的最小（大）值，用当前位置的值和其他值作比较

for (let i = 0; i < arr.length - 1; i += 1) {
	let index = i;
	for (let j = i + 1; j < arr.length; j += 1) {
		if (arr[j] < arr[index]) {
			index = j;
		}
	}
	if (index !== i) {
		[arr[index], arr[i]] = [arr[i], arr[index]];
	}
}

插入排序：默认数组第一个元素是有序的，之后每一个元素和它之前的元素比较，确保当前位置之前是有序的

for (let i = 1; i < arr.length; i += 1) {
    if (arr[i] < arr[i - 1]) {
        for (let j = i; j > -1; j -= 1) {
            if (arr[j] < arr[j - 1] && j - 1 > -1) {
                [arr[j], arr[j - 1]] = [arr[j - 1], arr[j]];
            }
        }
    }
}

快速排序

const partion = function (arr, start, end) {
	let left = start,
		right = end;
	const mid = arr[Math.floor((start + end) / 2)];
	while (left < right) {
		while (left <= right && arr[left] < mid) left++;
		while (left <= right && arr[right] > mid) right--;
		if (left <= right) {
			[arr[left], arr[right]] = [arr[right], arr[left]];
			left++;
			right--;
		}
	}
	return left;
};
const quick = function (arr, start, end) {
	let index;
	if (start < end) {
		index = partion(arr, start, end);
		if (start < index) {
			quick(arr, start, index - 1);
		}
		if (index < end) {
			quick(arr, index, end);
		}
	}
};
const quickSort = function (arr) {
	quick(arr, 0, arr.length - 1);
};
quickSort(arr);
console.log(arr, '====');

希尔排序

const xerSort = function (arr) {
	var gap = Math.floor(arr.length / 2);
	while (gap >= 1) {
		// 确保当前位置之前大部分是有序数列
		for (let i = gap; i < arr.length; i += 1) {
			for (let j = i - gap; j > -1; j -= gap) {
				if (arr[j] > arr[j + gap]) [arr[j], arr[j + gap]] = [arr[j + gap], arr[j]];
			}
		}
		gap = Math.floor(gap / 2);
	}
	return arr;
};

归并排序：分治思想，将数组不断二分，各自排好序后再进行（两个有序数组的）合并，是一个稳定的算法

const guiBing = function (arr) {
	const len = arr.length;
	if (len < 2) return arr;
	const mid = Math.floor(arr.length / 2);
	const left = arr.slice(0, mid);
	const right = arr.slice(mid);
	const mergeSortLeft = guiBing(left);
	const mergeSortRight = guiBing(right);
	return mergeSort(mergeSortLeft, mergeSortRight);
};
const mergeSort = function (left, right) {
	let result = [];
	while (left.length && right.length) {
		if (left[0] < right[0]) {
			result.push(left.shift());
		} else {
			result.push(right.shift());
		}
	}
	if (left.length) result = result.concat(left);
	if (right.length) result = result.concat(right);
	return result;
};
console.log(guiBing(arr));`

堆排序：查找数组中第K大的元素

const findKNumber = function (arr, k) {
	const len = arr.length;
	buildHeap(arr, k);  // 构建长度为K的小顶堆
	for (let i = k; i < len; i += 1) {
		if (arr[i] > arr[0]) {
			//	如果原数组中第i个元素比堆顶值大，需要替换堆顶值并重新堆化数据
			arr[0] = arr[i];
			downAdjust(arr, 0, k);
		}
	}
	console.log(arr);
	return arr[0];
};

const buildHeap = function (arr, len) {
	//	从最后一个非叶子节点开始下沉，堆化数据
	for (let i = Math.floor((len - 2) / 2); i >= 0; i -= 1) {
		downAdjust(arr, i, len);
	}
};

const downAdjust = function (arr, index, length) {
	let temp = arr[index];
	let childIndex = 2 * index + 1;
	while (childIndex < length) {
		//	如果左子树小于右子树，切换到右子树
		if (childIndex + 1 < length && arr[childIndex] > arr[childIndex + 1]) {
			childIndex += 1;
		}
		// 如果父节点小于任何一个子节点，跳出循环
		if (temp <= arr[childIndex]) break;
		arr[index] = arr[childIndex];
		index = childIndex;
		childIndex = 2 * childIndex + 1;
	}
	arr[index] = temp;
};
console.log(findKNumber(arr, 2));