算法分析-中位数和顺序统计学

Array.prototype.findMaxAndMin = function () {

    if (this.length == 0) return {min: null, max: null};

    var min, max, index = 0; //两个数之间的最大值，最小值 还有下标；
    var temp_max, temp_min = 0;

    //偶数
    if (this.length % 2 == 0) {
        if (this[0] > this[1]) {
            max = this[0];
            min = this[1];
        } else {
            min = this[0];
            max = this[1];
        }
        index = 2;
    } else {  //奇数
        min = this[0];
        max = this[0];
        index = 1;
    }

    //采用迭代
    while (index < this.length - 1) {
        if (this[index] < this[index + 1]) {
            temp_max = this[index + 1];
            temp_min = this[index];
        } else {
            temp_max = this[index];
            temp_min = this[index + 1];
        }
        max = temp_max > max ? temp_max : max;
        min = temp_min < min ? temp_min : min;
        index += 2;
    }

    return {min: min, max: max};
};

var A = [16, 22, 2, 323320, 13, 3, 2321, 45546, 5766, 7, 23];
console.log(A.findMaxAndMin());

 

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

Array.prototype.RANDOM_PARTITION = function (p, r) {
    console.log("p", p, "r", r);
    var random = Math.round(p + Math.random() * (r -p));

    this.swap(random, r);
    return this.PARTITION(p, r);
};

Array.prototype.PARTITION = function (p, r) {
    var x = this[r];
    var i = p - 1;

    for (var j = p; j < r; j++) {
        if (this[j] < x) {
            this.swap(++i, j);
        }
    }
    this.swap(r, ++i);
    return i;
};

Array.prototype.RONDOMIZED_SORT = function (p, r, i) {
    if (p == r) return this[p];

    var q = this.RANDOM_PARTITION(p, r);

    var k = q - p + 1;  //计算A[p..q]一共有多少元素

    if (i == k)  return this[q];

    if (i < k) {
        return arguments.callee.call(this, p, q - 1, i); //记住这里一定要加return 才会逐级往上返回。
    } else {
        return arguments.callee.call(this, q + 1, r, i - k); //因为所求在大端，我们已经知道k前面个数字是不符合的，所以要减去
    }
};


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

console.log(A.RONDOMIZED_SORT(0, A.length - 1, 9));

RANDOMIZED-SELECT 算法采用快速排序算法的思想。区别是，快速排序会递归地处理划分的两边，而 RANDOMIZED-SELECT 则只处理一边。所以快速排序的期望运行时间是 Θ(n lg n)，而 RANDOMIZED-SELECT 的期望运行时间为 Θ(n)。

RANDOMIZED-SELECT 的最坏运行时间为 Θ(n²)，即使是要选择最小元素也是如此。因为它是随机化的，该算法的平均情况性能较好。

9.2-1 证明：在RANDOMIZED-SELECT中，对长度为0的数组，不会进行递归调用。

看上面的代码，从RANDOMIZED-SELECT函数知，长度为0的数组 p=r，那么直接返回A[p].不做下面的随机划分和递归调用。

9.2-3 给出RANDOMIZED-SELECT的一个基于迭代的版本。

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

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

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

Array.prototype.PARTITION = function (p, r) {
    var x = this[r];
    var i = p - 1;

    for (var j = p; j < r; j++) {
        if (this[j] < x) {
            this.swap(++i, j);
        }
    }
    this.swap(r, ++i);
    return i;
};

Array.prototype.RANDOM_SELECT = function (p, r, i) {
    var type = 0;
    var q;  //q左边的都比q小，反之都大于等于
    var k;  //A[p...r]子数组的元素个数

    while (true) {
        if (p == r) break;
        q = this.RANDOM_PARTITION(p, r);

        k = q - p + 1;

        if (k == i) {
            type = 1;
            break;
        }

        if (i < k) {
            r = q - 1;
        } else {
            p = q + 1;
        }

    }
    return type ? this[q] : this[p];
};


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

console.log(A.RANDOM_SELECT(0, A.length - 1, 2));

下面给出一个更简介的代码：

var A = [100, 122, 223, 334, 445, 556, 556, 666, 777];
var B = [9, 9, 9, 10, 11, 12, 13, 14, 15];

function getMedian(A, B) {

    while (true) {
        var n = A.length;

        if (n > 1) {
            if (A[Math.floor(n / 2)] > B[Math.floor(n / 2)]) {
                A = A.slice(0, Math.floor(n / 2) + 1);
                B = B.slice(Math.floor(n / 2), n + 1);
            } else {
                B = B.slice(0, Math.floor(n / 2) + 1);
                A = A.slice(Math.floor(n / 2), n + 1);
            }
        } else {
            return A[0] < B[0] ? A[0] : B[0];
        }
    }
}
console.log(getMedian(A, B));