Performance issue with a n X n search in a container - algorithm

Question

I have a customized array implementation for a geometry (vertex) . Each element of the array is represented by the vertex which has a Point . Now I want to check the distance between each point for the vertex in the array . So essentially for every vertex in the array of size n I will loop till n and calculate the distance of vertex point with all n vertex points in the array . So a pseudo code will look like this
func MyFunc( Array iVrtxList , vrtx inpVertex )
{
point refPt = inpVertex->getPoint();
for ( i=0 ; i < iVrtxList.size(); i++)
{
if( distanceBetween(iVertexList(i).point ,rePt ) == 0 )
return
}
iVrtxList.add(inpVertex);
}
}
So I want to avoid N X N looping . I thought of sorting the container and then check only the subsequent element for the distance . However I seem to miss some elements

Answer 1

I kind of achieved our objective to skip the duplicate vertices without using a N X N approach . I used a multimap to keep track of the vertices . The key was hashed with the x,y,z values which we adjusted to precision to make it work with the dataset . However the hash calculation is vulnerable as any mapping causing collision will defeat the purpose . Following are the definitions
class PointCoords
{
public:
PointCoords(double ix, double iy, double iz) : _x(ix), _y(iy), _z(iz) { };
double _x;
double _y;
double _z;
};
class PointCoords_hash
{
public:
size_t operator()(const PointCoords& v) const
{
auto f1 = std::hash<double>{}(round(v._x * 10) / 10);
auto f2 = std::hash<double>{}(round(v._y * 10) / 10);
auto f3 = std::hash<double>{}(round(v._z * 10) / 10);
size_t hCode = (f1 ^ f2 ^ f3) << 1;
return ((f1 ^ f2 ^ f3) << 1);
};
};
class PointCoords_equal
{
public:
bool operator()(const PointCoords& u, const PointCoords& v) const
{
return (equal(u._x, v._x, 1e-6) &&
equal(u._y, v._y, 1e-6) &&
equal(u._z, v._z, 1e-6));
};
};
bool :equal( double d1, double d2, double err)
{
return ( fabs( d1 -d2) <= err);
}