Question

此函数检查向量a的元素是否在向量b中。它们应该是连续的。

bool i_vec(const vector<int>& a, const vector<int>& b)
{
    for(vector<int>::size_type i = 0; i <= b.size() - a.size(); i++)
    {
        if(equal(a.begin(), a.end(), &b[i]))
        {
            return true;
        }
    }
    return false;
}

我的递归方式。这是对的吗？

    vector<int>::iterator pos;

    pos = search(b.begin(),b.end(),a.begin(),a.end());
    if (pos != b.end())
    {
        cout << "true" << endl;
        return true;
    }
    cout << "false" << endl;
    return false;
}

Answer 1

几乎任何迭代算法都可以转换为递归算法，应该要问的问题是：这是一个好主意吗？

例如，添加无符号数字的函数：

def add(a,b):
    return a + b

可以通过以下方式递归：

def add(a,b):
    if a == 0:
        return b
    return add(a-1,b+1)

然而，这是一个可怕的想法，你可能会很快用完表达式的堆栈空间：

c = add(9999999999,4)

对于你有两个有序向量的特定情况，你可以很容易地做类似的事情，找到第一个公共元素，然后使用递归来同时推进每个列表索引。一旦你找到了共同元素，就会发生一些事情：

def contains(a,idxa,b,idxb):
    if idxa >= a.size or idxb >= b.size:
        return true
    if a[idxa] != b[idxb]:
        return false
    return contains(a,idxa+1,b,idxb+1)

但是您遇到与上面add相同的问题。对于足够大的列表，在获得结果之前，您将耗尽堆栈空间。

检查它的“更好”方法是，像resursive解决方案一样，找到第一个公共元素，但然后只是在循环中同时推进索引。这更具可读性，更不容易受到递归的限制。

有没有办法以递归形式编写此代码？

1 个答案: