前端排序算法

冒泡排序

/**
 * 比较相邻的两个元素，如果第一个比第二个大，则交换位置
 * 每一对相邻元素重复第一个步骤 从开始第一对到最后一对 这样在最后的元素应该会是最大的数
 * 针对所有元素重复以上步骤
*/
function bubbleSort(arr){
    const len = arr.length
    for(let i=0;i<len;i++){
            let isSort = true
            for(let j=0;j<len-1-i;j++){
                    if(arr[j]>arr[j+1]){
                            [arr[j],arr[j+1]] = [arr[j+1],arr[j]] 
                            isSort = false
                    }
            }
            if(isSort){
                    break
            }
    }
    return arr
}

console.log(bubbleSort([3,44,15,36,26,27,2,46,4,19,50,48]))

快速排序

/**
 * 选择一个参考元素，将列表分成两个子序列
 * 对列表重新排序，将所有小于基准值的元素放在基准值前面，所有大于基准值的元素放在基准值后面
*/
function quickSort(arr){
   if(arr.length<=1) return arr
   const left=[],right=[],current=arr.splice(0,1)
   for(let i=0;i<arr.length;i++){
           if(arr[i]<current){
                   left.push(arr[i])
           }else{
                   right.push(arr[i])
           }
   }
   return quickSort(left).concat(current,quickSort(right))
}
console.log(quickSort([3,44,15,36,26,27,2,46,4,19,50,48]))

插入排序

/**
* 从第一个元素开始，该元素可以认为已经被排序
* 取出下一个元素，在已排序的元素序列中从后向前扫描
* 如果已排序的该元素大于新元素，则将该元素移到下一位
* 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
* 将新元素插入到该位置后
* 重复步骤2-5
*/
function insertSort(arr){
       let temp
       for(let i=1;i<arr.length;i++){
               temp=arr[i]
               let j=i-1
               while(j>=0&&arr[j]>temp){
                       arr[j+1]=arr[j]
                       j--
               }
               arr[j+1]=temp
       }
       return arr
}
console.log(insertSort([3,44,15,36,26,27,2,46,4,19,50,48]))

选择排序

function selectSort(arr){
   let len = arr.length,minIndex,temp
   for(let i=0;i<len-1;i++){
           minIndex=i
           for(let j=i+1;j<len;j++){
                   if(arr[j]<arr[minIndex]){
                           minIndex=j
                   }
           }
           temp = arr[i]
           arr[i]=arr[minIndex]
           arr[minIndex]=temp
   }
   return arr
}
console.log(selectSort([3,44,15,36,26,27,2,46,4,19,50,48]))

归并排序

/**
* 将长度为n的输入序列分成两个长度为n/2的序列
* 对这两个子序列分别采用归并排序
* 将两个排列好的子序列合并成一个最终的排序序列
*/
function merge(left,right){
   let temp = []
   while(left.length&&right.length){
           if(left[0]<right[0]){
                   temp.push(left.shift())
           }else{
                   temp.push(right.shift())
           }
   }
   return temp.concat(left,right)
}

function mergeSort(arr){
   const len =arr.length
   if(len<2) return arr
   let mid=Math.floor(len/2),left=arr.slice(0,mid),right=arr.slice(mid)
   return merge(mergeSort(left),mergeSort(right))
}
console.log(mergeSort([3,44,15,36,26,27,2,46,4,19,50,48]))

希尔排序

function shellSort(arr){
   var len=arr.length
   for(var gap=Math.floor(len/2);gap>0;gap=Math.floor(gap/2)){
           for(var i=gap;i<len;i++){
                   var j=i
                   var current=arr[i]
                   while(j-gap>=0&& current<arr[j-gap]){
                           arr[j]=arr[j-gap]
                           j=j-gap
                   }
                   arr[j]=current
           }
   }
   return arr
}
console.log(shellSort([50,70,60,80,61,84,83,88,87,99]))

二分查找

function binarySearch(arr,target){
   let left=0
   let right =arr.length-1
   while(left<=right){
           let mid=Math.floor((left+right)/2)
           if(arr[mid]===target){
                   return mid
           }else if(arr[mid]<target){
                   left=mid+1
           }else{
                   right=mid-1
           }
   }
   return -1
}
 const myArray = [1, 3, 5, 7, 9, 11];
 console.log(binarySearch(myArray, 7)); // 输出: 3