在std::list中合并(将两个项目融合在一起，用融合替换）项目的算法(即破坏性聚类）

如果这很明显，我很抱歉，我是C++新手。stackoverflow上似乎有相关的答案，只是我对这些答案的理解不够，无法应用于我的案例。

我有一个表示视觉补丁的类实例列表。当特征之间的距离低于阈值时，我希望合并这些项，用合并的输出替换父项。

类似这样的东西：

1. 使用嵌套for循环遍历所有项目（将每个项目与其他项目进行比较）

2. 当找到匹配时（不是同一个实例）：

   1. 从匹配的对中构造一个新的（子）实例，附加到新列表中。

   2. 从列表中删除两个（父）项目

3. 继续迭代列表，查找其他匹配

4. 将新列表附加到原始列表。

我知道如何使用迭代器在单个for循环中从列表中删除项目，但由于erase（）递增到下一个项目，我不清楚它在嵌套循环中如何工作。

我可能还需要使这个函数递归，因为最终合并应该通过合并合并将列表减少为一组有代表性的实例。

如有建议，不胜感激。

以下是我的尝试，但不起作用（嵌套循环会干扰其中一个和另一个）。对列表中的元素进行这种成对比较的正确方法是什么

#include <iostream>
#include <list>
using namespace std;
int main() {
list<int> mylist;
list<int>::iterator mylistiterOutter;
list<int>::iterator mylistiterInner;
for(int i=0; i<10; i++) {
    mylist.push_back(i);
    cout << i << endl;
}
for(int i=0; i<10; i++) {
    mylist.push_back(i);
    cout << i << endl;
}
int counter =0;
for(mylistiterOutter = mylist.begin(); mylistiterOutter != mylist.end();) {
    cout << "Size of mylist: " << mylist.size() << endl;
    for(mylistiterInner = mylist.begin(); mylistiterInner != mylist.end();) {
        cout << "mylistiterInner: " << *mylistiterInner << endl;
        cout << "mylistiterOutter: " << *mylistiterOutter << endl;
        //if (mylistiterOutter == mylistiterInner) {// match!
        if (false) {
            //mylistiterOutter = mylist.erase(mylistiterOutter);
            //mylistiterInner = mylist.erase(mylistiterInner);
        } else {
            mylistiterOutter++;
            mylistiterInner++;
        }
        counter++;
    }
}
cout << endl << "Size of mylist: " << mylist.size() << endl << "NumIterations: " << counter << endl;
return(0);
}

谢谢@lalitm。我先尝试了你的方法，因为它更接近我最初的设想，但J.N.的建议更优雅，所以我也会尝试。不幸的是，我无法让@lalitm的方法发挥作用。（导致分段故障）。下面是稍微复杂一点的代码，其中包括示例类和合并代码，使用@lalitm的方法：

#include <iostream>
#include <list>
#include <cmath>
using namespace std;
class percepUnit {
public:
    int cx, cy; // location of percept in frame
    bool remove; // used to delete percepts
    // constructor method
    percepUnit(int ix, int iy) {
        cx = ix;
        cy = iy;
        remove = false;
    }
};
bool canMerge(percepUnit unitA, percepUnit unitB) {
    double dist = sqrt(pow(abs(unitA.cx-unitB.cx),2)+ pow(abs(unitA.cy-unitB.cy),2));
    return (dist < 3);
}
percepUnit merge(percepUnit unitA, percepUnit unitB) {
    int x,y;
    x = unitA.cx+unitB.cx/2;
    y = unitA.cy+unitB.cy/2;
    return (percepUnit(x,y));
}
int main() {
    list<percepUnit> mylist;
    list<percepUnit> mergedlist;
    list<percepUnit>::iterator mylistiterOutter;
    list<percepUnit>::iterator mylistiterInner;
    bool mylistiterOutterChanged;
    mylist.push_back(percepUnit(0,0));
    mylist.push_back(percepUnit(2,2));
    mylist.push_back(percepUnit(5,5));
    mylist.push_back(percepUnit(7,7));
    //cout << "merge front/back? " << canMerge(mylist.front(),mylist.back()) << endl;
    //percepUnit test = merge(mylist.front(),mylist.back());
    //cout << "merged front/back (x,y): " << test.cx << "," << test.cy << endl;
    for(mylistiterOutter = mylist.begin(); mylistiterOutter != mylist.end();) {
    cout << "Size of mylist: " << mylist.size() << endl;
        mylistiterInner = mylistiterOutter;
        mylistiterOutterChanged = false;
        for (++mylistiterInner; mylistiterInner != mylist.end();) {
            if (canMerge(*mylistiterOutter, *mylistiterInner )) {
                mergedlist.push_back(merge(*mylistiterOutter, *mylistiterInner));
                mylistiterOutter = mylist.erase(mylistiterOutter);
                mylistiterInner = mylist.erase(mylistiterInner);
                mylistiterOutterChanged = true;
            } else {
               ++mylistiterInner;
            }
        }
        if (!mylistiterOutterChanged) {
            ++mylistiterOutter;
        }
    }
    mylist.splice(mylist.end(), mergedlist);

    return(0);
}

这是我的gdb信息：

Program received signal SIGSEGV, Segmentation fault.
0x00007ffff7b31d97 in std::_List_node_base::unhook() ()
   from /usr/lib/libstdc++.so.6
(gdb) bt
#0  0x00007ffff7b31d97 in std::_List_node_base::unhook() ()
   from /usr/lib/libstdc++.so.6
#1  0x0000000000401786 in std::list<percepUnit, std::allocator<percepUnit> >::_M_erase (this=0x7fffffffe4d0, __position=...)
at /usr/include/c++/4.4/bits/stl_list.h:1424
#2  0x000000000040153d in std::list<percepUnit, std::allocator<percepUnit> >::erase (this=0x7fffffffe4d0, __position=...)
at /usr/include/c++/4.4/bits/list.tcc:111
#3  0x0000000000401130 in main () at debug.cpp:61

仍然没有运气。我认为问题可能是上面的代码没有测试两个迭代器是否指向列表中的同一项，因此会混淆迭代器（在不应该增加的情况下增加或不增加）。

如何测试两个迭代器是否指向同一项（没有比较所有类成员的蛮力？，但同一实例的两个副本不是同一实例。）