JavaScript 种常见的几种数组排序方式

1. Array.prototype.sort()
   Javascript 的 sort() 方法是最常用最快的方法；

   /**
    * 用原地算法对数组的元素进行排序
    * @params compareFunction 可选 指定按某种顺序进行排列的函数
    * @return Array 排序后的数组
    * Array.prototype.sort()
   */
   
   const arr = [5, 8, 1, 4, 9, 3, 7];
   // 升序
   console.log(arr.sort((a, b) => a - b)); // [1, 3, 4, 5, 7, 8, 9]
   // 降序
   console.log(arr.sort((a, b) => b - a)); // [9, 8, 7, 5, 4, 3, 1]
   

2. 冒泡排序

   const arr = [5, 8, 1, 4, 9, 3, 7];
   const arrSort = (array) => {
   	const len = array.length;
   	for (var i = 0; i < len - 1; i++) {
   		// 两两比较，如果前一个比后一个大，则交换位置
   		for (var j = 0; j < len - 1 - i; j++) {
   			if (array[j] > array[j+1]) {
   				var temp = array[j + 1];
   				array[j + 1] = array[j];
   				array[j] = temp;
   			}
   		}
   	}
   	return array;
   }
   console.log(arrSort(arr)); // [1, 3, 4, 5, 7, 8, 9]
   

   排序思路：
   1. 相邻的两个元素，如果前一个比后一个大，则交换位置。
   2. 完第一轮的时候，最后一个元素是最大的元素。
   3. 不重复的彻底比较全部元素
3. 快速排序
   递归思想，两边快速的排序，冒泡排序的改进

   const arr = [5, 8, 1, 4, 9, 3, 7];
   const quickSort = (array) => {
   	// 如果数组长度小于等于 1，返回数组本身
   	if (array.length <= 1) {
   		return array;
   	}
   	// 定义中间值的索引
   	var index = Math.floor(array.length / 2);    // 向下取整
   	// 取到中间值
   	var temp = array.splice(index, 1)[0];  // 向数组中添加项目，或从数组中删除项目，并返回被删除的项目
   	// 定义左右部分数组
   	var left = [];
   	var right = [];
   	for (var i = 0; i < array.length; i++) {
   		// 如果元素比中间值小，则放在左边，否则放在右边
   		if (array[i] < temp) {
   			left.push(array[i]);
   		} else {
   			right.push(array[i]);
   		}
   	}
   	return quickSort(left).concat([temp], quickSort(right));
   }
   console.log(quickSort(arr));    // array.length
   

   说明：
   1. index 整数，被操作项目所在的位置（必须）
   2. num 整数，要删除的项目的数量，如果为 0,示不删除（必须）
   3. item 向数组中添加的新项目，可以是多个（可选）
      push() 法是向数组末尾添加一个或多个新项目并返回新数组的长度
      concat() 法连接两个或多个数组，不会改变原有数组，返回一个新数组
4. 插入排序

   const arr = [5, 8, 1, 4, 9, 3, 7];
   const sort = (array) => {
   	// 假设第 0 个元素是有序的，第一个元素之后是无序的序列
   	// 从第一个元素开始依次将无序序列的元素插入到有序序列中
   	for (let i = 0; i < array.length; i++) {
   		if (array[i] < array[i - 1]) {
   			// 取出无序序列中需要插入的第 i 个元素
   			var temp = array[i];
   			// 定义有序序列中的最后一个位置
   			var j = i - 1;
   			array[i] = array[j];
   			// 比较大小，找到插入的位置
   			while (j >= 0 && temp < arr[j]) {
   				array[j + 1] = array[j];
   				j--;
   			}
   			插入
   			array[j + 1] = temp;
   		}
   	}
   	return array;
   }
   console.log(sort(arr)); // [1, 3, 4, 5, 7, 8, 9]
   

   排序思路：
   1. 从第一个元素开始，该元素可以认为已经被排序
   2. 取出下一个元素，在已经排序的元素序列中扫描
   3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
   4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
   5. 将新元素插入到下一位置中
   6. 重复步骤2
5. 选择排序

   const arr = [5, 8, 1, 4, 9, 3, 7];
   const selectSort = (array) => {
   	for (let i = 0; i < array.length; i++) {
   		// 设置当前范围最小值和索引
   		var min = array[i];
   		var minIndex = i;
   		// 在该范围内选出最小值
   		for (let j = i + 1; j < array.length; j++) {
   			if (min > arr[j]) {
   				min = arr[j];
   				minIndex = j;
   			}
   		}
   		// 将最小值插入， 并将原来位置的最小值删除
   		array.splice(i, 0, min);
   		array.splice(minIndex + 1, 1);
   	}
   	return array;
   }
   console.log(selectSort(arr)); // [1, 3, 4, 5, 7, 8, 9]
   

   排序思路：
   1. 在未排序序列中找到最小（大）元素
   2. 并存放到排序序列的起始位置
   3. 然后，再从剩余未排序元素中继续寻找最小（大）元素
   4. 然后放到已排序序列的末尾
   5. 以此类推