数据结构总结（二）：排序

一、排序算法的指标

1. 最好情况、最坏情况、平均情况时间复杂度
2. 空间复杂度。空间复杂度是 O(1) 的排序算法叫原地排序
3. 稳定性：如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变。

二、冒泡排序

操作相邻的两个数据，对其进行比较交换
优化：当某次冒泡操作已经没有数据交换时，说明已经达到完全有序，不用再继续执行后续的冒泡操作

const bubbleSort = (arr) => {
    if (arr.length <= 1) return
    for (let i = 0; i < arr.length; i++) {
        let hasChange = false
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                const temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
                hasChange = true
            }
        }
        if (!hasChange) break
    }
    console.log(arr)
}

• 时间复杂度：
  最好（优化后）：O(n)
  最坏：O($n^2$)
  平均：O($n^2$)
• 空间复杂度：O(1)
• 是否稳定：是

三、插入排序

取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。重复这个过程

const insertionSort = (arr) => {
    if (arr.length <= 1) return
    for (let i = 1; i < arr.length; i++) {
        const temp = arr[i]
        let j = i - 1
        // 若arr[i]前有大于arr[i]的值的化，向后移位，腾出空间，直到一个<=arr[i]的值
        for (j; j >= 0; j--) {
            if (arr[j] > temp) { // 大于temp才移动，这样才是稳定的排序
                arr[j + 1] = arr[j]
            } else {
                break
            }
        }
        arr[j + 1] = temp
    }
    console.log(arr)
}

• 时间复杂度：
  最好：O(n)
  最坏：O($n^2$)
  平均：O($n^2$)
• 空间复杂度：O(1)
• 是否稳定：是

四、选择排序

每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾

const selectionSort = (arr) => {
    if (arr.length <= 1) return
    // 需要注意这里的边界, 因为需要在内层进行 i+1后的循环，所以外层需要 数组长度-1
    for (let i = 0; i < arr.length - 1; i++) {
        let minIndex = i
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j // 找到整个数组的最小值
            }
        }
        const temp = arr[i]
        arr[i] = arr[minIndex]
        arr[minIndex] = temp
    }
    console.log(arr)
}

• 时间复杂度：
  最好：O($n^2$)
  最坏：O($n^2$)
  平均：O($n^2$)
• 空间复杂度：O(1)
• 是否稳定：否

性能：插入排序 > 冒泡排序 > 选择排序
插入排序比冒泡排序的循环部分赋值操作少。
这几种排序只适合小规模数据的排序，时间复杂度较高

五、归并排序

归并排序使用的是分治思想，使用递归实现
递推公式：
merge_sort(p…r) = merge_arr(merge_sort(p…q), merge_sort(q+1…r))
终止条件：
p >= r 不用再继续分解

const mergeArr = (left, right) => {
    let temp = []
    let leftIndex = 0
    let rightIndex = 0
    // 判断2个数组中元素大小，依次插入数组
    while (left.length > leftIndex && right.length > rightIndex) {
        if (left[leftIndex] <= right[rightIndex]) {
            temp.push(left[leftIndex])
            leftIndex++
        } else {
            temp.push(right[rightIndex])
            rightIndex++
        }
    }
    // 合并 多余数组
    return temp.concat(left.slice(leftIndex)).concat(right.slice(rightIndex))
}

const mergeSort = (arr) => {
    // 当任意数组分解到只有一个时返回。
    if (arr.length <= 1) return arr
    const middle = Math.floor(arr.length / 2) // 找到中间值
    const left = arr.slice(0, middle) // 分割数组
    const right = arr.slice(middle)
    // 递归 分解 合并
    return mergeArr(mergeSort(left), mergeSort(right))
}

• 时间复杂度：
  最好：O(nlogn)
  最坏：O(nlogn)
  平均：O(nlogn)
• 空间复杂度：O(n)
• 是否稳定：是

六、快速排序

递推公式：
quick_sort(p…r) = quick_sort(p…q-1) + quick_sort(q+1… r)
终止条件：
p >= r

const swap = (arr, i, j) => {
    const temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp
}

// 获取 pivot 交换完后的index
const partition = (arr, pivot, left, right) => {
    const pivotVal = arr[pivot]
    let startIndex = left
    for (let i = left; i < right; i++) {
        if (arr[i] < pivotVal) {
            swap(arr, i, startIndex)
            startIndex++
        }
    }
    swap(arr, startIndex, pivot)
    return startIndex
}

const quickSort = (arr, left, right) => {
    if (left < right) {
        let pivot = right
        let partitionIndex = partition(arr, pivot, left, right)
        quickSort(arr, left, partitionIndex - 1 < left ? left : partitionIndex - 1)
        quickSort(arr, partitionIndex + 1 > right ? right : partitionIndex + 1, right)
    }

}

• 时间复杂度：
  最好：O(nlogn)
  最坏：O($n^2$)
  平均：O(nlogn)
• 空间复杂度：O(1)
• 是否稳定：否