马士兵算法与数据结构学习（1）

排序

选择排序

• 选择排序是最简单也是最没有用的排序算法：时间复杂度O(n^2),还不稳定，最好和最坏情况均
  o(n^2)，空间复杂度是O(1),空间复杂度，值得是像有无开辟一个新的数组去存储，像是在快速排序中开辟一个变量进行存储，这样的可以胡忽略不计

代码

  quickSort = (arr: Array<number>)=>{
        if (!arr.length) return arr;
        for (let i = 0; i < arr.length-1; i++) {
          let minPos = i;
          let temp;
          for (let j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minPos]) {
              minPos = j;
            }
          }
          temp = arr[i];
          arr[i] = arr[minPos];
          arr[minPos] = temp;
        }
        return arr;
      }

冒泡排序

• 时间复杂度 O(n^2),最好情况是 O(n），最坏 O(n^2） 空间复杂度O(1)

代码

 bubble = (arr: Array<number>): Array<number> => {
  for (i=0; i<len-1; i++) /* 外循环为排序趟数，len个数进行len-1趟 */
     let didSwap = false;
        for (j=0; j<len-1-i; j++) {
        let temp;
        if (arr[i] > arr[i + 1]) {
          temp = arr[i];
          arr[i] = arr[i + 1];
          arr[i + 1] = temp;
          didSwap = true;
        }
      }
      if (didSwap == false) {
        return arr;
      }
    }
    return arr;
  };

插入排序

代码

  insert = (arr: Array<number>): Array<number> => {
    if (!arr.length) return arr;
    let temp;    
    //插入排序是每一次选定一个数跟前边的数去比较，把这个数插入到比它大的前边
    for (let i = 1; i < arr.length ; i++) {
      for (let j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
        //  if (arr[j] < arr[j - 1]) {
          temp = arr[j];
          arr[j] = arr[j-1];
          arr[j-1] = temp;
          flag = true;
          
        // }
      }
    }

    return arr;
  };

简单排序

选择排序，冒泡排序，插入排序，都是简单排序

希尔排序（改进版的插入排序）

• 间隔大的时候，移动的次数少，在间隔小的时候，移动的距离短

简单插入排序很循规蹈矩，不管数组分布是怎么样的，依然一步一步的对元素进行比较，移动，插入，比如[5,4,3,2,1,0]这种倒序序列，数组末端的0要回到首位置很是费劲，比较和移动元素均需n-1次。而希尔排序在数组中采用跳跃式分组的策略，通过某个增量将数组元素划分为若干组，然后分组进行插入排序，随后逐步缩小增量，继续按组进行插入排序操作，直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序，小的基本在前，大的基本在后。然后缩小增量，到增量为1时，其实多数情况下只需微调即可，不会涉及过多的数据移动。
　我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量

代码

 shellSort = (arr: Array<number>): Array<number> => {
    if (!arr.length) return arr;
    for (let gap = Math.floor(arr.length/2); gap >0; gap = Math.floor(gap/2)) {
      for (let i = gap;i<arr.length; i++) {
        for (let j = i; j > gap - 1; j -= gap) {
          if (arr[j] < arr[j - gap]) {
            let temp = arr[j];
            arr[j] = arr[j - gap];
            arr[j - gap] = temp;
          }
        }
      }
    }
    return arr;
  };

//希尔排序
function shellSort(arr) {
    var gap = Math.floor(arr.length/2);
    for( gap; gap>0;gap=Math.floor(gap/2)) {
        for(var i = gap; i<arr.length;i++) {
            var current = arr[i];
            var preIndex = i-gap;
            while(preIndex>=0 && arr[preIndex] > current) {
                arr[preIndex+gap] = arr[preIndex]
                preIndex = preIndex -gap;
            }
            arr[preIndex+gap] = current
        }

    }
    console.log(arr)
}
shellSort([7,6,12,3,45,1,3])

归并排序

• 递归实现（j
• ava,python内部都是用的这种排序）