多种排序算法(插入、二分法【查找、排序】、选择、冒泡、快速、希尔)

多种排序算法(插入、二分法【查找、排序】、选择、冒泡、快速、希尔)

-------- 插入排序 ---------

   function insertSort(arr) {
        var len = arr.length;
        for (var i = 1; i < len; i++) {
            var key = arr[i];
            var j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                // console.log(arr);
                j--;
            }
            arr[j + 1] = key;
        }
        return arr;
    }
    console.log(insertSort([12, 11, 10, 4, 3]));

---------- 二分法排序 ---------

    function binaryInsertSort(arr) {
        for (var i = 1; i < arr.length; i++) {
            var key = arr[i],
                left = 0,
                right = i - 1;
            while (left <= right) {
                var middle = parseInt((left + right) / 2);
                if (key < arr[middle]) {
                    right = middle - 1;
                } else {
                    left = middle + 1;
                }
                console.log(arr);
            }
            for (var j = i - 1; j >= left; j--) {
                arr[j + 1] = arr[j];
                console.log(arr);
            }
            arr[left] = key;
            console.log(arr);
        }
        return arr;
    }
    // console.log(binaryInsertSort([12, 11, 10, 4, 3]));

这里可以对比记忆一下 二分法排序 和 查找 的异同

-------- 二分法查找 --------

   
    二分法查找算法：
     采用二分法查找时，数据需是排好序的。
     主要思想是：
        （0）设查找的数组区间为array[s, e]）
        （1）确定该区间的中间位置m
        （2）将查找的值T与array[m]比较,若相等，查找成功返回此位置；否则确定新的查找区域，继续二分查找。
     区域确定如下：
        这里设array从小到大排列,
        array[m]>T由数组的有序性可知array[m,……,e]>T;
        故新的区间为array[s,……，m-1],
        类似上面查找区间array[s,……，m-1]。
        每一次查找与中间值比较，判断是否查找成功，不成功当前查找区间缩小一半，循环查找，即可。
        时间复杂度:O(log2n)。
   
    function BinarySearch(arr, target) {
        let s = 0;
        let e = arr.length - 1;
        let m = Math.floor((s + e) / 2);
        let sortTag = arr[s] <= arr[e]; //确定排序顺序
        while (s < e && arr[m] !== target) {
            if (arr[m] > target) {
                sortTag && (e = m - 1);
                !sortTag && (s = m + 1);
            } else {
                !sortTag && (e = m - 1);
                sortTag && (s = m + 1);
            }
            m = Math.floor((s + e) / 2);
        }

        if (arr[m] == target) {
            console.log("找到了,位置%s", m);
            return m;
        } else {
            console.log("没找到");
            return -1;
        }
    }

-------- 选择排序 --------

     *  选择排序
     * 选择排序就是通过n - i次关键字间的比较，
     * 从n - i - 1个记录中选出关键字最小的记录，并和第i个记录进行交换。
     * 选择排序(Selection - sort)是一种简单直观的排序算法。
     * 它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
     * 然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
     * 以此类推，直到所有元素均排序完毕。

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

-------- 冒泡排序 --------

     * 冒泡排序
     * 冒泡排序是一种交换排序，
     * 它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，
     * 直到没有反序的记录为止。它重复地走访过要排序的数列，一次比较两个元素，
     * 如果它们的顺序错误就把它们交换过来。
     * 走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
     * 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
    
     function bubbleSort(arr) {
        var len = arr.length;
        for (var i = 0; i < len - 1; i++) {
            var n = 0;
            for (var j = 0; j < len - i; j++) {
                if (arr[j] < arr[j - 1]) {
                    n++;
                    // console.log(n);
                    var temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
            if (n < 1) {
                break;
            }
        }
        return arr;
    }
    console.log(bubbleSort([1, 2, 3]));

-------- 快速排序 --------

     * 快速排序
     * （1）在数据集之中，选择一个元素作为”基准”（pivot）。
     * （2）所有小于”基准”的元素，都移到”基准”的左边；所有大于”基准”的元素，都移到”基准”的右边。
     * （3）对”基准”左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。
     * 
    function quickSort(arr) {
        if (arr.length <= 1) {
            return arr;
        }
        var pivotIndex = Math.floor(arr.length / 2);
        var pivot = arr.splice(pivotIndex, 1)[0];
        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]);
            }
        }
        return quickSort(left).concat([pivot], quickSort(right));
    }
    console.log(quickSort([3, 2, 4, 10, 5, 6, 1]));

-------- 希尔排序 --------

   *  希尔排序
   *  希尔排序的实质是分组插入排序，该方法又称缩小增量排序。
   *  该方法的基本思想是：先将整个待排元素序列分割为若干个子序列（由相隔某个‘增量’的元素组成的）
   *  分别进行直接插入排序，然后依次缩减增量再进行排序，
   *  带这个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。
   *  因为直接插入排序在元素基本有序的情况下（接近最好情况）效率是很高的，
   *  因此希尔排序在时间效率上有较大的提高。

  function shallSort(array) {
      var increment = array.length;
      var i;
      var temp; //暂存
      var count = 0;
      do {
          //设置增量
          increment = Math.floor(increment / 3) + 1;
          for (i = increment; i < array.length; i++) {
              console.log(increment);
              if (array[i] < array[i - increment]) {
                  temp = array[i];
                  console.log(array);
                  for (
                      var j = i - increment; j >= 0 && temp < array[j]; j -= increment
                  ) {
                      array[j + increment] = array[j];
                  }
                  array[j + increment] = temp;
                  console.log(array);
              }
          }
          console.log("i", increment);
      } while (increment > 1);
      return array;
  }
  shallSort([8, 3, 6, 21]);

参考

js实现排序算法（冒泡、选择、插入、二分插入、快速、希尔）