排序算法：冒泡排序，快速排序，堆排序，归并排序

1. 冒泡排序
   冒泡排序是基础简单的排序算法，现实中也用得很多。
   依次比较排序，不多说，上代码

function BubbleSort(arr) {
	var len = arr.length;
	var temp; 
	for(var i = 0; i < len; i++) { 
		for(var j = i + 1; j < len ; j++) { 
				if(arr[i] > arr[j]) { 
				temp = arr[i];
				arr[i] = arr[j]; 
				arr[j] = temp; 
			} 
		} 
	} 
}

2. 快速排序
随便取一个数（这里取的中间数）默认它为最小（或最大）进行比较，比当前这个数小的放在左边，比当前大的放右边
递归左右两边用concat合并左、中、右从而完成排序

 function QuirkSort(arr) { 
	if(arr.length <= 1) { 
		return arr; 
	} 
	var nowNober = arr.splice( Math.floor(arr.length/2), 1 ); 
	var leftArr = []; 
	var reightArr = []; 
	for(var i = 0; i < arr.length; i++) { 
		if(parseInt(arr[i])<=nowNober) { 
			leftArr.push(arr[i]);
		}else { 
			reightArr.push(arr[i]); 
		} 
	} 
	return QuirkSort(leftArr).concat(nowNober, QuirkSort(reightArr)); 
}

3. 堆排序（完全二叉树）

var len;
function buildMaxHeap(arr) { 
	//建立大顶堆 
	len = arr.length; 
	for (var i = Math.floor(len/2); i >= 0; i--) { 
		heapify(arr, i); 
	} 
} 
function heapify(arr, i) { 
	//堆调整 
	var left = 2 * i + 1, 
	right = 2 * i + 2, 
	largest = i; 
	if (left < len && arr[left] > arr[largest]) { 
		largest = left; 
	} 
	if (right < len && arr[right] > arr[largest]) { 
		largest = right; 
	} 
	if (largest != i) { 
		swap(arr, i, largest); 
		heapify(arr, largest); 
	} 
} 
function swap(arr, i, j) { 
	var temp = arr[i]; 
	arr[i] = arr[j]; 
	arr[j] = temp; 
} 
function heapSort(arr) { 
	buildMaxHeap(arr); 
	for (var i = arr.length-1; i > 0; i--) { 
		swap(arr, 0, i); 
		len--; 
		heapify(arr, 0); 
	} 
	return arr; 
}

4.归并排序
把一个问题缩小到一定程度，变成更小的问题来解决，这里做排序的最小问题是：f(n)>f(n+1)；
即可把一个数组分成两两相比较的相同问题
利用解决相同问题的解再合并成排序问题的解
分解出来的两两相比较问题必须是相互独立的，子问题之间不能包含公共的另一问题
代码如下：

function mergeSort(nums) {
	//遍历到一个数时返回去做比较
	if(num.length <= 1) {
		return nums;
	}
	//从中间分开
	var mid = Math.floor(nums.length/2);
	var left = nums.slice(0,mid);
	var right = nums.slice(mid);
	var leftArr = mergeSort(left);
	var rightArr = mergeSort(right);
	return Merg(leftArr, rightArr);//将左右合并
}
function Merg(left,right) {
	var result = [];
	while(left.length && right.length) {
		if(left[0]<=right[0]) {
			result.push(left.shift());
		}else {
			result.push(right.shift());
		}
	}
	while(left.length) {
		result.push(left.shift());
	}
	while(right.length) {
		result.push(right.shift());
	}
	return result;
}