Perché qualcuno dovrebbe usare set invece di unordered_set?

C ++ 0x sta introducendo unordered_setche è disponibile in booste in molti altri luoghi. Quello che capisco è che unordered_setè una tabella hash con O(1)complessità di ricerca. D'altra parte, setnon è altro che un albero con log(n)complessità di ricerca. Perché mai qualcuno dovrebbe usare setinvece di unordered_set? cioè c'è bisogno di setpiù?

Quando, per qualcuno che desidera scorrere gli articoli dell'insieme, l'ordine conta.

I set non ordinati devono pagare il loro tempo di accesso medio O (1) in alcuni modi:

• setutilizza meno memoria rispetto unordered_seta memorizzare lo stesso numero di elementi.
• Per un numero limitato di elementi , le ricerche in a setpotrebbero essere più veloci delle ricerche in a unordered_set.
• Anche se molte operazioni sono più veloci nel caso medio per unordered_set, sono spesso garantiti per avere una migliore peggiori complessità caso per set(ad esempio insert).
• Questo set ordinamento degli elementi è utile se si desidera accedervi in ​​ordine.
• È possibile confrontare lessicografico diversi sets con <, <=, >e >=. unordered_setnon sono richiesti per supportare queste operazioni.

Ogni volta che preferisci un albero a una tabella di hash.

Ad esempio, le tabelle hash sono "O (n)" nel caso peggiore. O (1) è il caso medio. Gli alberi sono "O ( log n)" nel peggiore dei casi.

Usa set quando:

1. Abbiamo bisogno di dati ordinati (elementi distinti).
2. Dovremmo stampare / accedere ai dati (in ordine ordinato).
3. Abbiamo bisogno del predecessore / successore degli elementi.

Usa unordered_set quando:

1. Dobbiamo mantenere un insieme di elementi distinti e non è richiesto alcun ordine.
2. Abbiamo bisogno dell'accesso a singolo elemento, cioè senza attraversamento.

Esempi:

impostato:

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

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

Unordered_set:

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

Uscita: 9 3 1 8 2 5 (forse questo ordine, influenzato dalla funzione hash)

Principalmente differenza:

Nota: (in alcuni casi setè più conveniente) ad esempio usando vectorcome chiave

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 

Il motivo per cui vector<int>può essere la chiave setperché vectoroverride operator<.

Ma se usi unordered_set<vector<int>>devi creare una funzione hash per vector<int>, perché vector non ha una funzione hash, quindi devi definirne una come:

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
}

puoi vedere che in alcuni casi unordered_setè più complicato.

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

Perché std :: set fa parte di Standard C ++ e unordered_set no. C ++ 0x NON è uno standard e nemmeno Boost. Per molti di noi, la portabilità è essenziale e ciò significa attenersi allo standard.

Prendi in considerazione gli algoritmi sweepline. Questi algoritmi fallirebbero completamente con le tabelle hash, ma funzionerebbero magnificamente con alberi bilanciati. Per darti un esempio concreto di un algoritmo sweepline, considera l'algoritmo di fortuna. http://en.wikipedia.org/wiki/Fortune%27s_algorithm

Un'altra cosa, oltre a ciò che altre persone hanno già menzionato. Mentre la complessità ammortizzata prevista per l'inserimento di un elemento in unorder_set è O (1), ogni tanto ci vorrà O (n) perché la tabella hash deve essere ristrutturata (il numero di bucket deve cambiare) - anche con una funzione hash "buona". Proprio come l'inserimento di un elemento in un vettore richiede O (n) di tanto in tanto perché l'array sottostante deve essere riallocato.

L'inserimento in un set richiede sempre al massimo O (log n). Questo potrebbe essere preferibile in alcune applicazioni.

Scusatemi, un'altra cosa degna di nota sulla proprietà ordinata:

Se si desidera un intervallo di dati nel contenitore, ad esempio: è stato memorizzato il tempo nel set e si desidera tempo dal 2013-01-01 al 2014-01-01.

Per unordered_set è impossibile.

Naturalmente, questo esempio sarebbe più convincente per i casi d'uso tra map e unordered_map .

g++ 6.4 benchmark stdlibc ++ ordinato vs non ordinato

Ho confrontato questa implementazione dominante di Linux C ++ per vedere la differenza:

I dettagli e l'analisi di riferimento completi sono stati forniti su: Qual è la struttura di dati sottostante di un set STL in C ++? e non li ripeterò qui.

"BST" significa "testato con std::sete" hash map "significa" testato con std::unordered_set. "Heap" è per il std::priority_queuequale ho analizzato su: Heap vs Binary Search Tree (BST)

Come breve riepilogo:

• il grafico mostra chiaramente che in queste condizioni, l'inserimento di hashmap è sempre stato molto più veloce quando ci sono più di 100k articoli e la differenza aumenta all'aumentare del numero di elementi

  Il costo di questo aumento di velocità è che non sei in grado di attraversare in modo efficiente in ordine.

• le curve suggeriscono chiaramente che ordinato std::setè basato su BST e basato su std::unordered_sethashmap. Nella risposta di riferimento, ho ulteriormente confermato che tramite il passaggio GDB il debug del codice.

Domanda simile per mapvs unordered_map: c'è qualche vantaggio nell'usare map over unordered_map in caso di chiavi banali?

Fuori mano, direi che è conveniente avere delle cose in una relazione se stai cercando di convertirla in un formato diverso.

È anche possibile che mentre si accede più velocemente, il tempo per creare l'indice o la memoria utilizzata durante la creazione e / o l'accesso ad esso sia maggiore.

Se vuoi che le cose vengano ordinate, allora useresti set invece di unordered_set. unordered_set viene utilizzato su set quando l'ordinamento memorizzato non ha importanza.

Mentre questa risposta potrebbe essere in ritardo di 10 anni, vale la pena sottolineare che std::unordered_setha anche degli svantaggi di sicurezza.

Se la funzione hash è prevedibile (questo è in genere il caso a meno che non applichi contromisure come un salt randomizzato), gli aggressori possono creare manualmente dati che producono collisioni di hash e fanno in modo che tutti gli inserimenti e le ricerche impieghino il tempo O (n) .

Questo può essere usato per attacchi denial-of-service molto efficienti ed eleganti.

Molte (la maggior parte?) Implementazioni di lingue che impiegano internamente mappe hash si sono imbattute in questo:

• Javascript
• PHP
• Giava