算法排序总结

    //双重默认值
//    function fetUrl(url,{method="GET"}={}){
//        console.log(method,"---")
//    }
//    fetUrl("11111",{method:"post"})

//     function m1({x=0,y=0}={}){
//         return [x,y]
//     }
//     function m2({x,y}={x:0,y:0}){
//         return [x,y]
//     }

//      console.log(m1(),m2())//[0,0]
//      console.log(m1({x:1,y:2}),m2({x:2,y:3}))

// var a = [ -22,-98, -8, -3,  5, 9, 33];
// function findMinAbsOfArr(arr) {
//     let min=arr[0]
//      for( var i=0;i<a.length;i++){
//          if(Math.abs(a[i])<min){
//             min=Math.abs(a[i])
//              return min
//          }
//      }
// }
// console.log(findMinAbsOfArr(a))


//比较两个数的大小
function greater(v,w){
   return Math.abs(v)-Math.abs(w)>0
}
//交换数组i与j的值
function each(a,i,j){
  var temp=a[i]
  a[i]=a[j]
  a[j]=temp
}

// 冒泡排序
var arr = [ -22,-98, -8, -3,  5, 9, 33];
 function sort(arr){
    for(var i=arr.length-1;i>0;i--){
        for(var j=0;j<i;j++){
            if(greater(arr[j],arr[j+1])){
               each(arr,j,j+1)
            }
        }
    }
    return arr 
 }
 console.log(sort(arr),"soer")

//选择排序
var  selectarr = [ -22,-98, -8, -3,  5, 9, 33];
  //先设置一个最小值然后拿最小值与其他元素比较
  function selectSort(arr){
       for(let i=0;i<=arr.length-2;i++){ //排除最小值
           let minIndex=i //假设为最小值
           for(let j=i+1;j<=arr.length-1;j++){
            if(greater(arr[minIndex],arr[j])){
                minIndex=j//交换索引
             }
           }
           each(arr,i,minIndex)//变换位置
       }
       return arr
  }

 console.log(selectSort(selectarr),"selectSort") 
//插入排序
var  insertArr = [ -22,-98, -8, -3,  5, 9, 33];
function insertSort(arr){
    for(let i=1;i<arr.length;i++){//全部一组
         for(let j=i;j>0;j--){//前面排好的一组
             if(greater(arr[j-1],arr[j])){
                each(arr,j-1,j)
             }else{
                 break
             }
         }
    }
  return arr
}
console.log(insertSort(insertArr),"insertSort")
//希尔排序
 var  shellArr = [ -22,-98, -8, -3,  5, 9, 33];
 function shellSort(arr) {
     //根据数组arr的长度确定增长量h
     let h=1
     while(h<arr.length/2) {
         h=2*h+1
     }
     //希尔排序
     while(h>=1){// 7,3
        //寻找待插入元素的值
        for(let i=h;i<arr.length;i++){
            // 寻找要比较的值(前面已经拍好的一组寻找)
            for(let j=i;j>=h;j-=h){
                //待插入元素是a[j],a[j-h]
                // console.log(j,arr[j-h],arr[j])
                if(greater(arr[j-h],arr[j])){
                    each(arr,j-h,j)
                }else{
                    break;
                }
            }
        }
       //最小值h
        h=parseInt(h/2)
     }
     return arr
 }
 console.log(shellSort(shellArr),"shellSort")
//归并排序
   let newArr=[]
   let margeArr=[ -22,-98, -8, -3,  5, 9, 33]
   function  margeSort(arr) {
      let lo=0;
      let hi=arr.length-1;
     return reSort(arr,lo,hi)
   }
   function reSort(arr,lo,hi){
       //安全性校验
        if(hi<=lo){
            return;
        }
      //进行拆分
      let mid=lo+parseInt((hi-lo)/2)//
      //递归调用左子组
       reSort(arr,lo,mid) // mid为 3，1，0
      //递归调用右子组
       reSort(arr,mid+1,hi)// mid为 3，5
    //   console.log(lo,mid,hi,"reSort")
      // 0 0 1  mid=0
      // 0 1 3  mid=1
      // 0 3 6  mid=3
      // 4 5 6  mid=5
      // 0 3 6  mid=3
      // 4 4 5  
      // 2 2 3  
     //合并
    return merge(arr,lo,mid,hi)
   }
   function merge(arr,lo,mid,hi){
       //定义三个指针
       let i=lo
       let p1=lo
       let p2=mid+1
    //    console.log(p1,mid,p2,hi)
      //遍历,移动p1指针与p2指针比较对应索引的值找出最小的值放到辅助数组中
      while(p1<=mid && p2<=hi ){
          if(greater(arr[p2],arr[p1])){//找到p1最小
            newArr[i++]=arr[p1++]
            // debugger
          }else{
            newArr[i++]=arr[p2++]
          }
      }
      //如果p1没有走完就移动p1指针
      while(p1<=mid){
        newArr[i++]=arr[p1++]
      }
      //如果p2没有走完就移动p1指针
      while(p2<=hi){
        newArr[i++]=arr[p2++]
      }
    //console.log(newArr,"111")
      //把辅助数组拷贝到原数组中
      for(let index=lo;index<=hi;index++){
          arr[index]=newArr[index]
      }
     return arr
   }
  console.log(margeSort(margeArr),"margeSort") 
//快速排序
let fastAre=[ 2,1,4,3]
function fastSort(arr){
    let lo=0;
    let hi=arr.length-1
   return restSort(arr,lo,hi)
}
function restSort(a,lo,hi){
   //安全性校验
   if(hi<=lo){
       return
   }
   //返回分界值切分后位置变化的索引
   let [partitions,arr]=partition(a,lo,hi)
  console.log(partitions,arr,"0000")
   //让左子组有序
   restSort(a,lo,partitions-1)

   //让右子组有序
   restSort(a,partitions+1,hi)

   return a
}
//切分函数
function  partition(a,lo,hi) {
    //确定分界值(基准值)
  let key=a[lo]
    //定义两个指针,分别指向最小索引与最大索引的后一位
  let left=lo
  let right=hi+1
  //进行对指针的移动
    while(true){
        //从右向左扫描
         while(greater(a[--right],a[key])){
              if(right===lo){
                  break
              }
         }
        //从左向右扫描
        while(greater(a[key],a[++left])){
             if(left===hi){
               break
             }
         }
        //如果左指针与右指针重合则停止 否则左右交换位置
        if(left>=right){
          return a
          break 
        }else{
            each(a,left,right)
        }
    }
     //基准值与中间值交换位置
    each(a,lo,right)
    return [right ,a]
}
// console.log(fastSort(fastAre),"fastSort")