排序算法

var SortBank = function() {
	// 简单的桶排序, 知道元素最大可能值
	// 共循环了:m+n+m+n次， 时间复杂度:O(M+N)， 浪费空间
	var tongSort = function (arr, callback) {
		var tong = [];
		for (var i = 0; i <=10; i++) {
			tong[i] = 0;
		}
		for (var i = 0; i < arr.length; i++) {
			tong[arr[i]]++;
		}
		for (var i = 0; i < 11; i++) {
			for (var j = 0; j < tong[i]; j++) {
				callback(i);
			}
		}
	}
	this.tongSort = function (arr, callback) {
		tongSort(arr, callback);
	}
	// 冒泡 O(N^2)
	this.bubbleSort = function (arr, callback) {
		for (var i = 0; i < arr.length - 1; i++) {
			for (var j = 0; j <= arr.length-i; j++) {
				if (arr[j] < arr[j+1]) {
					var temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
		callback(arr);
	}
	// 上 假如我们的计算机每秒钟可以运行 10 亿次，那么对 1 亿个数进行排序，桶排序只需要 0.1 秒，而冒泡排序则需要 1 千万秒，达到 115 天之久，

	// 快速排序的每一轮处理其实就是将这一轮的基准数归位，直到所有的数都归位为止，排序就结束了
	var array;
	var quickSort = function (left, right) {
		var temp, i, j; // 找一个基准数， 小于ta的放左边， 大于ta的放右边, 
		var t; // 用于换位
		if (left > right) {
			return;
		}

		temp = array[left];
		i = left;
		j = right;

		while (i !== j) {
			while (array[j] >= temp && i < j) {
				j--;
			}
			while (array[i] <= temp && i < j) {
				i++;
			}
			if (i < j) {
				t = array[i];
				array[i] = array[j];
				array[j] = t;
			}
		}
		// 基准数归为 这时候 left已经不是最初的left了， 所以还需要定义i,j
		array[left] = array[i];
		array[i] = temp;
		quickSort(left, i - 1);
		quickSort(i + 1, right);
	}
	this.quickSort = function (arr, callback) {
		array = arr;
		quickSort(0, array.length - 1);
		callback(array);
	}
}
var callback = function(v) {
	console.log(v);
}
var scores = [1, 8, 3, 5, 5, 2, 6, 1, 2, 7, 9, 3, 4, 5, 10, 8]; // 满分10分
var sortBank = new SortBank();
// sortBank.tongSort(scores, callback);
// sortBank.bubbleSort(scores, callback);
sortBank.quickSort(scores, callback);