js学习笔记之排序算法的原理及代码

冒泡排序

比较任何两个相邻的项，如果第一个比第二个大，则交换它们

重复这样的操作，直到排序完成，具体代码如下：

let arr = [67,23,11,89,45,76,56,99]
function bubbleSort ( data ) {
    var temp = 0;
    for ( var i = data.length ; i > 0 ; i -- ){
        for( var j = 0 ; j < i - 1 ; j++){
           if( data[j] > data[j + 1] ){
               temp = data[j];
               data[j] = data [j+1];
               data[j+1] = temp;
           }
        }
    }
    return data;
}
console.log(bubbleSort(arr))

 

选择排序

找到数据结构中的最小值并 将其放置在第一位，接着找到第二小的值并将其放在第二位，以此类推。具体代码如下：

let arr = [67,23,11,89,45,76,56,99]
function selectionSort (data) {
    let indexMin
    for (let i = 0; i < data.length - 1; i++){
        indexMin = i
        for (var j = i; j < data.length; j++){ 
            if(data[indexMin] > data[j]) {
                indexMin = j
            }
        } 
        if (i !== indexMin){
            let aux = data[i]
            data[i] = data[indexMin]
            data[indexMin] = aux
        }
    }
    return data
}
console.log(selectionSort(arr))

 

插入排序

依次循环每个数组元素，对比当前数组元素在已经排好的数组元素中处于什么位置，并插入。具体代码如下：

let arr = [67,23,11,89,45,76,56,99]
function insertionSort( data ) {
    var len = data.length;
    for (var i = 1; i < len; i++) {
        var key = data[i];
        var j = i - 1;
        while ( j >= 0 && data[j] > key) {
            data[j + 1] = data[j];
            j--;
        }
        data[j + 1] = key;
    }
    return data;
}
console.log(insertionSort(arr))

 

归并排序

把数组从中间拆分成左右两部分，然后把左右两部分再拆分，直到拆分的数组中只有一个元素。

拆分完后再将拆分的数组依次合并成有序数组，合并到最后会变成左右两个有序数组的合并。具体代码如下

const merge = (left, right) => {
    const result = []
    let il = 0
    let ir = 0
    while(il < left.length && ir < right.length) {
        if(left[il] < right[ir]) {
            result.push(left[il++]) // 这里的left[il++]是先进行取值运算left[il], 在进行自增运算il++
        } else {
            result.push(right[ir++])
        }
    }
    while (il < left.length) {
        result.push(left[il++])
    }
    while (ir < right.length) {
        result.push(right[ir++])
    }
    return result
}
const mergeSortRec = array => {
    if (array.length === 1) {
        return array
    }
    const mid = Math.floor(array.length / 2)
    const left = array.slice(0, mid)
    const right = array.slice(mid, array.length)
    return merge(mergeSortRec(left), mergeSortRec(right))
}

let arr = [5, 3, 2, 4, 1]
console.log(mergeSortRec(arr))

 

快速排序

在数组中选择一个基准值，所有小于基准的都放在左边，大于基准的都放在右边，再把左右两个数组同样处理，直到数组中只有一个元素为止

再依次合并排序完的所有数组，就得到了有序的数组，代码如下：

let arr = [67,23,11,89,45,76,56,99]
let quickSort = function(arr) {
 
    if (arr.length <= 1) { return arr }

    let pivot = arr.shift()
    let left = []
    let right = []
  
    for (var i = 0; i < arr.length; i++){
        if (arr[i] < pivot) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
        console.log(left, right, 'aaa')
    }

    return quickSort(left).concat([pivot], quickSort(right))
  
}
console.log(quickSort(arr))

 

转载于:https://www.cnblogs.com/nightstarsky/p/11532857.html