基本的排序和查找算法

• 排序算法

一、冒泡算法：优点没啥，缺点就是数据量多时候速度很慢，平均时间复杂度为n平方，稳定，依赖内存。

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

二、选择排序：在杂乱无章的数据时候比冒泡快，但是如果数据几乎是有序，则冒泡快。平均时间复杂度为n平方，依赖内存

      for(let i=0;i<arr.length;i++){
        //当前i与之后的元素相比较
        let minIndex = i
        for(j= i ;j<arr.length;j++){
          // 如果找到，则把所以记录起来
          if(arr[minIndex]>arr[j]){
            minIndex = j
          }
        }
        // 思路：找到最小的那个，要与当前的i来对换
        let temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp
      }

三、插入排序：后面的数据往前插，平均时间复杂度为n平方，依赖内存

 for(let i=1;i<arr.length;i++){
        let minindex = -1
        //二次循环主要找出最小的那个，这里有一个隐藏条件：越往前面的数越小，所以不用顾忌当前的J和minIndex的比较
        for(let j = i-1;j >= 0;j--){
          if(arr[j]>arr[i]){
            minindex = j
          }    
        }
        //判断如果当前的i比前面的数都大，则无需交换
        if(minindex != -1){
          //主要思想是插入！！ 把当前的i去掉，然后把temp插到相应的位置
          let temp = arr[i];
          arr.splice(i,1)
          arr.splice(minindex,0,temp)
        }
      }

四、归并排序：把数组分切最小分，然后再进行比较，最后再合并。缺点：大数据时候不稳定，依赖磁盘和内存进行，优点，速度快，越多它越快，时间复杂度为n。

 function sort(arr){
        if(arr.length == 1){
          return arr
        }
        let mid = Math.floor(arr.length / 2)
        let al = arr.slice(0, mid)
        let ar = arr.slice(mid, arr.length)
        return mergeSort(sort(al),sort(ar))
      }
      function mergeSort(left, right){
        let il = 0 , ir = 0 , result = []
        while(il < left.length && ir < right.length){
          if(left[il] < right[ir]){
            result.push(left[il])
            il++
          }else if(left[il] >= right[ir]){
            result.push(right[ir])
            ir++
          }
        }
        if(il< left.length){
          while(il<left.length){
            result.push(left[il])
            il++
          }
        }
        if(ir< right.length){
          while(ir<right.length){
            result.push(right[ir])
            ir++
          }
        }

        return result
      }

五、快速排序：找到一个基准值（中间），左边比基准值小，右边比基准值大，然后两个数组再找基准值，再各自比较，直到数组长度为一，再合并。优点：速度快，稳定性好，但是不比归并快，依赖内存，平均时间复杂度为：logn。

      var quickSort = function(arr) {
    　　if (arr.length <= 1) {//如果数组长度小于等于1无需判断直接返回即可 
            return arr;
        }
    　　var pivotIndex = Math.floor(arr.length / 2);//取基准点 
    console.log(pivotIndex)
    　　var pivot = arr.splice(pivotIndex, 1)[0];//取基准点的值,splice(index,1)函数可以返回数组中被删除的那个数
    　　var left = [];//存放比基准点小的数组
    　　var right = [];//存放比基准点大的数组 
    　　for (var i = 0; i < arr.length; i++){ //遍历数组，进行判断分配 
  　　　　if (arr[i] < pivot) {
  　　　　　　left.push(arr[i]);//比基准点小的放在左边数组 
  　　　　}else {
　　　　　　right.push(arr[i]);//比基准点大的放在右边数组 
  　　　　}
    　　}
         //递归执行以上操作,对左右两个数组进行操作，直到数组长度为<=1； 
         console.log([pivot])
      　　return quickSort(left).concat([pivot], quickSort(right));
        }

 

• 查找算法

一、二分查找：通常用这个查找就可以了，主要思想就是不断的折半，知道下标相等，记住一定是要有序的！！！！

let arr1 = [1,2,3,4,5,6,7,8]
      function binary_search(arr, key){
        let start = 0 , end = arr.length - 1
        let mid = Math.floor((start + end) / 2)
        while(start<=end){
          if(key == arr[mid]){
            return mid
          }else if(key > arr[mid]){
            end = mid - 1
          }else{
            start = start + 1
          }
        }
        return "no search data"
      }
      binary_search(arr1 , 2)