C++ 如何改进这些嵌套for循环

我有以下代码：

// 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
        }
    }
}

//元素的向量
矢量图形；
//所选图形元素的索引向量
向量选择指数；
//必须根据其对图形元素进行“排序”和分析的向量
向量顺序；
用于（自动o:订单）
{
用于（自动i：选定的索引）
{
const auto&g=图形[i]；
如果（g.位置（）==o）
{
//解析g
}
}
}

我有一个自定义元素的向量以及已选择要分析的元素的索引，但这些元素的分析顺序取决于它们的

位置（）

值（根据第三个向量）

---

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

您已经知道要处理多少个元素，因此可以使用一个向量来保持指向

图形

实例的指针，已分配适当数量的元素：

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

---

您可以创建一个临时向量并一步一步地进行，而不是嵌套这些向量

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

矢量选择图形//也许在这里使用ptr
selectedGraphics.reserve（selected_index.size（））；
用于（自动i：选定的索引）
选择图形。向后推（图形[i]）；
//然后按照你的顺序分类
排序（selectedGraphics.begin（）、selectedGraphics.end（）、[order]（自动左、自动右）
{
//“left”位置的迭代器在“right”位置的前面
返回order.find（left.position（））

---

排序假设

顺序

矢量条目与

所选图形

匹配。如果所选图形对象的位置不在

顺序

向量中，我不确定是否会有任何奇怪的副作用

假设只有一个

图形
对象具有给定的
位置（）
：

构建一个无序的地图
：
int
→ <代码>图形*

，您称之为例如

gp

，因此

gp[i]->position（）

=

i

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

for( auto o : order )
{
    auto const& g = *gp[o];
    // parse g
}

如果给定位置可以有多个

图形

对象，则构建

无序地图

：

int

→ <代码>矢量，然后使用如下代码

for( auto o : order )
{
    for( auto const p : gp[o] )
    {
        auto const& g = *p;
        // parse g
    }
}

---

或者，对于最后一种情况，您可以使用

无序的\u多重映射

您可以展开排序过程吗？（向量顺序{2，1，3，0，4，5}的一个例子）。好的，我编辑了答案。应该是这样的。不过我不能测试它。为了完整性，我还添加了

保留

。你想要的改进是速度（执行时间）、可读性还是“优雅”？@Niall我想要的是速度改进。天真地构建地图的图形数是线性的。OP的代码是O（MN），但M是选择大小，N是订单大小，图形数量是O（1）。Hm：构建时，仅从选定索引向量构建。这会让你陷入O（M+N）吗？虽然在C++中，YEP.O符号不是全部。根据向量的大小，对其进行排序，然后迭代可能比迭代一个巨大的映射更快。

for( auto o : order )
{
    for( auto const p : gp[o] )
    {
        auto const& g = *p;
        // parse g
    }
}