JS常用排序算法

• 冒泡排序(基本思想：外层循环每一次经过两两比较，把每一轮未排定部分最大的元素放到了数组的末尾)

	function bubbleSort(arr) {
    	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], arr[j + 1]] = [arr[j + 1], arr[j]];
  			}
		}
            return arr
	}

• 选择排序(思路：每一轮选取未排定的部分中最小的部分交换到未排定部分的最开头，经过若干个步骤，就能排定整个数组。即：先选出最小的，再选出第 2 小的，以此类推)

sortArray = function(nums) {
  for (let i = 0; i < nums.length; i++) {
      let min = Infinity;
      let minIndex;
      for (j = i; j < nums.length; j++) {
          if (nums[j] < min) {
              min = nums[j]
              minIndex = j;
          }
      }
      [nums[i], nums[minIndex]] = [nums[minIndex], nums[i]];
  }
  return nums;
};

• 快速排序

	function quickSort(arr){
            //如果数组<=1,则直接返回
            if(arr.length<=1) return arr;
            var pivotIndex=Math.floor(arr.length/2);
            //找基准，并把基准从原数组删除
            var pivot=arr.splice(pivotIndex,1)[0];
            //定义左右数组
            var left=[];
            var right=[];
            //比基准小的放在left，比基准大的放在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));
        }  

• 插入排序(思路：每次将一个数字插入一个有序的数组里，成为一个长度更长的有序数组，有限次操作以后，数组整体有序)

	var sortArray = function(nums) {
    for(let i = 1,len = nums.length;i<len;i++) {
        const temp = nums[i]
        let j = i
        // 最小的放前面
        while(j > 0 && temp < nums[j-1]) {
            nums[j] = nums[j-1]
            j--
        }
        nums[j] = temp
    }
    	return nums
	};

• 归并排序 (通过先递归的分解数列，再合并数列就完成了归并排序)

// 归并排序
function mergeSort(arr) {
  let array = mergeSortRec(arr);
  return array;
}

// 若分裂后的两个数组⻓度不为 1，则继续分裂
// 直到分裂后的数组⻓度都为 1，
// 然后合并⼩数组
function mergeSortRec(arr) {
  let length = arr.length;
  if (length === 1) {
    return arr;
  }

  let mid = Math.floor(length / 2),
    left = arr.slice(0, mid),
    right = arr.slice(mid, length);

  return merge(mergeSortRec(left), mergeSortRec(right));
}

// 依次比较两个数组的每个数，谁小就先取谁，取了后就在对应数组中删除这个数。
// 然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。
function merge(left, right) {
  let result = [],
    i = 0,
    j = 0,
    k = 0;

  // i和j都不会越界
  while (i < left.length && j < right.length) {
    if (left[i] < right[j]) {
      result[k++] = left[i++];
    } else {
      result[k++] = right[j++];
    }
  }

  // j越界 即j已经遍历完了
  while (i < left.length) {
    result[k++] = left[i++];
  }

  // i越界 即i已经遍历完了
  while (j < right.length) {
    result[k++] = right[j++];
  }
  return result;
}