js 排序算法

1. 冒泡排序（Bubble Sort）

基本思想

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个的位置。
2. 依次比较相邻元素，从开始第一对到结尾的最后一对。比较一遍后，最后的元素为最大的数。
3. 再对除了最后一个元素以外所有的元素重复以上的步骤，直到全部排序完成。

算法实现：

// 定义交换函数
function swap(arrs, p1, p2) {
	let tmp= arrs[p1];
    arrs[p1] = arrs[p2];
    arrs[p2] = tmp;
}

function bubbleSort(arrs) {
     for (let i = 0; i < arrs.length; i += 1) {
         for (let j = 0; j < arrs.length - 1 - i; j += 1) {
             if (arrs[j] > arrs[j + 1]) {
             	 // 如果前一位比后一位大，则交换
                 swap(arrs, arrs[j], arrs[j + 1]);
             }
         }
     }
 }
 let arrs1 = [2, 1, 4, 3, 6, 5];
 sort(arrs1);
 console.log(JSON.stringify(arrs1));

排序结果：

2. 选择排序（Selection sort）

基本思想

1. 先默认下标为0的数为最小元素，遍历数组与之比较，如果遇到更小的数，获取更小值的索引…这样完成一次遍历后，拿到最小值的索引；
2. 重复以上步骤，从第二位开始比较，拿到第二小的值，放到下标为2的位置…直至遍历完成。

算法实现：

// 定义交换函数
function swap(arrs, p1, p2) {
	let tmp= arrs[p1];
    arrs[p1] = arrs[p2];
    arrs[p2] = tmp;
}

function selectionSort(arrs) {
	let min = 0;
    let len = arrs.length;
    for (i=0; i < len - 1; i+=1 ){
        // 将当前位置设为最小值
        min = i;
        
        for (j=i+1; j < len; j+=1 ){
        	// 如果数组其余元素更小，则获取到更小值的下标
            if (arrs[j] < arrs[min]) {
                min = j;
            }
        }
        // 如果当前位置不是最小值，将其换为最小值
        if (i !== min){
            swap(arrs, i, min);
        }
    }
    return arrs;
}

3. 插入排序（Insertion sort）

基本思想

1. 将数组分成“已排序”和“未排序”两部分，默认第一个元素已排序完成；
2. 循环过程中，将“未排序”元素与“已排序”部分的最后一位比较，若比其大，则对下一个“未排序”元素进行排序；
3. 如果“未排序”元素比“已排序”元素最后一位小，则与最后一位元素的前一位比较，并且同时将对比过的“已排序”元素向后覆盖。

算法实现：

function insertSort(arrs) {
  let length = arrs.length;
  let temp;   // 当前应该比较的值
  let i;      // 未排序部分的当前位置
  let j;	  // 已排序部分的当前位置
  for(i = 1; i < length; i++) {
    temp = arrs[i]; 
    for(j = i; j > 0; j--) {
      if(arrs[j] >= arrs[j-1]) {
        break;      // 当前考察的数大于前一个数，证明有序，退出循环
      }
      arrs[j] = arrs[j-1]; // 将前一个数复制到后一个数上
    }
    arrs[j] = temp;  // 找到考察的数应处于的位置
  }
  return arrs;
}

4. 快速排序（Quick sort）

基本思想

任意选取一个数据作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。

算法实现：

function quickSort(array) {
   const sort = (arr, left = 0, right = arr.length - 1) => {
      if (left >= right) { //如果左边的索引大于等于右边的索引说明整理完毕
          return
      }
      let i = left
      let j = right
      const baseVal = arr[j] // 取无序数组最后一个数为基准值
      while (i < j) { //把所有比基准值小的数放在左边大的数放在右边
          while (i < j && arr[i] <= baseVal) { //找到一个比基准值大的数交换
              i++
          }
          arr[j] = arr[i] // 将较大的值放在右边如果没有比基准值大的数就是将自己赋值给自己（i 等于 j）
          while (j > i && arr[j] >= baseVal) { //找到一个比基准值小的数交换
              j--
          }
          arr[i] = arr[j] // 将较小的值放在左边如果没有找到比基准值小的数就是将自己赋值给自己（i 等于 j）
      }
      arr[j] = baseVal // 将基准值放至中央位置完成一次循环（这时候 j 等于 i ）
      sort(arr, left, j - 1) // 将左边的无序数组重复上面的操作
      sort(arr, j + 1, right) // 将右边的无序数组重复上面的操作
  }
  const newArr = array.concat() // 为了保证这个函数是纯函数拷贝一次数组
  sort(newArr)
  return newArr
}