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)