算法分析-前七章排序算法全实现，为第八章线性排序使用。

var A = [6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2];

Array.prototype.swap = function (i, j) {
    var temp = this[j];
    this[j] = this[i];
    this[i] = temp;
};

Array.prototype.getMaxVal = function () {
    //可以用任意我们学过的排序方法写，我们学过冒泡，选择，归并，快排，堆排序。
    //当然这样我们只要取出最大值即可，不需要全部排序，但是为了学程序，我将给出我们已经学过的所有排序方法，并全部排序
    var r = this.length - 1;
    //   return this.BUBBLE_SORT()[r];
    //    return this.SELECT_SORT()[r];
    //    return this.QUICK_SORT(0, r)[r];
    //heap_size = r+1; return.this.HRAP_SORT()[r];
    // return this.MERGE_SORT(0,r)[r];
    return this.INSERT_SORT()[r];
};
//冒泡
Array.prototype.BUBBLE_SORT = function () {

    //冒泡就是两两将换，
    for (var i = this.length - 1; i > 0; i--) {
        for (var j = 0; j < i; j++) {
            if (this[j] > this[j + 1]) {
                this.swap(j, j + 1);
            }
        }
    }
    return this;
};


//选择排序

Array.prototype.SELECT_SORT = function () {
    for (var i = 0; i < this.length - 1; i++) {
        var min = this[i];  //默认选择第一个最小;
        var index = i;  //记录最小值的坐标

        for (var j = i + 1; j < this.length; j++) {
            if (this[j] < min) {
                min = this[j];
                index = j;
            }
        }
        this.swap(index, i);
    }
    return this;
};


//随机算法-快排
//思想就是分治，递归。
//最主要的函数就是PARTITION,返回下标i,i的左边都比A[i]小，右边比他大；
Array.prototype.PARTITION = function (p, r) {
    var i = p - 1;
    var x = this[r];
    for (var j = p; j <= r - 1; j++) {
        if (this[j] < x) {
            this.swap(++i, j);

        }

    }
    this.swap(++i, r);
    return i;
};

Array.prototype.RANDOM_PARTION = function (p, r) {

    var q = p + Math.round(Math.random() * (r - p));
    this.swap(q, r);
    return this.PARTITION(p, r);
};

Array.prototype.QUICK_SORT = function (p, r) {
    if (r > p) {
        var q = this.RANDOM_PARTION(p, r);
        arguments.callee.call(this, p, q - 1);
        arguments.callee.call(this, q + 1, r);
    }
    return this;
};


//堆排序
//其核心函数在于MAX_HRAPTITY,总能让i位置是最大的。
var heap_size = 0; //包含heap_size下标在内的，之后的下标都是排序好的。

Array.prototype.HEAP_SORT = function () {
    this.BUILD_MAX_HEAP();
    while (heap_size > 1) {
        this.swap(0, --heap_size);
        this.MAX_HEAPTIFY(0);
    }
    heap_size = this.length; //最后复原
    return this;
};

//生成最大堆
Array.prototype.BUILD_MAX_HEAP = function () {

    for (var i = Math.floor(this.length / 2) - 1; i >= 0; i--) {
        this.MAX_HEAPTIFY(i);
    }
};

//生成以i为根节点，它为最大值
Array.prototype.MAX_HEAPTIFY = function (i) {
    var largest = i;
    var l = i * 2 + 1;
    var r = i * 2 + 2;

    if (l < heap_size && this[l] > this[largest]) {

        largest = l;
    }

    if (r < heap_size && this[r] > this[largest]) {

        largest = r;
    }
    if (largest !== i) {
        this.swap(largest, i);
        arguments.callee.call(this, largest);
    }
};

//heap_size = A.length;
//归并排序
//其核心思想是分治，递归

Array.prototype.MERGE_SORT = function (start, end) {

    if (end > start) { //记住这里没有等号，不然会一直递归下去。
        var middle = Math.floor((start + end) / 2);
        arguments.callee.call(this, start, middle);
        arguments.callee.call(this, middle + 1, end);
        this.MEAGE(start, middle, end);
    }
    return this;
};

Array.prototype.MEAGE = function (s, m, e) {
    var A = this.slice(s, m + 1),
        B = this.slice(m + 1, e + 1),
        lenA = m + 1 - s,
        lenB = e - m,
        i = 0,
        j = 0;

    while (i < lenA && j < lenB) {
        A[i] < B[j] ? this[s++] = A[i++] : this[s++] = B[j++];
    }
    while (i < lenA) {
        this[s++] = A[i++];
    }
    while (j < lenB) {
        this[s++] = B[j++];
    }
};


//插入排序
Array.prototype.INSERT_SORT = function () {
    try {
        if (this.length < 1) {
            throw new Error("错误长度的数组");
        }
        for (var i = 1; i < this.length; i++) {
            var j = i - 1,
                temp = this[i];
            while (this[j] > temp && j >= 0) {
                this[j + 1] = this[j];
                j--;
            }
            this[j + 1] = temp;
        }

    } catch (e) {
        console.error(e);
    } finally {
        return this;
    }
};