Question

我有以下代码：

// vector of elements
vector<Graphic> graphics;

// vector of indexes of the selected graphic elements
vector<int> selected_indexes;

// vector according to which the graphic elements have to be "sorted" and parsed
vector<short> order;

for (auto o : order)
{
    for (auto i : selected_indexes)
    {
        const auto& g = graphics[i];

        if (g.position() == o)
        {
            // parse g
        }
    }
}

我有一个自定义元素的向量以及已经选择要解析的元素的索引，但是这些元素必须被解析的顺序取决于它们的position()值，根据第三个矢量。

有没有办法改进这些嵌套循环，避免反复迭代将跳过的元素，因为它们的位置不等于当前的顺序？

Answer 1

假设只有一个具有给定Graphic的{{1}}个对象：

建立position()：unordered_map→int，您可以致电Graphics*，以便gp = gp[i]->position()。

构建地图是线性时间，对每个索引使用它是大致恒定的时间。

如果某个位置可以有多个for( auto o : order ) { auto const& g = *gp[o]; // parse g }个对象，请构建Graphics：unordered_map→int，然后使用

等用法代码

vector<Graphic*>

或者，对于最后一种情况，您可以使用for( auto o : order ) { for( auto const p : gp[o] ) { auto const& g = *p; // parse g } }。

Answer 2

您已经知道要处理多少个元素，因此您可以使用一个向量来指向已分配了适当数量元素的Graphic实例：

vector<Graphic*> selected(selected_indexes.size(), nullptr);

然后，您可以使用order

排序的元素填充此向量

for (auto index: selected_indexes) {
  auto where = std::find_if(order.begin(), order.end(), [&graphics, index] (short i) { return i == graphics[index].position(); });
  selected[*where] = &graphics[index];
}

Answer 3

您可以创建临时矢量并逐步执行此操作，而不是嵌套这些矢量。

vector<Graphic> selectedGraphics; //maybe use ptr here
selectedGraphics.reserve(selected_indexes.size());
for(auto i : selected_indexes)
    selectedGraphics.push_back(graphics[i]);

//then sort according to your order
std::sort(selectedGraphics.begin(),selectedGraphics.end(),[order](auto left, auto right)
{
    //the iterator of the position of "left" is further in front of the position of "right"
    return order.find(left.position()) < order.find(right.position());
});

//then process
for(auto graphic : selectedGraphics)
    //do whatever

排序假设order向量条目和selectedGraphics匹配的条目。如果选定的图形对象的位置不在order向量中，我不确定是否会有任何奇怪的副作用。

如何改进这些嵌套for循环

3 个答案: