JS数组——冒泡、插入、快速排序

前言：因为要对后端返回来的数据进行处理，之前之后冒泡，不够用，去看了插入跟快速，写下这篇笔记。

使用背景：

1.冒泡排序

　　数据比较少，小于1000

2.插入排序

　　数据比较少，大于1000不推荐

3.快速排序

　　相对于前两者，适合处理量大的数据

一： 冒泡排序

　　主要思想：将每个数跟数组中的其他数两两比较大小，交换位置。

var arr = [1,5,10,15,100,25,50]

// 需要注意，想要完成冒泡排序，需要两轮for循环
for (var i = 0; i < arr.length; i++) {
　　// 拿到每个数arr[i]，再去遍历 i 后面的数去做比较
　　for (var j = i + 1; j < arr.length; j++) {
　　　　// 比较大小
　　　　// 升序
　　　　if (arr[i] > arr[j]) {
　　　　　　var tmp = arr[i]
　　　　　　arr[i] = arr[j]
　　　　　　arr[j] = tmp
　　　　}
　　}
}

console.log(arr) // [1, 5, 10, 15, 25, 50, 100]

其他应用： 数组存储的是对象，利用arr[i].value 去比较

关键点： 控制循环次数，i是数组的长度，j是从i的位置+1开始，因为前面的数值已经排好了

可以优化的点： 假设数组本身就是排序好的，这时候再去比较大小就很不合理，设置标识

二、插入排序

主要思想：

　　1.把数组分成一个有序数列和一个无序数列

　　2.默认把数组第一项当成一个有序数列

　　3.拿第一项去跟其他无序项比较大小

　　4.调换位置

var arr = [10,5,25,30,100,25,231,52,1,6,0]

function sort(arr) {

　　for (let i = 1; i < arr.length; i++) {

　　　　if (arr[i] < arr[i-1]) {

　　　　　　let tmp = arr[i]

　　　　　　let j = i - 1

　　　　　　arr[i] = arr[j]

　　　　　　

　　　　　　// 这里比较关键 tmp一直存着小的值

　　　　　　while (j >= 0 && tmp < arr[j]) {

　　　　　　　　arr[j+1] = arr[j]

　　　　　　　　j--

　　　　　　}

　　　　　　// 直到 j = -1跳出while循环，所有j+1 = 0 等于最小的值

　　　　　　arr[j + 1] = tmp

　　　　}

　　}

　　return arr

}

console.log('before', arr)

console.log('after', sort(arr))

别光想，有点绕很正常的，有手写一下过程

三、快速排序（重点，面试比较多？）

主要思想：

　　1.随机用数组的其中一个值当基准值（中间值、中介、中线），我喜欢用数组第一项

　　2.left等于0，right等于数组的长度-1，从左往右

举个例子：

var arr = [5,3,6,2,7,9,10]
// 假设中间值是数组第一项 5
// 那我们想要的数组应该是这样的
arr = [2,3,5,6,7,9,10]
// 以 5 为中介，左边比5小或者等于，右边比5大或者等于

用代码实现

var arr = [5,3,2,4,6,9,7,10]

function quickSort(arr, i, j) {
　　var left = i
　　var right = j
　　
　　if (left < right) {
　　　　//如果数组有两项以上
　　　　var base = arr[left]
　　　　// 设置中间值，开始比较
　　　　
　　　　while (left !== right) {
　　　　　　// 这里是找比中间值小的值并设置
　　　　　　while (right > left && arr[right] >= base) {
　　　　　　　　// 假设此时right = 4
　　　　　　　　// right-- = 3  arr[left] = arr[3] = 4,这个时候再出去while判断，条件已经不成立了，我们也拿到了比base小的值了
　　　　　　　　right--
　　　　　　　　arr[left] = arr[right]
　　　　　　}
　　　　　　// 这里是找比中间值大的值并设置
　　　　　　while (left < right && arr[left] <= base) {
　　　　　　　　left++
　　　　　　　　arr[right] = arr[left]
　　　　　　}
　　　　}
　　　　// 设置中间值的位置
　　　　arr[right] = base
　　　　// 递归调用，直到数列别分解成一个数值组成的数列
　　　　arguments.callee(arr, i, left-1)
　　　　arguments.callee(arr, right+1, j) 
　　　　return arr
　　}
}

console.log(quickSort(arr, 0, arr.length-1)