数组排序

 

 

选择排序

基本思想：每次选择待排序的元素中最小的值，放置在序列的首位

function directSelectSort(arr) {
for (let i = 0; i < arr.length; i++) {
let min = arr[i]
let index = i
for (let j = i + 1; j < arr.length; j++) {
if (arr[j] < min) {
// 找到最小值，并标注最小值索引，方便后续与元素arr[i]交换位置
min = arr[j]
index = j
}
}
arr[index] = arr[i]
arr[i] = min
}
return arr
}
console.log(directSelectSort([7, 3, 4, 5, 10, 7, 8, 2]))

 

冒泡排序

基本思想：每次比较两相邻的数,当发现它们的排序与排序要求相反时，就将它们互换。这样小的数往下沉，大的数往上冒

function bubbleSort(arr) {
for (let i = 0; i < arr.length; i++) {
// 因为每次比较时都已经有i个元素沉下去了，所以j<arr.length-1-i
for (let j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
// 这里采用了解构赋值。如果一般做法，借助临时变量，则辅助空间是O(1)
;[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
}
}
}
return arr
}
console.log(bubbleSort([7, 3, 4, 5, 10, 7, 8, 2]))

 

快速排序

基本思想：选择一个基准元素(通常选择第一个元素)，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有元素都比基准元素小，另外一部分的所有元素大于或等于基准元素大。同样方法依次分割；整个排序过程可以递归进行。

let quicksort = function(arr) {
if(arr.length <= 1) return arr;

let pivot = Math.floor((arr.length -1)/2);
let val = arr[pivot], less = [], more = [];

arr.splice(pivot, 1);
arr.forEach(function(e,i,a){
e < val ? less.push(e) : more.push(e);
});

return (quicksort(less)).concat([val],quicksort(more))
}
console.log(quicksort([7, 3, 4, 5, 10, 7, 8, 2]))

 

插入排序

基本思想：在序号i之前的元素(0到i-1)已经排好序，本趟需要找到i对应的元素x (此时即arr[i]) 的正确位置k,在寻找位置k的过程中与序号i-1到0的元素依次进行比较。如果x小于比较元素，则比较元素向后移动一位；否则，结束移位，将x插入当前位置k

function insertSort(arr) {
for (let i = 1; i < arr.length; i++) {
// 将待插入元素提取出来
let temp = arr[i]
let j
for (j = i - 1; j >= 0; j--) {
if (arr[j] > temp) {
// 插入元素小于比较元素，比较元素则向后移动一位
arr[j + 1] = arr[j]
} else {
// 否则，结束移位
break
}
}
//将插入元素插入正确位置
arr[j + 1] = temp
}
return arr
}
console.log(insertSort([7, 3, 4, 5, 10, 7, 8, 2]))

 

归并排序

基本思想:将待排序序列分为若干个子序列，每个子序列是有序的，然后将有序子序列合并为整体有序序列。

function merge(left, right) {
let result = []
while (left.length > 0 && right.length > 0) {
if (left[0] < right[0]) {
/*shift()方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。*/
result.push(left.shift())
} else {
result.push(right.shift())
}
}
return result.concat(left).concat(right)
}
function mergeSort(arr) {
if (arr.length == 1) {
return arr
}
let middle = Math.floor(arr.length / 2),
left = arr.slice(0, middle),
right = arr.slice(middle)
return merge(mergeSort(left), mergeSort(right))
}
console.log(mergeSort([7, 3, 4, 5, 10, 7, 8, 2]))

 

希尔排序

基本思想：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

function shellSort(arr) {
let d = arr.length
while (true) {
d = Math.floor(d / 2)
for (let x = 0; x < d; x++) {
for (let i = x + d; i < arr.length; i = i + d) {
let temp = arr[i]
let j
for (j = i - d; j >= 0 && arr[j] > temp; j = j - d) {
arr[j + d] = arr[j]
}
arr[j + d] = temp
}
}
if (d == 1) {
break
}
}
return arr
}
console.log(shellSort([7, 3, 4, 5, 10, 7, 8, 2]))