经典算法

冒泡排序

• 比较相邻的元素
  • 如果第一个比第二个大，就调换位置。
  • 如果第一个比第二个小或者相等，就跳过比较下一个。
  • 以此类推，比较完所有的然后结束比较。

function bubbleSort(arr) {
  if (arr.length < 1) return 
  for (let i = 0; i < arr.length - 1; i++) {
    for (let j = 0; j < arr.length - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j + 1], arr[j]] = [arr[j], arr[j + 1]]
      }
    }
  }
  return arr
}

bubbleSort([1,5,2,3,5,7.0,20])

插入排序

• 插入排序是 最简单直观 的排序。
• 工作原理：通过构建有序序列，对于未排序数据，在已排序序列中 从后向前 扫描，找到相应位置并插入。

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

InsertionSort([1,4,6,3,7,9,0,23,42,55])

选择排序

• 首先在未排序的数列中找到最大或者最小的数，放到数列首位
• 其次，再在剩余未排序的数列中找到最大或者最小的数，放到数列末尾
• 以此类推，直至全部找完

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

selectionSort([3,2,5,3,6,7,8,9,0])

归并排序

• 分割
  • 将待排序的线性表不断地切分成若干个子表，直到每个子表只包含一个元素，这时，可以认为只包含一个元素的子表是有序表。
• 归并
  • 将子表两两合并，每合并一次，就会产生一个新的且更长的有序表，重复这一步骤，直到最后只剩下一个子表，这个子表就是排好序的线性表。

function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  const middle = Math.floor(arr.length / 2);
  const left = arr.slice(0, middle);
  const right = arr.slice(middle);
  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;
}

mergeSort([2,5,1,4,2,5,6])

快速排序

• 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小。
• 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  let pivotIndex = Math.floor(arr.length / 2);
  let pivot = arr.splice(pivotIndex, 1)[0];
  let left = [];
  let right = [];
  for (let 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));
}

quickSort([1,4,2,5,67,8,8])