JS基本排序查找记录

一、二分查找

binarySearch=(arr,target)=>{
    let len=arr.length,max=len-1,min=0;
    while(min<=max){
    let mid=Math.floor((max+min)/2)
        if(arr[mid]>target){
            max=mid-1
        }else if(arr[mid]<target){
            min=mid+1
        }else{
            return mid
        }
    }
    return -1
}

二、冒泡排序

bubbleSort=(arr)=>{
    let len=arr.length;
    for(let i=0;i<len;i++){
        for(let j=0;j<len-1-i;j++){
            if(arr[j]>arr[j+1]){
                let temp=arr[j]
                arr[j]=arr[j+1]
                arr[j+1]=temp
            }
        }
    }
    return arr
}

三、希尔排序--间隔对比--固定间隔和动态间隔

functtion shellSort(arr){
    let len=arr.length;
    let gap=Math.floor(len/2);
    while(gap!=0){
        for(var i=gap;i<len;i++){
             var temp=arr[i],j
             for(j=i-gap;j>=0&&temp<arr[j];j-=gap){
                arr[j+gap]=arr[j]
             }
             arr[j+gap]=temp
        }
        gap=Math.floor(gap/2)
    }
    return arr
}
动态间隔版
function shellSort(arr){
    var len=arr.length,temp,gap=1;
    while(gap<len/3){gap=gap*3+1}
    while(gap!=0){
        console.log('gap值',gap)
        for(var i=gap;i<len;i++){
            console.log('第一层循环',i)
            temp=arr[i]
            for(var j=i-gap;j>=0&&arr[j]>temp;j-=gap){
                console.log('第二层循环',j,arr[j],temp)
                arr[j+gap]=arr[j]
            }
            arr[j+gap]=temp
            console.log('第二层循环完毕',arr)
        }
        gap=Math.floor(gap/3)
        console.log('第一层循环完毕arr',arr,gap)
    }
    return arr
}

四、插入排序--间隔为1的希尔排序--图https://www.cnblogs.com/cc-freiheit/p/10983395.html

function insertSort(arr){
    let len=arr.length
    for(var i=1;i<len;i++){
        var temp=arr[i]
        for(var j=i-1;j>=0&&arr[j]>temp;j-=1){
            arr[j+1]=arr[j]
        }
        arr[j+1]=temp
    }
    return arr
}

五、归并排序--先拆后合--分治思想--nlogn

mergeSort=(arr)=>{
    let len=arr.length,mid=Math.floor(len/2);
    if(len<2)return arr
    let left=arr.slice(0,mid)
    let right=arr.slice(mid)
    console.log('每一个mergeSort',mid,left,right)
    return merge(mergeSort(left),mergeSort(right))
}
merge=(left,right)=>{
    let result=[]
    while(left.length&&right.length){
        if(left[0]<=right[0]){
            result.push(left.shift())
        }else{
            result.push(right.shift())
        }
    }
    while(left.length){
        result.push(left.shift())
    }
    while(right.length){
        result.push(right.shift())
    }
    console.log('每一个merge',result)
    return result
}

六、快速排序---分成左右与基准值做比较--也是一种先拆后合--注意拆到一个就得返回了，不然空数组无线循环--同归并

function quickSort(arr){
    if(arr.length<2){return arr}
    var pivotIndex=Math.floor(arr.length/2)
    var pivot=arr.splice(pivotIndex, 1)[0]
    var left=[],right=[]
    for(var i=0;i<arr.length;i++){
        if(arr[i]<pivot){
            left.push(arr[i])
        }else if(arr[i]>pivot){
            right.push(arr[i])
        }
    }
    console.log('每一个quickSort',pivot,left,right)
    return quickSort(left).concat([pivot],quickSort(right))
}

方法二

Array.prototype.quickSort=function(){
    const rec=(arr)=>{
        if(arr.length<2){return arr;}
        const left=[];
        const right=[];
        const mid=arr[0];
        for(let i=1;i<arr.length;i++){
            if(arr[i]<mid){
                left.push(arr[i])
            }else{
                right.push(arr[i])
            }
        }
        return [...rec(left),mid,...rec(right)];
    }
    const res=rec(this);
    res.forEach((n,i)=>{this[i]=n})
    return res;
}

ps参考文章：https://github.com/damonare/Sorts