【JS】数据结构——排序算法总结

在数据结构的考察中，时常会问到基础的排序算法的复杂度，实现原理等。下面进行梳理总结。

冒泡排序

两次for循环，因此一般在n2的复杂度，很慢。原理是，对相邻元素之间进行比较大小，这也一遍遍下来就会把最大的放在后面，看起来像冒泡一样。

let arr = [1,4,3,5,2,6];

function bubble(arr){
    let len = arr.length;
    //实现一个小到大的排序
    for(let i = 0; i < len - 1;i++){
        for(let j = 0; j < len - 1-i ; j++){
            if(arr[j] < arr[j+1]){
                [arr[j],arr[j+1]] = [arr[j+1],arr[j]];
            }
        }
    }

    return arr;
}

console.log(bubble(arr));

[ 6, 5, 4, 3, 2, 1 ]

选择排序

选择排序大致的思路是找到数据结构中的最小值并将其放置在第一位，接着找到第二小的值并将其放在第二位，以此类推。也就是说要记录和哪个值进行交换，记录下来位置。

function choose(arr){
    let len = arr.length;
    for(let i = 0; i < len-1; i++){
        let min = i;
        for(let j = i+1; j < len-1; j++){
            if(arr[min] > arr[j]){
                min = j;//记录最小值的位置，遍历后进行交换，这就叫做选择
            }
        }
        [arr[i],arr[min]] = [arr[min],arr[i]];
    }
    return arr;
}

插入排序

插入排序就是在前面已经排好顺序的地方找地方进行插入。

function stick(arr){
    let len = arr.length;
    for(let i = 0; i < len -1; i++){
        let temp = arr[i];
        j = i;
        while(j > 0 && arr[j-1] > temp){
            arr[j] = arr[j-1];
            j--;
        }
        arr[j] = temp;
    }
    return arr;
}

归并排序

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) {
        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;
}

mergeSort(arr);
console.log(mergeSort(arr));

快速排序

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

    return quickSort(left).concat(pivot,quickSort(right));
}

var arr1 = [1,5,23,60,80,123,342,0,3,45,60,100,1000,21];
var arr2 = quickSort(arr1);
console.log(arr2 )   //[0, 1, 3, 5, 21, 23, 45, 60, 60, 80, 100, 123, 342, 1000]

堆排序

计数排序

桶排序

希尔排序