前端基础算法

大O标识法和时间复杂度

度量一个程序的时间通常有两种方法
    1.事后统计的方法(受电脑配置影响不推荐)
        console.time('AAA')
        for(let i=0;i<999;i++){
            
        }
        console.timeEnd('AAA')
    2.事前分析估算的方法
  O(1)<O(log2(n))<O(n)<O(n^2)<O(n^3)...<O(2^n)

O(1):如果算法的执行时间不随着问题规模n的增加而增加，即使算法中有上千条语句，其执行时间也不过是常数

    let a=1
    let b=2
    let temp=a
    a=b
    b=temp

O(log2(n)):当数据增大n倍时，耗时增大logn倍(这里的log是以2为底的，比如，数据增大256倍时，耗时增大八倍)

    let i=1
    while(i<=n){
        i*=2
    }

O(n):当数据增大n倍时，耗时增大n倍

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

O(n^2):当数据增大n倍时，耗时增大n的平方倍

    for(let i=1;i<=n;i++){
        for(let j=1;j<=n;j++){
            ...
        }
    }

数组的冒泡排序

    function swap(a,b){
        <!--第一种交换-->
            <!--let c=a-->
            <!--a=b-->
            <!--b=c-->
        <!--第二种交换-->
            <!--[a,b]=[b,a]-->
        <!--第三种交换-->
            a=a+b
            b=a-b
            a=a-b
    }
    <!--交换数组索引i/j的交换-->
    function swap(arr,i,j){
        let temp=arr[i]
        arr[i]=arr[j]
        arr[j]=temp
        return arr
    }
    <!--基础款-->
    Array.prototype.bubble=function bubble(){
        //this->ary
        let _this=this
        for(let i=0;i<_this.length-1;i++){
            //每轮
            for(let j=0;j<_this.length-1-i;j++){
                if(_this[j]>_this[j+1]){
                    swap(_this,j,j+1)
                }
            }
        }
        return _this
    }  
    <!--升级款-->
     Array.prototype.bubble=function bubble(){
        //this->ary
        let _this=this,
            flag=false
        for(let i=0;i<_this.length-1;i++){
            //每轮
            for(let j=0;j<_this.length-1-i;j++){
                if(_this[j]>_this[j+1]){
                    swap(_this,j,j+1)
                    flag=true
                }
            }
            if(!flag) break
            flag=false
        }
        return _this
    }  
    let ary=[2,1,8,4]
    ary.bubble()
    console.log(ary)

插入排序

    Array.prototype.insert=function insert(){
        //1.准备一个新数组，相当于抓牌，先抓一个
        let _this=this,
            handle=[]
        handle.push(_this[0])
        //开始抓牌
        for(let i=1;i<_this.length;i++){
            //A每次新抓的牌
            let A=_this[i]
            //和手里的牌比较（倒着比）
            for(let j=handle.length-1;j>=0;j--){
                //要比较的手里这张牌
                let B=handle[j]
                //抓的A比手牌B大，放在B后面
                if(A>B){
                    handle.splice(j+1,0,A)
                    break
                }
                //比到开头都没有比手牌B大，则A是最小的，插入到开始
                if(j===0){
                    handle.unshift(A)
                }
            }
        }
        return handle;
    }
    let arr=[2,1,8,4]
    arr=arr.insert()
    console.log(arr)

快速排序

    Array.prototype.quick=function quick(){
        let _this=this
        
        if(_this.length<=1){
            return _this
        }
        
        let middleIndex=Math.floor(_this.length/2),
            middleValue=_this.splice(middleIndex,1)[0]
        
        let arrLeft=[],
            arrRight=[]
        for(let i=0;i<_this.length;i++){
            let item = _this[i]
            item<middleValue?arrLeft.push(item):arrRight.push(item)
        }
        return quick.call(arrLeft).concat(middleValue,quick.call(arrRight))
        
    }
    let arr=[2,1,8,4]
    arr=arr.quick()
    console.log(arr)