最近越来越觉得算法的重要性，就和数字竞赛，考的就是这样逻辑性思维题，废话不多说，先上以下几种排序算法。

1. 冒泡排序

let arr = [4,5,1,3,8,6,7]

function sort(arr) {
  for (let j = 0;j<arr.length-1;j++) {
    let sorted = false
    let sortend = arr.length - j - 1
    for (let i = 0; i < sortend; i++) {
      if (arr[i+1] < arr[i]) {
        let tmp = arr[i]
        arr[i]=arr[i+1]
        arr[i+1]=tmp
        sorted=true
        sortend=i+1
      }
    }
    if (!sorted) {
      break
    }
  }
  
  return arr
}
console.log(sort(arr))

时间复杂度：O(n²)

由冒泡排序衍生的一个问题，求第K个最大的值，这种问题也可用冒泡排序。冒泡排序就是每一轮得到一个最大值，那第k轮就能得到最K个最大值。代码如下：

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var findKthLargest = function(nums, k) {
    let temp = []
    for (let i = 0; i < k; i++) {
        let maxIndex = i
        for (let j = i + 1; j < nums.length; j++) {
            if (nums[j] > nums[maxIndex]) {
                maxIndex = j
            }
        }
        let temp = nums[i]
        nums[i] = nums[maxIndex]
        nums[maxIndex] = temp
    }
    return nums[k-1]
};

2. 鸡尾酒排序

let arr2 = [2,3,4,5,6,7,1]
function sort2(arr) {
    for (let j = 0;j<arr.length/2;j++) {
        let sorted = false
        for (let i = j; i < arr.length - j - 1; i++) {
            if (arr[i+1] < arr[i]) {
                let tmp = arr[i]
                arr[i]=arr[i+1]
                arr[i+1]=tmp
                sorted=true
            }
        }
        if (!sorted) {
            break
        }
        sorted = false
        for (let i = arr.length - j - 1; i >j; i--) {
            if (arr[i-1] > arr[i]) {
                let tmp = arr[i]
                arr[i]=arr[i-1]
                arr[i-1]=tmp
                sorted=true
            }
        }
        if (!sorted) {
            break
        }
    }
        
    return arr
}
console.log(sort2(arr2))

时间复杂度：O(n²)

3. 快速排序

分治法，需要找基点

 let arr3 = [4,5,1,3,8,6,7]
function quickSort(arr, left, right) {
    if (left >= right) return
    const pivotIndex = partitionArr(arr, left, right)
    quickSort(arr, left, pivotIndex - 1)
    quickSort(arr, pivotIndex + 1, right)
}
function partitionArr(arr, left, right) {
    let temp = arr[right]
    while(left !== right) {
        while (left < right && arr[left] <= temp) {
            left++
        }
        if (left < right) {
            arr[right] = arr[left]
            right--
        }
        while (left < right && temp <= arr[right]) {
            right--
        }
        if (left < right) {
            arr[left] = arr[right]
            left++
        }
    }
    arr[left] = temp
    console.log(arr)
    return left
}
quickSort(arr3, 0,arr3.length-1)
console.log(arr3)

时间复杂度：O(nlogn)

4. 计数排序

let arr4 = [4,5,1,3,8,6,7]
 function countSort(arr) {
     let max = Math.max(...arr)
     let min = Math.min(...arr)
     const diff = max - min
     const _arr = []
     for (let i = 0; i < diff + 1; i++) {
        _arr[i] = 0
     }
     for (let i = 0; i < arr.length; i++) {
        _arr[arr[i] - min] = _arr[arr[i] - min] + 1
     }
     const rs = []
     for (let i = 0, k = 0; i < _arr.length; i++) {
        if (_arr[i]!=0) {
            for (let j = 0; j < _arr[i]; j++) {
                rs[k] = i + min
                k++
            }
        }
     }
    return rs 
 }
 console.log(countSort(arr4))

时间复杂度：O(n)