js排序算法

1. 冒泡排序

思想：

比较相邻的两个元素，如前一个比后一个大，则交换位置

第一轮的最后一个元素应该是最大的元素

按照步骤1的方法比较相邻两个元素，这个时候因为最后一个元素已经是最大的了，所以最后一个元素不用比较

总共比较 n-1次

双重循环，所以平均复杂度和最坏的复杂度均是是O(n^2)，最好的情况是已经排好序的，所以只遍历一次就可以了，所以是O(n)

代码

function sort(arr) {  

    for (let i = 0; i < arr.length - 1; i++) {

        for (let j = 0; j < arr.length - i -1; j++) {

            if(arr[j] > arr[j+1]){

                [arr[j],arr[j+1]] = [arr[j+1],arr[j]]

            }

        }

    }

}

var arr = [3,1,5,7,2,4,9,6]

console.log('排序前：'+arr);

sort(arr)

console.log('排序后:'+arr);

 

2. 快速排序

快排的思想：

通过一趟排序将待排记录分成独立的两个部分，左边元素均比枢纽元素小，右边元素均比枢纽元素大，之后再对这两部分继续排序，直到整个序列有序。（面试有问到）

其实该排序有三种思路，以下的代码是第三种思路，也就是根据阮一峰老师的思路写的

function sort(arr) {  

    if(arr.length <= 1){

        return arr

    }

    var mid = parseInt(arr.length / 2)

    var left = [],right = []

    var pivot = arr.splice(mid,1)[0]

    arr.forEach(item => {

        if(item < pivot){

            left.push(item)

        }else {

            right.push(item)

        }

    })

    return sort(left).concat([pivot],sort(right))

}

var arr = [3,1,5,7,2,4,9,6]

console.log('排序前：'+arr);

console.log('排序后:'+sort(arr));

 

该方法并不是原地排序。并没有改变原数组，而是将排好序的元素组返回成一个新数组。

若想改变元素组，可以采取第一种思路，双指针

function sort(arr, from, to) {

    var i = from, j = to, pivot = arr[from]

    if(from >= to) return

    while (i < j) {

        while (i < j && arr[j] > pivot) {

            --j

        }

        while (i < j && arr[i] < pivot) {

            ++i

        }

        if (i < j) {

            [arr[i], arr[j]] = [arr[j], arr[i]]

        }

    }

    [arr[i], pivot] = [pivot, arr[i]]

    sort(arr, from, i-1)

    sort(arr, i + 1, to)

}

var arr = [3, 1, 5, 7, 2, 4, 9, 6]

console.log('排序前：' + arr);

sort(arr,0,arr.length-1)

console.log('排序后:' + arr);

 

时间复杂度最好和平均均为O(nlgn)，最坏为O(n^2)

至于为什么是这样，可以参考这篇博客：快速排序时间复杂度为O（n×log（n））的证明

 

3. 选择排序

时间复杂度均为O(n^2)

var arr = [3,5,8,5,2,9]

var index = 0

for(var i = 0;i<arr.length-1;++i){

    index = i

    for(var j = i+1;j<arr.length;++j){

        if(arr[j] < arr[index]){

            index = j//保存最小值的索引

        }

    }

    // 如果没变的话，那就不用交换

    if(index !== i){

        [arr[i],arr[index]] = [arr[index],arr[i]]

    }

}

console.log(arr);