冒泡排序、选择排序、插入排序、归并排序、快速排序、计数排序（总结）

冒泡排序、选择排序、插入排序、归并排序、快速排序、计数排序

冒泡排序(时间复杂度O（n²），原地排序，稳定)

function bubbleSort(arr) {
    console.log("arr:", arr)
    for (let i = 0; i < arr.length; i++) {
        for (let j = i; j < arr.length; j++) {
            if (arr[j] < arr[i]) {
                const temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp
            }
        }
    }
    console.log("BubbleSort:", arr)
}

选择排序(时间复杂度O（n²），非原地排序，稳定)

function selectOrder(arr) {
	console.log("arr:", arr)
    for (let i = 0; i < arr.length; i++) {
        let minIndex = i;
        for (let j = i; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j
            }
        }
        const temp = arr[i]
        arr[i] = arr[minIndex]
        arr[minIndex] = temp    
    }
    console.log("selectOrder:", arr)
}

插入排序(时间复杂度O（n²），原地排序，稳定)

function insertOrder(arr) {
	console.log("arr:", arr)
	for (let i = 0; i < arr.length; i++) {
        const temp = arr[i];
        let j = i - 1;
        for (; j >= 0; j--) {
            if (arr[j] >= temp) {
                arr[j + 1] = arr[j]
            } else {
                break;
            }
        }
        arr[j + 1] = temp
    }    
    console.log("insertOrder:", arr)
}

归并排序(时间复杂度O（nlogn），非原地排序，稳定)

function mergeSort(arr) {
    if (arr.length === 1) return arr;
    const half = arr.length >> 1
    const left = arr.slice(0, half);
    const right = arr.slice(half)
    return merge(mergeSort(left), mergeSort(right))
}

function merge(left, right) {
    const temp = [];
    while (left.length && right.length) {
        if (left[0] <= right[0]) {
            temp.push(left.shift())
        } else {
            temp.push(right.shift())
        }
    }
   return temp.concat(left, right)
}

console.log(mergeSort([3,4,6,15,7,11]))

快速排序（时间复杂度O（nlogn）非原地排序 稳定）

function quickSort(arr) {
    if (arr.length <= 1) return arr;
    const piovt = arr[arr.length - 1]
    const left = [], right = [];
    for (let i = 0; i < arr.length - 1; i++) {
        if (arr[i] <= piovt) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
    }
    return quickSort(left).concat(piovt, quickSort(right))
}

快速排序（时间复杂度O（nlogn）原地排序 稳定）

function quickSort(arr, left, right) {
    if (left > right) return
    const storageIndex = partition(arr, left, right);
    quickSort(arr, left, storageIndex - 1)
    quickSort(arr, storageIndex + 1, right)
    return arr
}
function partition(arr, left, right) {
    const piovt = arr[right];
    let index = left;
    for (let i = left; i < right; i++) {
        if (arr[i] < piovt) {
            swap(arr, index, i);
            index++
        }
    }
    swap(arr, index, right)
    return index
}
function swap(arr, a, b) {
    const temp = arr[a];
    arr[a] = arr[b]
    arr[b] = temp
}
console.log(quickSort([1,2,6,11,2,34,5,6,3],0,8))

计数排序（特殊的桶排序，适用于数值范围不大的数据，时间复杂度为O（n）非原地排序 稳定）

function countSort(arr) {
    let max = -1;
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i]
        }
    }
    const cArr = new Array(max + 1).fill(0)
    for (let i = 0; i < arr.length; i++) {
        cArr[arr[i]] += 1
    }
    for (let i = 1; i < max + 1; i++) {
        cArr[i] += cArr[i - 1]
    }
    const orr = []
    for (let i = arr.length - 1; i >= 0; i--) {
        const index = cArr[arr[i]] - 1;
        orr[index] = arr[i];
        cArr[arr[i]] -= 1
    }

    console.log(orr)
}
countSort([6,4,2,4,6,8,1,7])