前端排序算法

排序算法

冒泡排序

从运行时间来看，冒泡排序是最差的一个，冒泡排序比较任何两个相邻的项，如果第一个比第二个大，则交互位置，元素项向上移动至正确的顺序，就像气泡升至表面一样。他的复杂度是O(n^2)。

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

选择排序

选择排序大体是找到数组中最小的值放在第一位，找到第二小放在第二位，以此类推。他的复杂度是O(n^2)。

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

插入排序

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5。

function insertionSort(arr) {
	let len = arr.length;
	let current, preIndex;
	for (let i = i; i < len; i++) {
		preIndex = i - 1;
		current = arr[i];
		while (preIndex >= 0 && arr[preIndex] > current) {
        	arr[preIndex + 1] = arr[preIndex];
        	preIndex--;
        }
        arr[preIndex + 1] = current;
        return arr;
	}
}

快速排序

1）在数据集之中，选择一个元素作为"基准"。
2）所有小于"基准"的元素，都移到"基准"的左边；所有大于"基准"的元素，都移到"基准"的右边。
3）对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

function quickSort(arr) {
	if (arr.length <= 1) {
    	return arr;
    }
    let midIndex = Math.floor(arr.length / 2);
    let mid = arr.splice(midIndex, 1)[0];
    let left = [];
    let right = [];
    for (let i = 0; i < arr.length; i++) {
		if (arr[i] < mid) {
			left.push(arr[i]);
		} else {
			right.push(arr[i]);
		}
	}
	return quickSort(left).concat([mid], quickSort(right));
}