前端 排序算法基础记录

写在前：

1，非线性时间比较类排序：

1）交换排序： 冒泡排序、快速排序

2）插入排序： 简单插入排序、希尔排序

3）选择排序：简单选择排序、堆排序

4）归并排序：二路归并排序、多路归并排序

2，线性时间非比较类排序：

1）计数排序

2）桶排序

3）基数排序

---

冒泡排序：比较相邻的元素，如果第一个比第二个大，就交换他们两个。

function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len - 1; i++) {
        for (var j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {       // 相邻元素两两对比
                var temp = arr[j+1];       // 元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

---

选择排序：

原理：在未排序序列中找到最小元素，存放在排序序列的起始位置，然后，在从剩余未排序元素中寻找最小元素，然后存放在已排序序列的末尾。

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {    // 寻找最小的数
                minIndex = j;                // 将最小数的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
} 

---

插入排序：

1，从第一个元素开始，该元素可以认为已经被排序；

2，取出下一个元素，在已经排序的元素序列中从后向前扫描，

3，如果该元素（已排序）大于新元素，将该元素移到下一位置，

4，重复3，直到找到已排序的元素小于或者等于新元素的位置，

5，将新元素插入到该位置后

6，重复2~5

function insertionSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while (preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex + 1] = current;
    }
    return arr;
}

---

希尔排序：

function shellSort(arr) {
    var len = arr.length,
        temp,
        gap = 1;
    while (gap < len / 3) {         // 动态定义间隔序列
        gap = gap * 3 + 1;
    }
    for (gap; gap > 0; gap = Math.floor(gap / 3)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i-gap; j > 0 && arr[j]> temp; j-=gap) {
                arr[j + gap] = arr[j];
            }
            arr[j + gap] = temp;
        }
    }
    return arr;
}

---

归并排序： 把长度为n的输入序列分成两个长度为n/2的子序列，对这两个子序列分别采用归并排序，将两个排序好的子序列合并成一个最终的排序序列。

function mergeSort(arr) { // 采用自上而下的递归方法
  var len = arr.length;
   if (len < 2) {
      return arr;
  }
  var middle = Math.floor(len / 2),
      left = arr.slice(0, middle),
      right = arr.slice(middle);
  return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right) {
  var result = [];
  while (left.length>0 && right.length>0) {
      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;
}

其他：https://segmentfault.com/a/1190000020072884