数组排序

插入排序

定义：后一项与前一项的比较，把后一项作为比较项临时保存起来，当前一项大于比较项时，前一项往后移，

而比较项继续和前一项进行比较，直到前一项小于比较项时，把比较项插入到当前项的后一项中,覆盖原来的值。

/*
  原数组：[1,35,54,3,6,4,7]
  拷贝一份原数组：[1,35,54,3,6,4,7]  i：后一项(比较项)  j：前一项

  第一轮
  i=1,j=0   1  < 35  [1,35,54,3,6,4,7] 
  第二轮
  i=2,j=1   35 < 54  [1,35,54,3,6,4,7] 
  第三轮
  i=3,j=2   54 > 3   [1,35,54,54,6,4,7] 
        j=1   35 > 3   [1,35,35,54,6,4,7]
        j=0   1  <  3   [1,3,35,54,6,4,7]
  第四轮
  ......
  
  直接插入排序至少需要array.length-1轮。
*/
function sort(array) {
  var len = array.length,
	i, j, tmp, result;
  result = array.slice(0);
  for (i = 1; i < len; i++) {
	tmp = result[i];
	j = i - 1;
	// result[j] < tmp时，则为降序排序
	while (j >= 0 && result[j] > tmp) {
	  result[j + 1] = result[j];
	  j--;
	}
	result[j + 1] = tmp;
  }
  return result;
}

冒泡排序

定义：当前项和后一项进行比较，如果当前项大于后一项，两者交换位置。

 /* 
  [4, 3, 5, 2, 1];
  第一轮：虽然没有实现最后目标，但是已经把数组中最大的那个值放到数组最后的位置
  4>3 交换位置 [3,4,5,2,1]
  4<5 不需要交换位置 [3,4,5,2,1]
  5>2 交换位置 [3,4,2,5,1]
  5>1 交换位置 [3,4,2,1,5]
  第二轮
  ....

  每一轮当前项和后一项两两比较的话，虽然不一定达到最后的目标结果，但是已经把当前最大的那个值放在后面了，
  数组一共有n项，只需要比较n-1轮，把n-1个最大值分别的放在末尾，就实现了排序。

  i：轮数 i<ary.length-1
  j:每一轮比较的次数 ary.length-1-i（不用和自己比）
*/
function bubbleSort(array) {
  var i, j, len = array.length,
	temp = null;
  for (i = 0; i < len; i++) {
	for (j = 0; j < len - 1 - i; j++) {
	  if (array[j] > array[j + 1]) {
		temp = array[j];
		array[j] = array[j + 1];
		array[j + 1] = temp;
	  }
	}
  }
  return array;
}

冒泡排序优化

/* 
  以上分析说的是每轮最多的次数，也可能不需要四轮就可以,所以存在可以优化的空间
    [2, 1, 3, 5, 4]
    第一轮
    2>1 [1,2,3,5,4]
    2<3 [1,2,3,5,4]
    3<5 [1,2,3,5,4]
    5>4 [1,2,3,4,5] ->在这已经排序好了，后面的没必要再比较了
    第二轮
    1<2 [1,2,3,4,5]
    2<3 [1,2,3,4,5]
*/
function bubbleSort2(array) {
  var i, j, len = array.length,
	flag = false;
  for (i = 0; i < len; i++) {
	for (j = 0; j < len - 1 - i; j++) {
	  if (array[j] > array[j + 1]) {
		array[j] = array[j] + array[j + 1];
		array[j + 1] = array[j] - array[j + 1];
		array[j] = array[j] - array[j + 1];
		flag = true;
	  }
	}
	if (flag) {
	  flag = false;
	} else {
	  break;
	}
  }
  return array;
}

快速排序

实现步骤：
    1)首先在数组中找一个“基准点”；（一般选择数组中间的这一项,如果array.length/2不是整数时，Math.floor(array.length/2),eg:一共有九项，结果是4，即第五项为中间项；一共10项，结果是5，即第六项为中间项）
    2)拿基准点和数组中的其它项进行比较，比基准点小的放左边，大的放右边
    3)以后的每一项都重复上述的两个操作，直到当前这一边只有一项的时候停止处理...

function quickSort(array) {
  if (array.length <= 1) {
	return array;
  }
  var pointIndex = Math.floor(array.length / 2);
  var pointValue = array.splice(pointIndex, 1)[0];
  var left = [];
  var right = [];
  var i = null,
	len = array.length;
  for (i = 0; i < len; i++) {
	var cur = array[i];
	cur < pointValue ? left.push(cur) : right.push(cur);
  }
  return quickSort(left).concat([pointValue], quickSort(right));
}