js算法（排序）

js排序

常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

1. 快速排序

• 先从数列中取出一个数作为“基准”。
• 分区过程：将比这个“基准”大的数全放到“基准”的右边，小于或等于“基准”的数全放到“基准”的左边。
• 再对左右区间重复第二步，直到各区间只有一个数。

var quickSort = function(arr) {
    if (arr.length <= 1) { return arr; }
    var pivotIndex = Math.floor(arr.length / 2);   //基准位置（理论上可任意选取）
    var pivot = arr.splice(pivotIndex, 1)[0];  //基准数
    var left = [];
    var 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));  //链接左数组、基准数构成的数组、右数组
};

2. 选择排序
   希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
   希尔排序是基于插入排序的以下两点性质而提出改进方法的：

• 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
• 从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
• 重复第二步，直到所有元素均排序完毕。
  希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行依次直接插入排序。
  
• 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
• 按增量序列个数 k，对序列进行 k 趟排序；
• 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

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;
}

3. 冒泡排序

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

var arr = [5,4,8,1,3,7,0,9,2,6];
var len = arr.length;
var tmp = null;
for(var j=0; j<len-1; j++){      //循环9次
   for (var i=0; i<len-1-j; i++) {    //每次比较10-j-1次数
   if (arr[i]>arr[i+1]) {
       tmp = arr[i+1];
       arr[i+1] = arr[i];
       arr[i] = tmp;
   }
}　　
console.log('第'+（j+1）+'次循环',arr);<br> }

4.选择排序

• 依次找到剩余元素最小值，放置排好序的末尾（第一个放在开头）。代码如下:

	var arr = [5,4,8,1,3,7,0,9,2,6];
   	var len = arr.length;
    var min = null;
    var tmp = null;
    //选择排序
    for(var j=0; j<len-1 ; j++){
        min = j;
        for(var i=j+1; i<len ;i++){
            if(arr[i] < arr[min]){
                min = i;
            }
        }
        tmp = arr[j]
        arr[j] = arr[min];
        arr[min] = tmp;

        console.log('第'+(j+1)+'次循环', arr);
    }

5. 希尔排序

• 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
• 从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
• 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

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;
}

6. 插入排序

• 即构建有序序列，未排序数据依次从已排序数据按从后往前比较，插入到合适的位置。代码如下：

  var arr = [5,4,8,1,3,7,0,9,2,6];
  var len = arr.length;
  var cur = null;
  var tmp = null;

  //插入排序
  for(var j=1; j<len ; j++){       //从第二个开始比较
      cur = j-1;
      tmp = arr[j];           //带插入元素
      while (cur >= 0 && arr[cur] > tmp) {
          arr[cur+1] = arr[cur];
          cur--;
      }
      arr[cur+1] = tmp;
     
      console.log('第'+(j)+'次循环', arr);
  }

7. 归并排序

• 把序列分成两个长度为n/2的子序列
• 对这两个子序列分别归并排序（循环将两个数组的第一个值比较，并弹出第一个值， 直到数组长度都不存在）
• 将两个排序好的子序列合并成一个最终的排序序列

 var arr = [5,4,8,1,3,7,0,9,2,6];
 var merge_sort = function(v){
	 var merge = function(left, right){
	     var final = [];
	     while(left.length && right.length) {//两个数组的第一个值比较，并删除第一个值
	         final.push(left[0] <= right[0] ? left.shift() : right.shift());
	     }
	     console.log(final.concat(left.concat(right)));
	     return final.concat(left.concat(right));
	 }
	
	 //将数组分为2组
	 var len = v.length;
	 if (len < 2) return v;
	 var mid = len / 2; 
	 return merge(
	  merge_sort(v.slice(0, parseInt(mid))),
	  merge_sort(v.slice(parseInt(mid)))
	 );
 }
 merge_sort(arr);