【用JavaScript学算法】最小可用ID

假设我们是用非负整数作为某个系统的ID，所有用户都由一个ID唯一确定。任何时间，这个系统中的有些ID处于使用中的状态，有些ID则可以分配给新用户。问题是，怎样才能找到最小的可分配ID呢？
样例输入：[18, 4, 8, 9, 16, 1, 14, 7, 19, 3, 0, 5, 2, 11, 6]
样例输出：10

暴力解决

算法时间复杂度O(n^2)

var notBelong = function (x,array){ for(var i =0;i<array.length;i++){//            console.log('x=%d,array[%d]=%d',x,i,array[i])        if(x == array[i]){            return false;        }    }    return true;}var minFree = function (array){    var x = 0;    for(var i=0;i< a.length;i++){        if(notBelong(x,array)){            return x;        }else{            x+=1;        }    }}var a = [18, 4, 8, 9, 16, 1, 14, 7, 19, 3, 0, 5, 2, 11, 6];var x = minFree(a);console.log(x); //10

改进一：hash

算法时间复杂度O(n)，但是需要O(n)的空间存储标志。

var minFree = function (array) {    var x = 0;    var flag = new Array(array.length);    for(var i=0;i< array.length;i++){        flag[array[i]]=1;    }    for(i=0;i<array.length;i++){        if(!flag[i]){            return i;        }    }}var a = [18, 4, 8, 9, 16, 1, 14, 7, 19, 3, 0, 5, 2, 11, 6];var x = minFree(a);console.log(x);

改进二：分而治之

策略：将问题分解为若干规模较小的子问题，然后逐步解决它们以得到最终的结果。
思路：
将所有满足xi≤⌊n/2⌋的整数放入一个子序列A’，并将剩余的整数放入另一个序列A”。根据minfree(x1,x2,...,xn)≤n，如果序列A’的长度正好是⌊n/2⌋，说明前一半的整数已经“满了”，最小的可用整数一定可以在A”中递归地找到。否则，最小的可用整数可以在A’中找到。

递归实现：
递归结束的边界条件是带查找的序列为空，返回下界作为结束。
minfree(A,l,u)，l是下界，u是上界。

minfree(A)=search(A,0,|A|−1)

search(A,l,u)=⎧⎩⎨l,search(A′′,m+1,u),search(A′,l,m),A=ϕ|A′|=m-l+1其他

其中，m=⌊l+u2⌋A′={∀x∈A∧x≤m}A′′={∀x∈A∧x>m}

时间复杂度：
第一次需要O(n)次比较来划分序列A’和A”，第二次需要比较O(n/2)次，第三次O(n/4)……总时间为O(n+n/2+n/4+…)=O(2n)=O(n)。

function search(a, l, u) {    console.log("l=%d,u=%d",l,u);    var m = Math.floor((l+u)/2);    if (a.length == 0) {        return l;    }    var t1 = new Array();    var t2 = new Array();    for(var i = 0;i< a.length;i++){        if(a[i]<=m){            t1.push(a[i]);        }else{            t2.push(a[i]);        }    }    if(t1.length == Math.floor(m-l+1)){        return arguments.callee(t2,m+1,u);    }else{        return arguments.callee(t1,l,m);    }}var a = [18, 4, 8, 9, 16, 1, 14, 7, 19, 3, 0, 5, 2, 11, 6];var x = search(a,0,a.length-1);console.log(x);  //10

优化：迭代实现
递归的深度是O(lgn)，因此调用栈的大小也是O(lgn)，因此空间复杂度并不能忽略。
所以，可以使用迭代来避免空间上的占用。

var minFree = function (array) {    var length = array.length;    var l = 0;    var u = length - 1;    var temp;    while (length) {        var m = Math.floor((l + u) / 2);        var right = 0, left = 0;        for (right = 0; right < length; ++right) {            if (array[right] <= m) {                temp = array[left];                array[left] = array[right];                array[right] = temp;                ++left;            }        }        if (left == m - l + 1) {            array = array.slice(left);            console.log(array);            length = length - left;            l = m + 1;        } else {            length = left;            u = m;        }    }    return l;}