1. 冒泡排序
排序思想：判断两个相邻元素，大于则交换位置
复杂度：O(n^2)
例子：[2 4 5 3 1] > [2 4 3 1 5] > [2 3 1 4 5] > 2 1 3 4 5] > [1 2 3 4 5]
// 冒泡排序
function bubbleSort(arr) {
let len = arr.length-1;
for (let i=0; i<len; i++) {
for (let j=0; j<len-i; j++) {
if (arr[j] > arr[j+1]) { // 大于则交换两个的位置
let temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
}
2.选择排序
排序思想： 每次判断，拿到最小值，交换位置
复杂度：O(n^2)
例子：[2 4 5 3 1] > [1 3 5 3 2] > [1 2 5 3 4] > [1 2 3 5 4] > [1 2 3 4 5]
// 选择排序
function selectionSort(arr) {
let len = arr.length;
let minIndex, temp;
for (let i=0; i<len; i++) {
minIndex = i;
for (let j=i+1; j<len; j++) {
if (arr[minIndex] > arr[j]) {
minIndex = j; // 保存最小值索引
}
}
// 进行互换位置
temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
return arr;
}
3. 插入排序
适用与规模小、有序的数据3w-
排序思想：将数组分成两个，一个是已排序好的，一个是待排序的，将待排序的元素和已排序好的元素进行比较，插入适当位置。
复杂度：O(n^2) 有序程度越高，越快
例子：[2] [4 5 3 1] > [2 4] [5 3 1] > [2 4 5] [3 1] > [2 3 4 5] [1] > [1 2 3 4 5]
// 插入排序
function insertionSort(arr) {
let len = arr.length;
let prev, cur;
for (let i = 1; i < len; i++) {
prev = i - 1;
cur = arr[i];
while (prev>=0 && arr[prev]>cur) {
arr[prev+1] = arr[prev];
prev--;
}
arr[prev+1] = cur;
}
return arr;
}
4. 希尔排序
适用于中等规模的数据10万+
排序思想：将数组拆分成不同的间隔，对每个间隔进行插入排序，最后将全部进行一次插入排序
复杂度：O(n^1.5) 有序程度越高，越快
let len = arr.length;
let h = Math.floor(len/2);
// while (h < len / 3) { h = 3 * h + 1 };
while (h >= 1) {
for (let i = h; i < len; i++) {
for (let j = i; j >= h && arr[j] < arr[j - h]; j -= h) {
let t = arr[j];
arr[j] = arr[j - h];
arr[j - h] = t;
}
}
h = Math.round(h / 3);
}
return arr;
5. 归并排序
排序思想：将数组拆分成最小单元，进行比较插入
复杂度：O(nlogn)
例子：[ 2 4 5 3 1] > [2] [4] [5] [3] [1] > [2 4] [5] [3] [1] > [2 4 5] [3] [1] > [2 3 4 5] [1] > [1 2 3 4 5]。从左往右比较合并
// 归并排序
function mergeSort(arr) {
if (arr.length < 2) {
return arr;
}
let middle = Math.floor(arr.length/2);
let left = arr.slice(0, middle);
let right = arr.slice(middle);
return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right) {
let result = [];
while (left.length && right.length) {
if (left[0] <= right[0]) {
result.push(left.shift());
} else {
result.push(right.shift());
}
}
// 不管添加哪个，留下来的就是最大的
while (left.length) {
result.push(left.shift());
}
while (right.length) {
result.push(right.shift());
}
return result;
}
6.快速排序
排序思想：取一个基准值，比基准值小的在左边，大的在右边；左右在继续这样的操作，最后合并。
复杂度：O(nlogn)
例子：[ 2 4 3 5 1 ] > [ 2 1]+[ 3 ]+[ 4 5 ] > [ 1 ]+[ 2 ]+[ 3 ]+[ 4 ]+[ 5 ]
// 快速排序
function quickSort (arr) {
if (arr.length < 2) { // 数组元素只有一个的时候
return arr;
}
let pivotIndex = Math.floor(arr.length/2);
let pivot = arr.splice(pivotIndex,1)[0]; // 基准值
let left = [], // 存放比基准值小的
right = []; // 存放比基准值大的
arr.forEach(item=>{
if (item <= pivot) {
left.push(item);
} else {
right.push(item);
}
})
return quickSort(left).concat([pivot], quickSort(right));
}
7. 计数排序
排序思想：将数组的值当另一个数组的索引，再取出来。典型的空间换时间。
复杂度：O(n+m) m为元素最大值
例子：
function countingSort(arr) {
let bucket = [],
sortedIndex = 0;
arrLen = arr.length;
for (let i = 0; i < arrLen; i++) { // 拿到数组的值当索引
if (!bucket[arr[i]]) {
bucket[arr[i]] = 0;
}
bucket[arr[i]]++;
}
for (let i = 0,len=bucket.length; i < len; i++) {
while(bucket[i] > 0) { // 拿到索引填充到数组中
arr[sortedIndex] = i;
sortedIndex++;
bucket[i]--;
}
}
return arr;
}
8.堆排序
排序思想：先构建一个最大堆，然后循环数组，依次将最大的元素放到末尾
复杂度：O(nlogn)
function heapSort(arr) {
let len = arr.length;
function maxHeapify(i) {
let left = 2 * i + 1;
let right = 2 * i + 2;
let largest = i;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
swap(i, largest);
maxHeapify(largest);
}
}
function swap(i, j) {
let t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
// 构建堆
for (let i = Math.floor(len/2) - 1; i >= 0; i--) {
maxHeapify(i);
}
// 大-> 小
for (let i = arr.length - 1; i > 0; i--) {
swap(0, i);
len--;
maxHeapify(0);
}
/* 小->大
for (let i = 0; i < len; i++) {
maxHeapify(i);
}
*/
return arr;
}
网友评论