回温js算法

---恢复内容开始---

一，冒泡排序。

　　具体算法描述如下：

　　　　<1>.比较相邻的元素。如果第一个比第二个大，就交换它们两个；

　　　　<2>.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

　　　　<3>.针对所有的元素重复以上的步骤，除了最后一个；

　　　　<4>.重复步骤1~3，直到排序完成。

　　代码实现

let arr = [9, 10, 8, 7, 5, 4, 2, 1, 3, 6];

      function sort(arr) {
        var as = [].concat(arr), len = arr.length, count = 0;
        for (let i = 0; i < len-1; i++) {
          for (let j = 0; j < len-1-i; j++) {
            if(as[j]>as[j+1]){
              var item = as[j];
              as[j] = as[j+1];
              as[j+1] = item;
              count++;
            }
          }
        }
        console.log(count)
        return as
      }
      console.log(sort(arr))

结果：

count：37

arr：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

二，选择排序。

　　描述：

　　　　在时间复杂度上表现最稳定的排序算法之一，因为无论什么数据进去都是O(n²)的时间复杂度。。。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

　　实现：

let arr = [9, 10, 8, 7, 5, 4, 2, 1, 3, 6];

      function sort(arr) {
        var as = [].concat(arr), len = arr.length, count = 0, minNum, item;
        for (let i = 0; i < len-1; i++) {
          minNum = i;
          for (let j = i+1; j < len; j++) {
            if(as[minNum] > as[j]){
              minNum = j;
              count++
            }
          }
          item = as[i];
          as[i] = as[minNum];
          as[minNum] = item;
        }
        console.log(count)
        return as
      }
      console.log(sort(arr))

三，插入排序。

　　描述：插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

　　实现：

let arr = [9, 10, 8, 7, 5, 4, 2, 1, 3, 6];

      function sort(arr) {
        var as = [].concat(arr), len = arr.length, count = 0, preIndex, item;
        for (let i = 1; i < len; i++) {
          preIndex = i-1;
          item = as[i];
          while(preIndex >= 0 && as[preIndex] > item){
            as[preIndex+1] = as[preIndex]
            preIndex-- ;
            count++;
          }
          as[preIndex+1] = item
        }
        console.log(count)
        return as
      }
      console.log(sort(arr))

四，希尔排序。

　　描述：希尔排序本质上是一种插入排序，但是对数列进行了等间隔分组处理，在每一组中做插入排序，这一优化使得原本 O(n^2) 的时间复杂度一下降为 O(nlogn)

　　实现：

let arr = [9, 10, 8, 7, 5, 4, 2, 1, 3, 6];
        function shellsort(arr) {
          for (let gap = Math.floor(arr.length/2); gap > 0; gap = Math.floor(gap/2)) {
            for (let i = gap; i < arr.length; i++) {
              let item = arr[i];
              let j = i-1;
              while (j>=0 && arr[j] > item) {
                arr[j+1] =  arr[j];
                j--;
              }
              arr[j+1] = item;

            }
          }
        }
        console.log(shellsort(arr));

五，归并排序。

        let arr = [9, 10, 8, 7, 5, 4, 2, 1, 3, 6];
        function mergeSort(arr) {
          if (arr.length<2) {
            return arr
          }
          let middle =parseInt(arr.length/2);
          let left = arr.slice(0,middle);
          let right = arr.slice(middle);
          if(left.length =='undefined' && right.length == 'undefined'){
            return false
          }
          return merge(mergeSort(left),mergeSort(right))
        }

        function 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())
          }
          return result
        }
        console.log(mergeSort(arr));

六，快速排序。

 let arr = [9, 10, 8, 7, 5, 4, 2, 1, 3, 6];
        function quickSort(arr) {
          if(arr.length<=1){
            return arr
          }
          let middle = Math.floor(arr.length/2);
          let povid = arr.splice(middle,1)[0];
          let left = [];
          let right = [];
          for (let i = 0; i < arr.length; i++) {
            if(arr[i] < povid){
              left.push(arr[i])
            }else {
              right.push(arr[i])
            }
          }
          return quickSort(left).concat([povid],quickSort(right))
        }
        console.log(quickSort(arr))

七，堆排序。

//调整函数
        function headAdjust(elements, pos, len){
          //将当前节点值进行保存
          var swap = elements[pos];

          //定位到当前节点的左边的子节点
          var child = pos * 2 + 1;

          //递归，直至没有子节点为止
          while(child < len){
            //如果当前节点有右边的子节点，并且右子节点较大的场合，采用右子节点
            //和当前节点进行比较
            if(child + 1 < len && elements[child] < elements[child + 1]){
              child += 1;
            }

            //比较当前节点和最大的子节点，小于则进行值交换，交换后将当前节点定位
            //于子节点上
            if(elements[pos] < elements[child]){
              elements[pos] = elements[child];
              pos = child;
              child = pos * 2 + 1;
            }
            else{
              break;
            }

            elements[pos] = swap;
          }
        }

        //构建堆
        function buildHeap(elements){
          //从最后一个拥有子节点的节点开始，将该节点连同其子节点进行比较，
          //将最大的数交换与该节点,交换后，再依次向前节点进行相同交换处理，
          //直至构建出大顶堆（升序为大顶，降序为小顶）
          for(var i=elements.length/2; i>=0; i--){
            headAdjust(elements, i, elements.length);
          }
        }

        function sort(elements){
          //构建堆
          buildHeap(elements);

          //从数列的尾部开始进行调整
          for(var i=elements.length-1; i>0; i--){
            //堆顶永远是最大元素，故，将堆顶和尾部元素交换，将
            //最大元素保存于尾部，并且不参与后面的调整
            var swap = elements[i];
            elements[i] = elements[0];
            elements[0] = swap;

            //进行调整，将最大）元素调整至堆顶
            headAdjust(elements, 0, i);
          }
        }

        var elements = [3, 1, 5, 7, 2, 4, 9, 6, 10, 8];

        sort(elements);
        console.log(elements);

八，计数排序。

       function countingSort(array) {
        let len = array.length,B = [],C = [],min = array[0], max = array[0];
      　　for (var i = 0; i < len; i++) {
      　　　　min = min <= array[i] ? min : array[i];
      　　　　max = max >= array[i] ? max : array[i];
      　　　　C[array[i]] = C[array[i]] ? C[array[i]] + 1 : 1;
      　　}

      　　// 计算排序后的元素下标
      　　for (var j = min; j < max; j++) {
      　　　　C[j + 1] = (C[j + 1] || 0) + (C[j] || 0);
      　　}
      　　for (var k = len - 1; k >= 0; k--) {
      　　　　B[C[array[k]] - 1] = array[k];
      　　　　C[array[k]]--;
      　　}
      　　return B;
      }
        var elements = [3, 1, 5, 7, 2, 4, 9, 6, 10, 8];

        console.log(countingSort(elements));

九，桶排序。

//  @param array 数组
      // @param num 桶的数量
      function bucketSort(array, num) {
    　　if (array.length <= 1) {
    　　　　return array;
    　　}
    　　var len = array.length, buckets = [], result = [], min =array[0], max =array[0] , space, n = 0;

    　　var index = Math.floor(len / num) ;
    　　while(index<2){

    　　　　num--;
    　　　　index = Math.floor(len / num) ;
    　　}

    　　for (var i = 1; i < len; i++) {
    　　　　min = min <= array[i] ? min : array[i];
    　　　　max = max >= array[i] ? max : array[i];
    　　}
    　　space = (max - min + 1) / num;  //步长
    　　for (var j = 0; j < len; j++) {
    　　　　var index = Math.floor((array[j] - min) / space);
    　　　　if (buckets[index]) { // 非空桶，插入排序
    　　　　　　var k = buckets[index].length - 1;
    　　　　　　while (k >= 0 && buckets[index][k] > array[j]) {
    　　　　　　　　buckets[index][k + 1] = buckets[index][k];
    　　　　　　　　k--;
    　　　　　　}
    　　　　　　buckets[index][k + 1] = array[j];
    　　　　} else { //空桶，初始化
    　　　　　　buckets[index] = [];
    　　　　　　buckets[index].push(array[j]);
    　　　　}
    　　}
    　　while (n < num) {
    　　　　result = result.concat(buckets[n]);
    　　　　n++;
    　　}
    　　return result;
      }
      var elements = [3, 1, 5, 7, 2, 4, 9, 6, 10, 8];

      console.log(bucketSort(elements,4));

十，基数排序。

/**
* 基数排序适用于：
* (1)数据范围较小，建议在小于1000
* (2)每个数值都要大于等于0
* @author damonare
* @param arr 待排序数组
* @param maxDigit 最大位数
*/
//LSD Radix Sort

      function radixSort(arr, maxDigit) {
      　　var mod = 10;
      　　var dev = 1;
      　　var counter = [];
      　　console.time('基数排序耗时');
      　　for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
      　　　　for(var j = 0; j < arr.length; j++) {
      　　　　　　var bucket = parseInt((arr[j] % mod) / dev);
      　　　　　　if(counter[bucket]== null) {
      　　　　　　　　counter[bucket] = [];
      　　　　　　}
      　　　　counter[bucket].push(arr[j]);
      　　　　}
      　　　　var pos = 0;
      　　　　for(var j = 0; j < counter.length; j++) {
      　　　　　　var value = null;
      　　　　　　if(counter[j]!=null) {
      　　　　　　　　while ((value = counter[j].shift()) != null) {
      　　　　　　　　　　arr[pos++] = value;
      　　　　　　　　}
      　　　　　　}
      　　　　}
      　　}
      　　console.timeEnd('基数排序耗时');
      　　return arr;
      }
      var elements = [3, 1, 5, 7, 2, 4, 9, 6, 10, 8];

      console.log(radixSort(elements,2));