5

我有一个std::vector<T>变量。我还有两个 T 类型的变量，第一个表示要插入的向量中的值，而第二个表示要插入的值。

所以可以说我有这个容器：1,2,1,1,2,2

并且根据上面的定义，这两个值是 2 和 3。然后我想写一个函数来更新容器，而不是包含：

1,2,3,1,1,2,3,2,3

我正在使用 c++98 和 boost。我可以使用哪些 std 或 boost 函数来实现此功能？

遍历向量并使用 std::insert 是一种方法，但是当人们意识到您需要记住跳过刚刚插入的值时，它会变得混乱。

4

4 回答 4

7

这就是我可能会做的：

vector<T> copy;
for (vector<T>::iterator i=original.begin(); i!=original.end(); ++i)
{
    copy.push_back(*i);
    if (*i == first)
        copy.push_back(second);
}
original.swap(copy);

如果你愿意，可以打电话预约。你知道你至少需要空间来容纳original.size()元素。您还可以对向量进行初始迭代（或使用std::count）来确定要保留的元素的确切数量，但如果不进行测试，我不知道这是否会提高性能。

于 2013-08-15T16:13:08.380 回答
3

我提出了一个解决方案，它可以在内存中的 O(n) 和 O(2n) 时间内就地运行。Laethnes 提出的解决方案在时间上不是 O(n^2)，而 Benjamin 提出的解决方案在内存中是 O(2n)。

// First pass, count elements equal to first.
std::size_t elems = std::count(data.begin(), data.end(), first);
// Resize so we'll add without reallocating the elements.
data.resize(data.size() + elems);
vector<T>::reverse_iterator end = data.rbegin() + elems;
// Iterate from the end. Move elements from the end to the new end (and so elements to insert will have some place).
for(vector<T>::reverse_iterator new_end = data.rbegin(); end != data.rend() && elems > 0; ++new_end,++end)
{
  // If the current element is the one we search, insert second first. (We iterate from the end).
  if(*end == first)
  {
    *new_end = second;
    ++new_end;
    --elems;
  }
  // Copy the data to the end.
  *new_end = *end;
}

这个算法可能有问题，但想法是每个元素只复制一次：

  1. 首先计算我们需要插入多少元素。
  2. 其次，通过从末端检查数据并将每个元素移动到新的末端。
于 2013-08-15T16:32:28.197 回答
1

这就是我可能会做的：

typedef ::std::vector<int> MyList;
typedef MyList::iterator MyListIter;

MyList data;

// ... fill data ...

const int searchValue = 2;
const int addValue = 3;

// Find first occurence of searched value
MyListIter iter = ::std::find(data.begin(), data.end(), searchValue);

while(iter != data.end())
{
    // We want to add our value after searched one
    ++iter;

    // Insert value and return iterator pointing to the inserted position
    // (original iterator is invalid now).
    iter = data.insert(iter, addValue);

    // This is needed only if we want to be sure that out value won't be used
    // - for example if searchValue == addValue is true, code would create
    // infinite loop.
    ++iter;

    // Search for next value.
    iter = ::std::find(iter, data.end(), searchValue);
}

但正如你所看到的，我无法避免你提到的增量。但我认为这不是坏事：我会将这段代码放在单独的函数中（可能在某种“核心/实用程序”模块中）并且 - 当然 - 将此函数实现为模板，所以我只会编写它一次 - 恕我直言，只有一次担心增加价值是可以接受的。非常可以接受。

template <class ValueType>
void insertAfter(::std::vector<ValueType> &io_data,
                 const ValueType &i_searchValue,
                 const ValueType &i_insertAfterValue);

甚至更好（恕我直言）

template <class ListType, class ValueType>
void insertAfter(ListType &io_data,
                 const ValueType &i_searchValue,
                 const ValueType &i_insertAfterValue);

编辑：

好吧，我会以不同的方式解决问题：首先计算搜索值出现的次数（最好存储在某种可以保存和重复使用的缓存中），这样我就可以在之前准备数组（只有一个分配）并使用 memcpy 移动原始值（当然，仅适用于 int 等类型）或 memmove（如果向量分配的大小已经足够）。

于 2013-08-15T16:21:51.213 回答
1

就地，O(1) 额外内存和 O(n) 时间（住在 Coliru）：

template <typename T, typename A>
void do_thing(std::vector<T, A>& vec, T target, T inserted) {
    using std::swap;

    typedef typename std::vector<T, A>::size_type size_t;
    const size_t occurrences = std::count(vec.begin(), vec.end(), target);
    if (occurrences == 0) return;

    const size_t original_size = vec.size();
    vec.resize(original_size + occurrences, inserted);

    for(size_t i = original_size - 1, end = i + occurrences; i > 0; --i, --end) {
        if (vec[i] == target) {
            --end;
        }
        swap(vec[i], vec[end]);
    }
}
于 2013-08-15T17:19:55.063 回答