写在前面

前端经典面试题，每天至少一更，找个地方记录，以便于之后复习，也是另一种鞭策自己的坚持下去的方式。

快速排序

算法思想：快速排序的思想很简单，就是首先随便选择一个元素作为基点base，然后把比base小的放一边，比base大的元素放在另一边，然后在对左右两边的元素递归上面的操作，最后只剩下一个元素的时候就排序完成了。

时间复杂度 平均时间复杂度是 $O(nlog^n) - O(n^2）$

空间复杂度$O(log^n)$

代码

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

举例说明 let arr = [10,30,20,40,60,50] console.log(quickSort(arr))

第一次循环
10 30 20 40 60 50 
base:10  
i=1：left=[] right[30]
i=2: left=[] right[30，20]
... 
i =5 left=[] right[30 20 40 60 50]
返回 ====>  10,【quickSort（[30 20 40 60 50]）】==20 30 40 50 60

第二次循环 quickSort（[30 20 40 60 50]）
base:30  
i=1：left=[20] right[]
i=2: left=[20] right[40]
... 
i =4 left=[20] right[40 60 50]
返回 ====>  20,30,【quickSort（[40 60 50]）】===40 50 60

第三次循环 quickSort（[40 60 50]）
base:40  
i=1：left=[] right[60]
i=2: left=[20] right[60 50]
返回 ====> 40,【quickSort（[60 50]）】 ==50 60

第四次循环 quickSort（[60 50]）
base:60  
i=1：left=[50] right[]
返回 ====> 50,60
然后再回溯

冒泡排序

算法思想：就是不断地一次比较，把最大最小的元素放在最后，之后不在操作该元素，然后重复上述操作，将第二大的元素放在倒数第二个，直到只有一个元素 时间复杂度 $O(n^2)$

空间复杂度 $O(1)$

算法代码

    function bubbleSort(arr){
        for(let i=0;i<arr.length;i++){
            for(let j=1;j<arr.length-i;j++){ //这里需要注意索引的取值
                if(arr[j-1]>arr[j]){
                    [ arr[j-1],arr[j] ] = [arr[j],arr[j-1]]
                    //解构赋值，先把右边的值解析出来，然后数组再根据索引值对应赋值
                }
            }
        }
        return arr
    }

选择排序

算法思想 找到最大或者最小的元素放在队末，然后在从剩余元素中继续寻找最大或者最小的元素

时间复杂度 $O(n^2)$

空间复杂度 $O(1)$

算法代码

    function selectSort(arr){     
        for(let i = 0;i<arr.length;i++){
            let min = arr[i]
            for(j=i+1;j<arr.length;j++){
                if(arr[j]<min){
                    [min,arr[j]] = [arr[j],min]
                }
            } //找到当前arr[i]~arr[length-1]中的最小值
            arr[i] = min 
        }
        return arr

    }

插入排序

算法思想 （1）从一个元素开始，该元素被视为已排序

(2)取出下一个元素，在已排序的元素队列中从后往前扫描

（3）排序的元素大于新元素，则已排序的元素往后移一个位置

（4）重复步骤（3）直到找到小于或者等于新元素的位置，将新元素插在其后面

（5）重复（2）-（4）直到正序排序

时间复杂度 $O(n^2)$

空间复杂度 $O(1)$

    function insertSort(arr){
        let result = [arr[0]]
        for(let i=1;i<arr.length;i++){
            let newNum = arr[i]
            for(let j=result.length-1;j>=0;j--){
                if(result[j]<=newNum){
                    result[j+1] = newNum
                    break //一定要有break
                }else{
                    result[j+1] = result[j]
                }
            }
        }
        return result

    }