一些排序算法(冒泡排序，快速排序)

算法一定不能报错，不管逻辑对或错，只要报错，那算法绝对不通过，所以在一开始要加验证数据(代码的健壮性，也叫鲁棒性robust)

快速排序

function quickSort(arr, begin, end) {
    if (arr === null || arr.length <= 0 || begin >= end) return;
    var left = begin;
    var right = end;
    var pivot = arr[left];
    while (left < right) {
        while (left < right && pivot < arr[right]) {
            right--;
        }
        /* 注意交换数据不需要判断left是否小于right，
        因为外面的while循环会判断，即使一开始
        left < right然后进行了left++或right--后
        两者相等了，那么它多余的进行一次数据的交换
        也毫无关系(不影响最终的值，下次便会跳出这个循环)
        如果不想让left==right的时候加一句left == right || 
        swap(arr, left, right)即可
        */
        swap(arr, left, right);
        while (left < right && arr[left] < pivot) {
            left++;
        }
        swap(arr, left, right);
    }
    quickSort(arr, begin, left - 1);
    quickSort(arr, left + 1, end);

    return arr;
}

function swap(arr, a, b) {
    var temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

冒泡和选择排序的实质就是每次循环将最大的/最小的数放到数组末尾，然后除掉它，将剩余的数据再迭代进行比较，将剩余的数据中最大的放到数组倒数第二位…

冒泡排序

function bubbleSort (arr) {
	if(arr === null || arr.length <=0 ) return;
	var len = arr.length;
	for(var i = 0; i < len;++i) {
		for(var j = 0;j < len - i - 1;++j) {
			if(arr[j + 1] < arr[j]) {
				swap(arr, j+1, j);//如果需要从大到小排序将if语句中改为arr[j+1] > arr[j]
			}
		}
	}
}
function swap(arr, a, b) {
    var temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

选择排序

function selectSort(arr) {
	if(arr === null || arr.length < 0) return;
	var len = arr.length;
	var tempIndex;
	for(var i = 0; i < len; ++i) {
		tempIndex = 0;//默认每次冒泡的第一个数最大
		//第二层循环次数改变是因为此时并不是arr[j]和arr[j+1]比了，而是
		//arr[j]和arr[0]比较，所以需要每个数都和arr[0]进行一次比较，第一
		//次相当于arr[0]和arr[0]比较，那也可以不让他们比较，也就是改为
		//for(var j = 1;j < len - i -1;++j)
		for(var j = 0; j < len - i;++j) {
			if(arr[tempIndex] < arr[j]) {
				tempIndex = j;
			}
		}
		swap(arr, tempIndex, len - i - 1);
	}
	return arr;
}

1. for循环中i++会产生临时变量(需要缓存)，而++i不需要，但是却能达到一样的效果，后者更高效，所以for循环中尽量写++i
2. 快速排序更适合混乱无序的数组，冒泡排序和选择排序更适合尽可能有序的数组