js的几种常见的算法排序总结

冒泡排序

思想：

比较相邻的两个元素的大小，顺序如果相反的话则进行交换，这样的话每次循环都可以将最小的或者最大的元素放到后面，最终达到排序的效果（可升序可降序）

代码实现

var array = [3, 4, 1, 5, 2, 45, 1, 23]
function bubbleSort(arr) {
    // 数组的长度小于或等于1,或不是一个数组时不需要排序 ，直接返回数组
    if (arr.length <= 1 || !Array.isArray(arr)) return arr
    for (var i = 0; i < arr.length; i++) {
        for (var j = 0; j < arr.length - i; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换顺序
                var change = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = change
            }
        }
    }
    return arr
}
console.log(bubbleSort(array))

优化方法：
如果在进行某一次循环时，内部元素没有发生交换，则说明排序已经完成，没有必要再进行后面的操作，直接可以终止循环。

选择排序

思想

从未排序的序列中找到最大或者最小的元素，放到元素的未排序的头部，重复后达到排序的目的

代码实现

var array = [3, 4, 1, 5, 2, 45, 1, 23]
function chooseSort(arr) {
    // 数组的长度小于或等于1,或不是一个数组时不需要排序 ，直接返回数组
    if (arr.length <= 1 || !Array.isArray(arr)) return arr
    for (var i = 0; i < arr.length; i++) {
        var index = i
        for (var j = i; j < arr.length; j++) {
            if (arr[index] > arr[j]) {
                index = j
            }
        }
        if (index !== i) {
            // 说明找到了更小或者更大的元素，则进行位置的交换
            var change = arr[index]
            arr[index] = arr[i]
            arr[i] = change
        }
    }
    return arr
}

console.log(chooseSort(array))

插入排序

思想

抽取的第一个元素开始，第一个元素默认已经排好序，下一个元素开始和第一个元素进行比较，如果小于第一个元素 则扫描这个元素的前面所有元素进行换位放到前面，依次类推，最终达成排序。

代码实现

function insertSort(arr) {
    // 数组的长度小于或等于1,或不是一个数组时不需要排序 ，直接返回数组
    if (arr.length <= 1 || !Array.isArray(arr)) return arr
    var change;
    // 从第二个元素开始遍历，依次和前面的元素进行比较
    for (var i = 1; i < arr.length; i++) {
        // 设置默认将要被替换的元素
        change = arr[i]
        var j = i
        for (j = i; j > 0 && arr[j - 1] > change; j--) {
            // 当前值和之前的每个值进行比较，发现有比当前值小的值就进行重新赋值
            arr[j] = arr[j - 1]
        }
        arr[j] = change
    }
    return arr
}
console.log(insertSort(array))

归并排序

思想

将数组从中间拆分成一个个小的数组，直到拆分到数组的元素为一个为止，然后将拆分后的数组按照数组有序数组的过程进行排序，直到合成一个新的数组

代码实现

function mergeSort(arr) {
    // 数组的长度小于或等于1,或不是一个数组时不需要排序 ，直接返回数组
    if (arr.length <= 1 || !Array.isArray(arr)) return arr
    var mid = Math.floor(arr.length / 2)
    var left = arr.slice(0, mid)
    var right = arr.slice(mid)
    return Merge(mergeSort(left), mergeSort(right))
}
function Merge(leftArr, rightArr) {
    var result = []
    var leftIndex = 0
    var rightIndex = 0
    while (leftIndex < leftArr.length && rightIndex < rightArr.length) {
        if (leftArr[leftIndex] > rightArr[rightIndex]) {
            result.push(rightArr[rightIndex++])
        } else {
            result.push(leftArr[leftIndex++])
        }
    }
    // 如果是左边数组还有剩余，则把剩余的元素全部加入到结果数组中。 
    while (leftIndex < leftArr.length) {
        result.push(leftArr[leftIndex++])
    }
    while (rightIndex < rightArr.length) {
        result.push(rightArr[rightIndex++])
    }
    return result
}

console.log(mergeSort(array))

快速排序

思想

找到一个基准值，与他比较，比他小的放左边，大的放右边，再递归比较，最后得出结果。

代码实现

var arr2 = [3, 6, 1, 45,1, 4,23]
function quickSort(arr){
    if (arr.length <= 1) {
        return arr;
    }
    var midIndex = parseInt(arr.length/2),
        left = [],
        right = []
        // 取出中间元素
    var midItem = arr.splice(midIndex,1)[0];
    for(var i=0;i<arr.length;i++){
        if(arr[i]>midItem){
           right.push(arr[i])
        }else{
            left.push(arr[i])
        }
    }
    // 最后返回连结左边部分数组 基准值 和右边数组组合的数组
    return quickSort(left).concat([midItem],quickSort(right))

}
console.log(quickSort(arr2))