¿Por qué alguien usaría set en lugar de unordered_set?

Se presenta C ++ 0x, unordered_setque está disponible en boostmuchos otros lugares. Lo que entiendo es que unordered_setes una tabla hash con O(1)complejidad de búsqueda. Por otro lado, setno es más que un árbol con log(n)complejidad de búsqueda. ¿Por qué demonios usaría alguien en setlugar de unordered_set? es decir, ¿hay una necesidad de setmás?

Cuando, para alguien que quiere iterar sobre los elementos del conjunto, el orden es importante.

Los conjuntos desordenados tienen que pagar por su tiempo de acceso promedio O (1) de varias maneras:

• setusa menos memoria que unordered_setpara almacenar la misma cantidad de elementos.
• Para una pequeña cantidad de elementos , las búsquedas en un setpueden ser más rápidas que las búsquedas en un unordered_set.
• A pesar de que muchas operaciones son más rápidas en el caso promedio para unordered_set, a menudo son la garantía de tener mejores peores complejidades de casos de set(por ejemplo insert).
• Eso set ordena los elementos es útil si desea acceder a ellos en orden.
• Puede comparar lexicográfico diferentes sets con <, <=, >y >=. unordered_setNo es necesario que respalden estas operaciones.

Siempre que prefiera un árbol a una tabla hash.

Por ejemplo, las tablas hash son "O (n)" en el peor de los casos. O (1) es el caso promedio. Los árboles son "O ( log n)" en el peor de los casos.

Use set cuando:

1. Necesitamos datos ordenados (elementos distintos).
2. Tendríamos que imprimir / acceder a los datos (en orden ordenado).
3. Necesitamos predecesor / sucesor de elementos.

Use unordered_set cuando:

1. Necesitamos mantener un conjunto de elementos distintos y no se requiere ordenar.
2. Necesitamos acceso a un solo elemento, es decir, no transversal.

Ejemplos:

conjunto:

Entrada: 1, 8, 2, 5, 3, 9

Salida: 1, 2, 3, 5, 8, 9

Conjunto_desordenado:

Entrada: 1, 8, 2, 5, 3, 9

Salida: 9 3 1 8 2 5 (tal vez este orden, influenciado por la función hash)

Principalmente diferencia:

Nota: (en algunos casos setes más conveniente), por ejemplo, usar vectorcomo clave

set<vector<int>> s;
s.insert({1, 2});
s.insert({1, 3});
s.insert({1, 2});

for(const auto& vec:s)
    cout<<vec<<endl;   // I have override << for vector
// 1 2
// 1 3 

La razón por la que vector<int>puede ser clave es setporque se vectoranula operator<.

Pero si lo usa unordered_set<vector<int>>, debe crear una función hash vector<int>, porque el vector no tiene una función hash, por lo que debe definir una como:

struct VectorHash {
    size_t operator()(const std::vector<int>& v) const {
        std::hash<int> hasher;
        size_t seed = 0;
        for (int i : v) {
            seed ^= hasher(i) + 0x9e3779b9 + (seed<<6) + (seed>>2);
        }
        return seed;
    }
};

vector<vector<int>> two(){
    //unordered_set<vector<int>> s; // error vector<int> doesn't  have hash function
    unordered_set<vector<int>, VectorHash> s;
    s.insert({1, 2});
    s.insert({1, 3});
    s.insert({1, 2});

    for(const auto& vec:s)
        cout<<vec<<endl;
    // 1 2
    // 1 3
}

Puedes ver que en algunos casos unordered_setes más complicado.

Principalmente citado de: https://www.geeksforgeeks.org/set-vs-unordered_set-c-stl/ https://stackoverflow.com/a/29855973/6329006

Porque std :: set es parte de Standard C ++ y unordered_set no lo es. C ++ 0x NO es un estándar, y tampoco lo es Boost. Para muchos de nosotros, la portabilidad es esencial, y eso significa apegarse al estándar.

Considere algoritmos de línea de barrido. Estos algoritmos fallarían por completo con las tablas hash, pero funcionan maravillosamente con árboles equilibrados. Para darle un ejemplo concreto de un algoritmo de línea de barrido, considere el algoritmo de la fortuna. http://en.wikipedia.org/wiki/Fortune%27s_algorithm

Una cosa más, además de lo que otras personas ya mencionaron. Aunque la complejidad amortizado espera para la inserción de un elemento a un unordered_set es O (1), de vez en cuando se va a tomar O (n), ya que las necesidades tabla hash a reestructurarse (el número de necesidades cubos para el cambio) - incluso con una función hash 'buena'. Al igual que insertar un elemento en un vector toma O (n) de vez en cuando porque la matriz subyacente necesita ser reasignada.

Insertar en un conjunto siempre toma como máximo O (log n). Esto podría ser preferible en algunas aplicaciones.

Disculpe, una cosa más que vale la pena notar sobre la propiedad ordenada:

Si desea un rango de datos en el contenedor, por ejemplo: almacenó el tiempo en el conjunto y desea tiempo del 2013-01-01 al 2014-01-01.

Para un_order_set es imposible.

Por supuesto, este ejemplo sería más convincente para casos de uso entre map y unordered_map .

g++ 6.4 stdlibc ++ comparado con el conjunto de referencia desordenado

Comparé esta implementación dominante de Linux C ++ para ver la diferencia:

Los detalles y análisis completos de referencia se han proporcionado en: ¿Cuál es la estructura de datos subyacente de un conjunto STL en C ++? y no los repetiré aquí.

"BST" significa "probado con std::sety" hash map "significa" probado con std::unordered_set. "Heap" es para std::priority_queuelo que analicé en: Heap vs Binary Search Tree (BST)

Como resumen rápido:

• el gráfico muestra claramente que, en estas condiciones, la inserción de hashmap siempre fue mucho más rápida cuando hay más de 100 000 elementos, y la diferencia aumenta a medida que aumenta el número de elementos

  El costo de este aumento de velocidad es que no puede atravesar eficientemente en orden.

• las curvas sugieren claramente que ordenado std::setestá basado en BST y std::unordered_setestá basado en hashmap. En la respuesta de referencia, confirmé que mediante el paso GDB depurando el código.

Pregunta similar para mapvs unordered_map: ¿Hay alguna ventaja de usar map sobre unordered_map en caso de claves triviales?

Por supuesto, diría que es conveniente tener cosas en una relación si está buscando convertirlo a un formato diferente.

También es posible que aunque uno sea más rápido para acceder, el tiempo para construir el índice o la memoria utilizada al crearlo y / o acceder a él es mayor.

Si desea ordenar las cosas, entonces usaría set en lugar de unordered_set. unordered_set se usa sobre el conjunto cuando el pedido almacenado no importa.

Si bien esta respuesta puede demorar 10 años, vale la pena señalar que std::unordered_settambién tiene desventajas de seguridad.

Si la función hash es predecible (este suele ser el caso a menos que aplique contramedidas como una sal aleatoria), los atacantes pueden crear datos a mano que produzcan colisiones hash y provoquen que todas las inserciones y búsquedas tomen tiempo O (n) .

Esto se puede usar para ataques de denegación de servicio muy eficientes y elegantes.

Muchas (¿la mayoría?) Implementaciones de lenguajes que emplean internamente mapas hash se han encontrado con esto:

• Javascript
• PHP
• Java