【用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);

改进二：分而治之

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

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

$minfree(A)=search(A,0,|A|-1)$

$search(A,l,u)= \begin{cases} l, & \text{A=$\phi$} \\ search(A'',m+1,u), & \text{|$A'$|=m-$l$+1}\\ search(A',l,m),&\text{其他} \end{cases}$

$其中，\\ m=\lfloor\frac{l+u}{2}\rfloor \\A'=\{\forall x \in A \land x\le m \}\\A''=\{\forall x \in A \land 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;
}