算法分析-线性时间排序，决策树，计数排序，基数排序，桶排序【线性排序】

决策树引导

      通俗来说，决策树分类的思想类似于找对象。现想象一个女孩的母亲要给这个女孩介绍男朋友，于是有了下面的对话：

      女儿：多大年纪了？

      母亲：26。

      女儿：长的帅不帅？

      母亲：挺帅的。

      女儿：收入高不？

      母亲：不算很高，中等情况。

      女儿：是公务员不？

      母亲：是，在税务局上班呢。

      女儿：那好，我去见见。

      这个女孩的决策过程就是典型的分类树决策。相当于通过年龄、长相、收入和是否公务员对将男人分为两个类别：见和不见。假设这个女孩对男人的要求是：30岁以下、长相中等以上并且是高收入者或中等以上收入的公务员，那么这个可以用下图表示女孩的决策逻辑（声明：此决策树纯属为了写文章而YY的产物，没有任何根据，也不代表任何女孩的择偶倾向，请各位女同胞莫质问我^_^）：

      上图完整表达了这个女孩决定是否见一个约会对象的策略，其中绿色节点表示判断条件，橙色节点表示决策结果，箭头表示在一个判断条件在不同情况下的决策路径，图中红色箭头表示了上面例子中女孩的决策过程。

      这幅图基本可以算是一颗决策树，说它“基本可以算”是因为图中的判定条件没有量化，如收入高中低等等，还不能算是严格意义上的决策树，如果将所有条件量化，则就变成真正的决策树了。

      有了上面直观的认识，我们可以正式定义决策树了：

      决策树（decision tree）是一个树结构（可以是二叉树或非二叉树）。其每个非叶节点表示一个特征属性上的测试，每个分支代表这个特征属性在某个值域上的输出，而每个叶节点存放一个类别。使用决策树进行决策的过程就是从根节点开始，测试待分类项中相应的特征属性，并按照其值选择输出分支，直到到达叶子节点，将叶子节点存放的类别作为决策结果。

      可以看到，决策树的决策过程非常直观，容易被人理解。目前决策树已经成功运用于医学、制造产业、天文学、分支生物学以及商业等诸多领域。知道了决策树的定义以及其应用方法，下面介绍决策树的构造算法。

下面给出A[1，2，3]排序的决策树，是算法导论的原图：

思考：

在一颗比较排序算法的决策树中，一个叶结点可能的最小深度是多少？

分析：

最少进行n-1次比较，所以深度最小是n-1

 

下面给出代码：

COUNTING-SORT 在数组 A={6,0,2,0,1,3,4,6,1,3,2}上的操作过程。

(1)C[1..k]被初始化为0。
(2)把等于A[j]的个数C[A[j]]进行循环累加 C[6]=1+1=2 C[0]=1+1=2 C[2]=1+1=2 C[1]=1+1=2 C[3]=1+1=2 C[4]=1 
(3)把小于等于A[j]的个数C[A[j]]进行循环累加。
C[0]=2
C[1]=C[1]+C[0]=2+2=4
C[2]=C[2]+C[1]=2+4=6
C[3]=C[3]+C[2]=2+6=8
C[4]=C[4]+C[3]=1+8=9
C[5]=C[5]+C[4]=0+9=9
C[6]=C[6]+C[5]=2+9=11
(4)把A[j]放入到恰当的B[C[A[j]]]位置中去。
B[C[2]]=B[6]=2    C[2]--  C[2]=5
B[C[3]]=B[8]=3    C[3]--  C[3]=7
B[C[1]]=B[4]=1    C[1]--  C[1]=3
B[C[6]]=B[11]=6   C[6]--  C[6]=10
B[C[4]]=B[9]=4    C[4]--  C[4]=8
B[C[3]]=B[7]=3    C[3]--  C[3]=6
B[C[1]]=B[3]=1    C[1]--  C[1]=2
B[C[0]]=B[2]=0    C[0]--  C[0]=1
B[C[2]]=B[5]=2    C[2]--  C[2]=4
B[C[0]]=B[1]=0    C[0]--  C[0]=0
B[C[6]]=B[10]=6   C[6]--  C[6]=9  所以：B[10]={0,0,1,4,2,2,3,3,4,6,6}

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;
    }
};

//初始化数组全为0;
Array.prototype.setZero4arr = function (k) {
    var B = [];
    for (var i = 0; i <= k; i++) {
        B[i] = 0;
    }
    return B;
};


var A = [6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2],
    k = A.getMaxVal(),
    B = A.setZero4arr(A.length - 1);  //最后放入

//计数排序
Array.prototype.COUNT_SORT = function (max, B) {

    var C = this.setZero4arr(max);   //0...max


    for (var i = 0; i < this.length; i++) {
        C[this[i]]++;   //知道了每个数的个数
    }

    //累加得到最后的结果  C[i]包含了<= i 的个数。
    for (var j = 1; j < C.length; j++) {
        C[j] += C[j - 1];
    }
    //最后填充B
    for (var k = this.length - 1; k >= 0; k--) {
        B[C[this[k]] - 1] = this[k];

        //由于每个元素可能都不相同，因此，每当将一个值A[k]放入数组B中的时候，都要减少C[A[k]]的值，
        //这会使得下一个其值等于A[k]的输入元素（如果存在的话）直接进入输出数组B中A[k]的前一个位置。
        C[this[k]]--;

    }
    return B;
};

//思考 这样写对吗？稳定吗？看下面的思考题。
/*Array.prototype.COUNTING_SORT = function (k, B) {

    var C = this.setZero4arr(k);

    for (var i = 0; i < this.length; i++) {
        C[this[i]]++;
    }
    for (var j = 1; j < C.length; j++) {
        C[j] += C[j - 1];
    }

    for (var k = 0; k < this.length; k++) {
        B[C[this[k]] - 1] = this[k];
        C[this[k]]--;
    }
    return B;

};*/


console.log(A.COUNTING_SORT(k, B));

8.2-2 试证明COUNTING-SORT是稳定的。
由8.2-1例子可以发现 开始时候B[6]=2，这个是数组靠后位置的2，因为第4个循环是从后往前循环的，所以经过多次j--后，到了B[5]=2 这是考前位置的2.所以由8.2-1例子可以看出，原数组A靠后相同的数放到了新数组B靠后的位置，而原数组A靠前的数放到了新数组B靠前的位置。所以COUNTING-SORT是稳定的。

8.2-3 假设我们在COUNTING-SORT的第10行循环开始部分，将代码改写为：10.for j=1 to A.length 试证明该算法仍然正确，它还稳定吗？
如果把第10行改成for j=1 to A.length ，颠倒顺序处理元素的顺序，那么还是8.2-1的例子，其中的第(4)个循环就要微调了，对于相同元素来说，原数组靠前的相同元素出现在新数组靠后的位置上，反之亦然。所以就不稳定了。

 8.2-4 设计一个算法，它能够对于任何给定的驾驭0到K之间的n个整数先进行预处理，然后再O(1)时间内回答输入的n个整数中有多少个落在区间[a..b]内你设计的算法预处理时间应为Θ(n+k).
在n个整数中，通过第(3)个循环，计算出小于a值得元素个数C[a-1],小于等于b值得元素个数C[b]，两者差值就是在[a,b]区间上的元素个数。
设落在区间[a,b]上元素个数x=C[b]-C[a-1].

基数排序

基数排序不需要比较关键字的大小。

它是根据关键字中各位的值，通过对排序的N个元素进行若干趟“分配”与“收集”来实现排序的。 

不妨通过一个具体的实例来展示一下，基数排序是如何进行的。 

设有一个初始序列为: R {50, 123, 543, 187, 49, 30, 0, 2, 11, 100}。

我们知道，任何一个阿拉伯数，它的各个位数上的基数都是以0~9来表示的。

所以我们不妨把0~9视为10个桶。 

我们先根据序列的个位数的数字来进行分类，将其分到指定的桶中。例如：R[0] = 50，个位数上是0，将这个数存入编号为0的桶中。

                                   

分类后，我们在从各个桶中，将这些数按照从编号0到编号9的顺序依次将所有数取出来。

这时，得到的序列就是个位数上呈递增趋势的序列。 

按照个位数排序： {50, 30, 0, 100, 11, 2, 123, 543, 187, 49}。

接下来，可以对十位数、百位数也按照这种方法进行排序，最后就能得到排序完成的序列。

 

8.3-2 下面的排序算法中哪些是稳定的，插入排序，归并排序，堆排序和快速排序？给出一个能使任何排序算法都稳定的方法。
归并和插入排序是稳定的，因为他们不改变相同元素原有的顺序。堆排序和快速排序是不稳定的。如果想让以上4种排序都是稳定排序，那么我们保存原数组相同元素的下标，在进行比较排序时，不同元素肯定没有这个问题，而相同元素在原数组中较小的下标对应的值放入到前面，较大的放到后面。

 下面我给出基数排序的一个算法实现代码:

//基数排序
//他是基于计数排序的。

Array.prototype.COUNTING_SORT_4_RDIEX_SORT = function (b, d) {
    var C = this.setZero4arr(9);  //计数排序第一步
    var B = this.setZero4arr(this.length - 1);

    for (var j = 0; j < this.length; j++) { //计数排序第二步

        C[get_bit_val(this[j], b, d)]++;
    }

    for (var k = 1; k < C.length; k++) { //计数排序第三步
        C[k] += C[k - 1];
    }

    for (var i = this.length - 1; i >= 0; i--) { //计数排序第四步
        B[C[get_bit_val(this[i], b, d)] - 1] = this[i]; 
        C[get_bit_val(this[i], b, d)]--;  //这一步很关键，如果遇到重复的，以前是往前插入了，不然会覆盖。
    }
    return B;
};

//获得该数字第i位的数字,从个位开始取，如果没有这位的数，默认为0。
/*
 *  x是传入的数
 *  i是第几位
 *  最大数的长度
 * 
 * */
function get_bit_val(x, i, d) {
    x += "";
    var temp = x.split("");
    while (temp.length < d) {
        temp.unshift(0); //往前填充0
    }
    return temp[i];
}


Array.prototype.RDIEX_SORT = function () {
    var k = this.getMaxVal().toString();
    var d = k.length;
    var B = [];
    for (var i = d - 1; i >= 0; i--) {
        i == d - 1 ? B = this.COUNTING_SORT_4_RDIEX_SORT(i, d) : B = this.COUNTING_SORT_4_RDIEX_SORT.call(B, i, d);
    }
    return B;
};

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

桶排序Bucket sort

---

补充说明三点

1,桶排序是稳定的

2,桶排序是常见排序里最快的一种,比快排还要快…大多数情况下

3,桶排序非常快,但是同时也非常耗空间,基本上是最耗空间的一种排序算法

二.算法描述

        例如要对大小为[1..1000]范围内的n个整数A[1..n]排序，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储(10..20]的整数，……集合B[i]存储((i-1)*10, i*10]的整数，i = 1,2,..100。总共有100个桶。然后对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。 然后再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任何排序法都可以。最后依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这样就得到所有数字排好序的一个序列了。

        下图表示出了桶排序作用于有10个数的输入数组上的操作过程。

 

                                             

function getR2(x, y) {
    return x * x + y * y;
}
Array.prototype.BUCKET_SORT = function () {
    var n = this.length; //n个桶
    var d2 = 0;//点到（0，0）的距离的平方
    var num = Math.ceil(d2 * n); //放在第几个桶里。
    var B = []; //当放桶子用
    var result = [];
    for (var i = 0; i < n; i++) {
        B[i] = {val: [], next: null};
    }

    for (var j = 0; j < n; j++) {
        d2 = getR2(this[j].x, this[j].y);
        num = Math.ceil(d2 * n);
        if (num === 0) num++; //直接在原点直接设为第一个桶子里
        B[num - 1].val.push(this[j]);
    }

    for (var k = 0; k < n; k++) {
        if (B[k].val.length == 0) {
            continue;
        }
        B[k].val.INSERT_SORT();
        // result.concat(B[k].val);
        result = result.concat(B[k].val);
    }
    return result;
};
Array.prototype.INSERT_SORT = function () {
    for (var i = 1; i < this.length; i++) {
        var key = this[i];
        var j = i - 1;
        while (j >= 0 && this[j] > key) {
            this[j + 1] = this[j];
            j--;
        }
        this[j + 1] = this[i];
    }
    return this;
};

var A = [{x: 0, y: 0}, {x: 0.21, y: 0.3}, {x: 1, y: 0}];

console.log(A.BUCKET_SORT());