una - C++ elimina ciertos elementos del vector

insertar un elemento en un vector c++

Question

Soy nuevo en C ++ y quiero eliminar el elemento vectorial.

Mis vectores son como:

<vector<vector>> objPoints;
<vector<vector>> delPoints;
<vector<vector>> objPoints2;

cada objPoints tiene un tamaño de 1000x3 y tiene todos los puntos. Desde objPoints quiero eliminar delPoints, es decir, los valores (X, Y, Z) que residen en cada fila.

¿Puede alguien decirme la sintaxis?

Answer 1

Interpreto sus preguntas de la siguiente manera: Tiene dos vectores objPoints y delPoints que contienen 1000 puntos tridimensionales. Yo codificaría esto como

std::vector<std::array<int,3> > objPoints;

donde asumí que tiene un ráster tal que puede desribe sus puntos por valores int (de lo contrario, para entradas double , la comparación no es tan fácil).

Una de las ventajas de utilizar std::array<int,3> es que obtiene automáticamente un orden lexicográfico de los puntos (es decir, las especializaciones de std::less y std::equal_to que se pueden usar directamente sin necesidad de crear algunos).

Algoritmo:

Primero ordena tus matrices. Puede haber algoritmos donde esto no es realmente necesario (ver la otra respuesta por @AshwaniDausodia), pero lo siguiente lo asume. Además, en general, al usar vectores clasificados se puede obtener un mejor rendimiento (al menos en la gran O: para contenedores sin clasificar, es aproximadamente O(size1*size2) , mientras que es menor para el siguiente algoritmo). La clasificación primero requiere un esfuerzo de O(size1 log(size1)) + O(size2 log(size2))

A continuación, recorra ambas matrices al mismo tiempo y cada vez que encuentre un elemento común elimínelo de uno de los vectores. A medida que recorre las matrices ordenadas, donde siempre puede aumentar solo el iterador que apunta al elemento más pequeño, este paso toma O(size1+size2) .

Implementación:

// deletes the elements from container c1 which are also present in c2
// requires sorted containers c1 and c2
//
template< class ContainerType1, class ContainerType2 >
void delete_common_elements(ContainerType1& c1, ContainerType2 const& c2 )
{
for(auto it1=c1.begin(), it2=c2.begin()
; it1!=c1.end() && it2!=c2.end(); )
{
if(*it1==*it2) // eventually change here if your points are not int''s
// but are of floating-point type
{
it1 = c1.erase(it1); //it1 is increased here
}
else
{
*it1<*it2 ? ++it1 : ++it2;
}
}
} 

MANIFESTACIÓN

En conjunto, esto requiere un esfuerzo de O(c1.size()) + O(c1.size() * log(c1.size()) (asumiendo naturalmente c1.size()>=c2.size() ).

Uno puede extender esto fácilmente para tomar un operador de comparación arbitrario en lugar del operator== .

Answer 2

Puede considerar leer estas preguntas y respuestas en sobre cómo borrar elementos de contenedores STL .

El punto clave es usar la expresión borrar-borrar para borrar elementos del vector, y usar una lambda para expresar la condición de borrado:

objPoints.erase(
std::remove_if(
objPoints.begin(),
objPoints.end(),
[&delPoints](const Point3D& point)
{
// Erasing condition:
// Is ''point'' contained in the ''delPoints'' vector?
auto it = std::find(delPoints.begin(), delPoints.end(), point);
return (it != delPoints.end());
}),
objPoints.end());

Ejemplo completo de código compilable (en vivo aquí ):

#include <algorithm> // for std::find(), std::remove_if()
#include <array> // for std::array
#include <iostream> // for console output
#include <vector> // for std::vector
typedef std::array<int, 3> Point3D;
std::ostream& operator<<(std::ostream& os, const Point3D& point)
{
os << "{" << point[0] << ", "
<< point[1] << ", " << point[2] << "}";
return os;
}
std::ostream& operator<<(std::ostream& os, const std::vector<Point3D>& v)
{
if (v.empty())
{
os << "{ <empty> }" << std::endl;
return os;
}
os << "{/n";
for (const auto& point : v)
{
os << " " << point << ''/n'';
}
os << "}" << std::endl;
return os;
}
int main()
{
std::vector<Point3D> objPoints{{1, 2, 3},
{4, 5, 6},
{11, 22, 33},
{44, 55, 66},
{77, 88, 99}};
std::vector<Point3D> delPoints{{10, 10, 10},
{11, 22, 33},
{44, 55, 66}};
std::cout << "objPoints =/n" << objPoints << std::endl;
std::cout << "delPoints =/n" << delPoints << std::endl;
objPoints.erase(
std::remove_if(
objPoints.begin(),
objPoints.end(),
[&delPoints](const Point3D& point)
{
// Erasing condition:
// Is ''point'' contained in the ''delPoints'' vector?
auto it = std::find(delPoints.begin(), delPoints.end(), point);
return (it != delPoints.end());
}),
objPoints.end());
std::cout << "/nAfter erasing, objPoints =/n";
std::cout << objPoints << std::endl;
}

Salida:

objPoints =
{
{1, 2, 3}
{4, 5, 6}
{11, 22, 33}
{44, 55, 66}
{77, 88, 99}
}
delPoints =
{
{10, 10, 10}
{11, 22, 33}
{44, 55, 66}
}
After erasing, objPoints =
{
{1, 2, 3}
{4, 5, 6}
{77, 88, 99}
}

Answer 3

Si definitivamente tiene que usar vectores, una forma fácil (pero ineficaz) sería std::find el elemento en objPoints que desea eliminar y luego eliminarlo con std::vector::erase .

Answer 4

Un método obvio sería:

for each point in delPoints
if point exists in objPoints
delete point from objPoints.

Puedes hacerlo de manera mucho más eficiente si puedes ordenar los vectores. Le proporcionaré un método y un pseudo código, luego podrá implementarlo por su cuenta.

First sort objPoints and delpoints
i=0,j=0
while i < length(objPoints) and j < length(delPoints)
if objPoints[i] > delPoints[j] // Means delPoints[j] is not there in objPoints. If it would have, we would have found it.
j++
else if objPoints[i] < delPoints[j] // Means delPoints[j] is after objPoints[i] if it is there in objPoints
i++
else
erase objPoints[i] // Means we have found delPoints[j], so delete it.

Para comaprison, primero compare wrt x cordinate luego y y luego z . Para la clasificación, puede usar std::sort con la misma función de comparación descrita en la línea anterior. Para eliminar, puede usar std::vector::erase .
O puede implementar sus propias funciones.