前端js排序算法总结实现

前端js排序算法总结实现

代码底部有测试次数和用时

1.冒泡排序

/*
 * @Descripttion: 
 * @Author: mikasa
 * @Date: 2020-09-18 09:28:39
 */
//从第一个元素开始，把当前元素和下一个索引元素进行比较。如果当前元素大，那么就交换位置，重复操作直到比较到最后一个元素
function bubbleSort(arr){
    //判断数组
    let TimeStart = new Date().getTime()
    if(Array.isArray(arr)){
        for (let i = 0; i < arr.length - 1; i++) {
            for (let j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]){
                    let temp = arr[i];
                    arr[i] = arr[j]
                    arr[j] = temp
                }
            }
        }
    }
    let TimeEnd = new Date().getTime()
    let Spend = TimeEnd - TimeStart
    console.log(Spend+'ms')
    return arr
}
var arr = []
for (let x = 0; x < 100000; x++) {
    arr.push(Math.ceil(Math.random()*100000))
}
console.log(bubbleSort(arr))


//100 1ms
//1000 6ms
//10000 205ms
//100000 15723ms

2.插入排序

/*
 * @Descripttion: 
 * @Author: mikasa
 * @Date: 2020-09-18 10:04:32
 */
//第一个元素默认是已排序元素，取出下一个元素和当前元素比较，如果当前元素大就交换位置。那么此时第一个元素就是当前的最小数，所以下次取出操作从第三个元素开始，向前对比，重复之前的操作。
function insertSort(arr){
    //判断数组
    let TimeStart = new Date().getTime()
    if(Array.isArray(arr)){
       for (let i = 1; i < arr.length; i++) {
            var preIndex = i - 1;
            var current = arr[i]
            while(preIndex >=0 && arr[preIndex] > current){
                arr[preIndex + 1] = arr[preIndex];
                preIndex--;
            }
            arr[preIndex + 1] = current;
       }
    }
    let TimeEnd = new Date().getTime()
    let Spend = TimeEnd - TimeStart
    console.log(Spend+'ms')
    return arr
}
var arr = []
for (let x = 0; x < 100000; x++) {
    arr.push(Math.ceil(Math.random()*100000))
}
console.log(insertSort(arr))


//100 1ms
//1000 5ms
//10000 29ms
//100000 2919ms

3.归并排序

/*
 * @Descripttion: 
 * @Author: mikasa
 * @Date: 2020-09-18 15:41:48
 */

//第一个元素默认是已排序元素，取出下一个元素和当前元素比较，如果当前元素大就交换位置。那么此时第一个元素就是当前的最小数，所以下次取出操作从第三个元素开始，向前对比，重复之前的操作。
function mergeSort(arr){
    //判断数组
    var len = arr.length;
    if (len < 2) {
      return arr;
    }
    var middle = Math.floor(len / 2),
      left = arr.slice(0, middle),
      right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
    var result = [];
    while (left.length && right.length) {
      // 不断比较left和right数组的第一项，小的取出存入res
      left[0] < right[0] ? result.push(left.shift()) : result.push(right.shift());
    }

    return result.concat(left, right);
  }
var arr = []
for (let x = 0; x < 100; x++) {
    arr.push(Math.ceil(Math.random()*100))
}
let TimeStart = new Date().getTime()
console.log(mergeSort(arr))
let TimeEnd = new Date().getTime()
let Spend = TimeEnd - TimeStart
console.log(Spend+'ms')


//100 18ms
//1000 17ms
//10000 26ms
//100000 1169ms

4.快速排序

/*
 * @Descripttion: 
 * @Author: mikasa
 * @Date: 2020-09-18 13:58:45
 */


//在数据集之中，找一个基准点，建立两个数组，分别存储左边和右边的数组，利用递归进行下次比较。
function quickSort(arr){
    //判断数组
    //判断
    if(!Array.isArray(arr)) return;
    if(arr.length <= 1){

        return arr;
    }
    //分开
    var left = [], right = [];
    //取出中间靠左
    var num = Math.floor(arr.length / 2);
    //取中间
    var numValue = arr.splice(num, 1)[0];
    //大的放右边 小的放左边
    for (let i = 0; i < arr.length; i++) {
        if(arr[i] > numValue){
            right.push(arr[i])
        }else{
            left.push(arr[i])
        }
    }
    return [...quickSort(left), numValue, ...quickSort(right)]
}
var arr = []
for (let x = 0; x < 100; x++) {
    arr.push(Math.ceil(Math.random()*100))
}

let TimeStart = new Date().getTime()
console.log(quickSort(arr))
let TimeEnd = new Date().getTime()
let Spend = TimeEnd - TimeStart
console.log(Spend+'ms')


//100 13ms
//1000 15ms
//10000 24ms
//100000 77ms
//1000000 576ms

5.希尔排序

/*
 * @Descripttion: 
 * @Author: mikasa
 * @Date: 2020-09-18 14:22:06
 */
//选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
//按增量序列个数 k，对序列进行 k 趟排序；
//每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，
//分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
function shellSort(arr){
    //判断数组
    let TimeStart = new Date().getTime()
    var len = arr.length,temp,gap = 1;
    while (gap < len / 5) {
        gap = gap * 5 + 1;
    }
    console.log(gap)
    for (gap; gap > 0; gap = Math.floor(gap / 5)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i - gap; j >= 0 && arr[j] > temp; j -= gap) {
              arr[j + gap] = arr[j];
            }
            arr[j + gap] = temp;
        }
    }
    let TimeEnd = new Date().getTime()
    let Spend = TimeEnd - TimeStart
    console.log(Spend+'ms')
    return arr
}
var arr = []
for (let x = 0; x < 1000; x++) {
    arr.push(Math.ceil(Math.random()*1000))
}
console.log(shellSort(arr))


//100 0ms
//1000 4ms
//10000 7ms
//100000 17ms
//1000000 238ms

6.选择排序

/*
 * @Descripttion: 
 * @Author: mikasa
 * @Date: 2020-09-18 13:47:02
 */

//遍历数组，设置最小值的索引为 0，如果取出的值比当前最小值小，就替换最小值索引，遍历完成后，将第一个元素和最小值索引上的值交换。如上操作后，第一个元素就是数组中的最小值，下次遍历就可以从索引 1 开始重复上述操作
function selectSort(arr){
    //判断数组
    let TimeStart = new Date().getTime()
    if(Array.isArray(arr)){
        for (let i = 0; i < arr.length - 1; i++) {
           var minIndex = i
           for (let j = i+1; j < arr.length; j++) {
               if(arr[minIndex] > arr[j]){
                    minIndex = j
               }
           }
           let temp = arr[i]
           arr[i] = arr[minIndex]
           arr[minIndex] = temp
        }
    }
    let TimeEnd = new Date().getTime()
    let Spend = TimeEnd - TimeStart
    console.log(Spend+'ms')
    return arr
}
var arr = []
for (let x = 0; x < 100000; x++) {
    arr.push(Math.ceil(Math.random()*100000))
}
console.log(selectSort(arr))


//100 1ms
//1000 4ms
//1000 43ms
//10000 4084ms