数组排序方法

        var arr = [6, 3, 5, 1, 9, 4, 7, 8, 2];

1、冒泡排序：
比较相邻的两项，如果第一项比第二项大，则交换他们。

        //冒泡排序
        Array.prototype.bubbleSort = function () {
            var len = this.length;
            for (var i = 0; i < len; i++) {
                for (var j = 0; j < len - i - 1; j++) {
                    if (this[j] > this[j + 1]) {
                        var temp = this[j];
                        this[j] = this[j + 1];
                        this[j + 1] = temp;
                    }
                }
            }
        }
       arr.bubbleSort();

2、选择排序
原址比较排序算法。找到数据结构中的最小值放在第一位，然后找到第二小的值放到第二位…

        Array.prototype.selectSort = function () {
            var len = this.length,
                minIndex,
                temp;
            for (var i = 0; i < len; i++) {
                minIndex = i;
                
                //找到最小值的索引
                for (var j = i; j < len; j++) {
                    if (this[j] < this[minIndex]) {
                        minIndex = j;
                    }
                }
                if (minIndex !== i) {
                    temp = this[minIndex];
                    this[minIndex] = this[i];
                    this[i] = temp;
                }
            }
        }
        arr.selectSort();

3、插入排序
每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。

        Array.prototype.insertSort = function () {
            var len = this.length,
                temp = this[0],
                tempIndex = 0;
            for (var i = 1; i < len; i++) {
                tempIndex = i;
                temp = this[i];
                while (tempIndex > 0 && this[tempIndex - 1] > temp) {
                    this[tempIndex] = this[tempIndex - 1];
                    tempIndex--;
                }
                this[tempIndex] = temp;
            }
        }
        arr.insertSort();

4、归并排序
是一种分治算法。思想是将原始数组分成较小的数组直到每个数组中只有一项，接着将小数组按序归并成大数组。

        function mergeSort(originArr) {
            var len = originArr.length,
                mid, left, right;
            if (len == 1) {
                return originArr;
            }
            mid = Math.floor(len / 2);
            left = originArr.slice(0, mid);
            right = originArr.slice(mid, len);
            return merge(mergeSort(left), mergeSort(right));
        }
        function merge(left, right) {
            var resultArr = [];
            while (left.length && right.length) {
                if (left[0] < right[0]) {
                    var item = left.shift();
                    resultArr.push(item);
                } else {
                    var item = right.shift();
                    resultArr.push(item);
                }
            }
            return resultArr.concat(left, right);
        }
        var sortedArr = mergeSort(arr);

5、快速排序
也是一种分治算法。选择数组中的中间项作为key值，将比key小的项放入左侧数组中，比key大的想放到右侧数组中；然后对划分后的小数组重复此步骤。

        function quickSort(originArr) {
            var len = originArr.length,
                key = originArr[Math.floor(len / 2)],
                left = [], right = [], mid = [], curValue;
            if (len < 2) {
                return originArr;
            }
            for (var i = 0; i < len; i++) {
                curValue = originArr[i];
                if (curValue < key) {
                    left.push(curValue);
                } else if (curValue > key) {
                    right.push(curValue);
                } else {
                    mid.push(curValue);
                }
            }
            return [].concat(quickSort(left), mid, quickSort(right))
        }
        var nowArr = quickSort(arr);