0. 比较函数
const COMPARE = {
LESS_THAN: '-1',
EQUALITY: '0',
BIGGER_THAN: '1'
}
const defaultCompareFn = (a, b) => {
if (a > b) {
return COMPARE.BIGGER_THAN;
}
else if (a === b) {
return COMPARE.EQUALITY;
}
else {
return COMPARE.LESS_THAN;
}
}
1. 冒泡排序
比较所有相邻的两个元素的大小,如果第一个元素大于第二个元素则交换这两个元素的位置。
const bubbleSort = (array, compareFn = defaultCompareFn) => {
if (!Array.isArray(array)) return false;
let len = array.length;
for (let i = 0; i < len; i++) {
for (let j = 0; j < len-i-1; j++) {
if (compareFn(array[j], array[j + 1]) === COMPARE.BIGGER_THAN) {
[array[j], array[j + 1]] = [array[j + 1], array[j]];
}
}
}
return array;
}
console.log('bubbleSort:', bubbleSort([5, 6, 2, 4, 5, 7,19, 0, 45, 8]));
2. 选择排序
找出数组中的最小值,放在数组中的第一个位置,找出数组中第二小的值,放在数组中的第二个位置,以此类推…
找出最小值所在的索引,与数组中的第一个元素交换位置,依次类推…
const selectionSort = (array, compareFn = defaultCompareFn) => {
if (!Array.isArray(array)) return false;
const { length: len } = array;
for (let i = 0; i < len; i++) {
let minIndex = i;
for (let j = i; j < len; j++) {
if (compareFn(array[minIndex], array[j]) === COMPARE.BIGGER_THAN) {
minIndex = j;
}
}
if (minIndex !== i) {
[array[i], array[minIndex]] = [array[minIndex], array[i]];
}
}
return array;
}
3. 插入排序
将第二个元素和第一个元素排序、将第三个元素和前两个元素排序、将第四个元素和前三个元素排序,以此类推…
对于小型数组来说这种排序方式效率要比冒泡排序和选择排序效率高。
const insertionSort = (array, compareFn = defaultCompareFn) => {
if (!Array.isArray(array)) return false;
const { length: len } = array;
for (let i = 1; i < len; i++) {
let j = i;
const temp = array[i];
while (j > 0 && compareFn(array[j - 1], temp) === COMPARE.BIGGER_THAN) {
array[j] = array[j - 1];
j--;
}
array[j] = temp;
}
return array;
}
4. 归并排序
归并排序是第一个可以实际使用的排序方法,前面三种排序方法性能都不好。
采取分而治之的方式,将一个大数组从中间切分成小数组,直到小数组长度为1,然后对被切分的两个小数组进行排序,组成排序后的大数组,依次类推…
// 小数组排序,返回排序后的大数组
const merge = (left, right, compareFn = defaultCompareFn) => {
let i = 0;
let j = 0;
const result = [];
while(i < left.length && j < right.length) {
result.push(
compareFn(left[i], right[j]) === COMPARE.BIGGER_THAN ?
right[j++] :
left[i++]
)
}
return result.concat(i >= left.length ? right.slice(j) : left.slice(i));
}
// 主题函数
const mergeSort = (array, compareFn = defaultCompareFn) => {
if (!Array.isArray(array)) return [];
const { length: len } = array;
if (len > 1) {
const middle = Math.floor(len / 2);
const left = mergeSort(array.slice(0, middle), compareFn);
const right = mergeSort(array.slice(middle, len), compareFn);
array = merge(left, right, compareFn);
}
return array;
}
5. 快速排序
快速排序也是一种分而治之的方式实现的排序方法。
-
选取中间值作为主元(pivot)
-
划分操作:选取最左边的索引作为左指针,最右边的索引作为右指针。移动左指针知道找到一个比主元大的值,在移动右指针,知道找到一个比主元小的值,然后交换他们, 直到左侧的指针超过右侧的指针,这个过程中是的,左指针前面的值都小于左指针以及左指针后面的值。
-
对划分后的两个数组进行上面两个步骤操作,直到数组已经完全排序。
// 主函数
function quickSort(array, compareFn = defaultCompareFn) {
if (!Array.isArray(array)) return false;
return quick(array, 0, array.length - 1, compareFn);
}
// 递归函数
function quick(array, left, right, compareFn = defaultCompareFn) {
if (array.length > 1) {
const index = partition(array, left, right, compareFn);
if (left < index - 1) {
array = quick(array, left, index - 1, compareFn);
}
if (index < right) {
array = quick(array, index, right, compareFn);
}
}
return array;
}
// 划分方法
function partition(array, left, right, compareFn) {
const pivot = array[Math.floor((left + right) / 2)];
let i = left;
let j = right;
while (i <= j) {
while (compareFn(array[i], pivot) === COMPARE.LESS_THAN) {
i++;
}
while(compareFn(array[j], pivot) === COMPARE.BIGGER_THAN) {
j--;
}
if (i <= j) {
[array[i], array[j]] = [array[j], array[i]];
i++;
j--;
}
}
return i;
}
6. 计数算法
这是一个分布式排序算法,对于整数来说是一种优秀算法。
使用一个临时数组来储存原始数组中的元素出现的次数,这个临时数组是以原始数组中的元素作为索引,元素出现的次数作为值,临时数组创建完毕后,原始数组中不重复的元素已经排序好了,直接循环临时数组,生成排好序的数组就好。
// 主函数
function countingSort(array) {
if (!Array.isArray(array)) return false;
if (array.length < 2) return array;
const maxValue = findMaxValue(array);
const counts = new Array(maxValue + 1);
array.forEach(element => {
if (!counts[element]) {
counts[element] = 0;
}
counts[element]++;
});
let sortIndex = 0;
counts.forEach((count, i) => {
while (count > 0) {
array[sortIndex++] = i;
count--;
}
})
return array;
}
// 查找数组中的最大值
function findMaxValue(array) {
let maxValue = array[0];
for (let i = 1; i < array.length; i++) {
if (array[i] > maxValue) maxValue = array[i];
}
return maxValue;
}
7. 桶排序
桶排序也是一种分布式排序算法,将数组划分到不同的桶中,对桶中的小数组进行排序,在组合成排序后的数组。
// 主函数
function bucketSort(array) {
if (array.length < 2) return array;
const buckets = createBuckets(array, 3);
return sortBuckets(buckets);
}
// 划分数组
function createBuckets(array, bucketSize = 3) {
const { length } = array;
if (array.length < 2) return array;
let minValue = array[0];
let maxValue = array[0];
for (let i = 1; i < length; i++) {
if (array[i] < minValue) minValue = array[i];
if (array[i] > maxValue) maxValue = array[i];
}
const buckets = [];
// 桶的数量
const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
for (let i = 0; i < bucketCount; i++) {
buckets[i] = [];
}
for (let i = 0; i < length; i++) {
const bucketIndex = Math.floor((array[i] - minValue) / bucketSize);
buckets[bucketIndex].push(array[i]);
}
return buckets;
}
// 对小数组排序,组合成排序好的大数组
function sortBuckets(buckets) {
const sortedArray = [];
for (let i = 0; i < buckets.length; i++) {
if (buckets[i] != null) {
insertionSort(buckets[i]);
sortedArray.push(...buckets[i]);
}
}
return sortedArray;
}
8. 基数排序
- 基于每个有效位上的数组进行计数排序,和计数排序不同的地方在于,索引是有效位上的数字,值是有效数字出现的次数。
- 对临时数组中的值,进行累计处理,当前值变成当前值加上上一个值,使每个有效数字出现的次数基于上个有效数字做累计。
- 每次对数组进行排序时,先获取有效数字,在临时数组中获取累计处理后的值作为索引,对数组进行排序。
function radixSort(array, radix = 10) {
if (array.length < 2) return array;
let minValue = array[0];
let maxValue = array[0];
let sign = 1;
for (let i = 0; i < array.length; i++) {
if (array[i] < minValue) minValue = array[i];
if (array[i] > maxValue) maxValue = array[i];
}
while (Math.floor((maxValue - minValue) / sign) >= 1) {
array = countingRadixSort(array, sign, minValue, radix);
sign *= radix;
}
return array;
}
function countingRadixSort(array, sign, minValue = 0, radix = 10) {
let bucketIndex;
// 保存计数的临时数据
const buckets = [];
const aux = [];
for (let i = 0; i < radix; i++) {
buckets[i] = 0;
}
for (let i = 0; i < array.length; i++) {
bucketIndex = Math.floor((array[i] - minValue) / sign) % radix;
buckets[bucketIndex]++;
}
// 累计处理
for (let i = 1; i < radix; i++) {
buckets[i] += buckets[i - 1];
}
for (let i = array.length - 1; i >= 0; i--) {
bucketIndex = Math.floor((array[i] - minValue) / sign) % radix;
aux[--buckets[bucketIndex]] = array[i];
}
for (let i = 0; i < aux.length; i++) {
array[i] = aux[i];
}
return array;
}