冒泡排序

冒泡排序的主要思想是，按照某一顺序（从后向前或从前向后）逐一比较相邻的元素，按照规定的条件交换元素位置，每次循环可以确定一个元素的最终位置，所以冒泡排序在外层共需要数组长度-1次的循环来确定所有元素的正确位置。有如下一个数组：

var arr = [5,7,10,3,4,6,20,9,0];

如下图，我们从后向前循环，第一次循环比较完之后，0会被换到第一个位置上：

以此类推,要进行N-1次的循环，就能完成排序。

function bubbleSort(arr){
  var len = arr.length, i, j;
  // 外层循环次数为数组长度-1
  for(i = len - 1; i >= 1; i--){
      //内层循环交换元素，循环长度最开始为数组长度，依次递减
    for(j = 0; j <= i - 1; j++){
        //满足条件交换位置
      if(arr[j] > arr[j + 1]){
        d = arr[j + 1];
        arr[j + 1] = arr[j];
        arr[j] = d;
      }
    }
  }
  return arr;
}

快速排序

首先选出一个关键值，以这个值为基准，循环遍历数组，将数组分成比关键值大的一组(left)和比关键值小的一组(right)，之后再递归调用方法，直到传入的数组长度为1时，直接返回，并按照left，关键值，right将数组进行连接，实现排序。
如下图所示：

代码实现如下：

function quickSort(arr){
  if(arr.length <= 1) return arr;
  //关键值索引
  var pivotIndex = Math.floor(arr.length/2)
      // 获取关键值
    , pivot = arr.splice(pivotIndex, 1)[0]
    // 根据关键值分组
    , 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));
}

归并排序

归并排序首先要将待排序的数组进行分解，分解成多个单元素的数组，之后先进行两两比较，确定顺序后合并，再将合并后的数组进行两两比较，确定顺序并合并，直到所有数组合并完成。如下图：

分组：

归并排序：

代码实现：

function mergeSort (items) {
    //递归分组，分组到每组只有一个元素，返回该数组
    if(items.length==1){
        return items;
    }
    var middle=Math.floor(items.length/2),
    left=items.slice(0,middle),
    right=items.slice(middle);
    return merge(mergeSort(left),mergeSort(right));
}

function merge (left,right) {
    //排序，先比较一个值得数组之间的大小，并进行排序，之后递归结果
    var result=[];
    while(left.length>0 && right.length>0){
        //单个元素时只比较0位置的元素，多个时是已经排好顺序的，所以也
        if(left[0]<right[0]){
        /*shift()方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。*/
            result.push(left.shift());
        }else{
            result.push(right.shift());
        }
    }
    return result.concat(left).concat(right);
}