Comprendere Unordered_Map::Find()
La funzione unordered_map::find() è progettata per individuare un elemento associato a una chiave specificata all'interno di una 'unordered_map'. La sua dichiarazione varia a seconda che l'oggetto sia qualificato come costante o meno, fornendo flessibilità nel suo utilizzo.
trova l'iteratore ( cost tipo_chiave & K ) ;Viene utilizzato quando 'unordered_map' non è qualificato come costante. Questo codice restituisce un iteratore che punta all'elemento trovato.
const_iterator trova ( cost tipo_chiave & K ) cost ;
Questa versione è applicabile quando 'unordered_map' è qualificato con costante. Restituisce un iteratore costante con un comportamento simile alla versione non costante.
parametri:
Richiede un singolo parametro, 'k', che è la chiave da cercare all'interno di 'unordered_map'.
Valore di ritorno:
Il valore restituito dipende dalla qualificazione dell'oggetto “unordered_map”.
Il metodo restituisce un iteratore non costante se l'oggetto non è costantemente qualificato.
Se l'oggetto è qualificato come costante, il metodo restituisce un iteratore costante.
Complessità temporale:
La complessità temporale di std::unordered_map::find() è cruciale per comprenderne l'efficienza:
Nel caso medio, la complessità temporale è costante (O(1)), rendendolo altamente efficiente per i casi d'uso tipici.
Nello scenario peggiore, la complessità temporale diventa lineare (O(n)). Tuttavia, questo scenario è raro nella pratica.
Esempio 1:
Esploriamo un esempio pratico per illustrare l'utilizzo e i vantaggi di unordered_map::find(). In questo esempio, viene creata una “unordered_map” con i caratteri come chiavi e i corrispondenti numeri interi come valori. La funzione find() individua l'elemento collegato alla chiave 'p'. L'iteratore “ittr” è collegato all'elemento trovato e i suoi dati vengono stampati sulla console. Vedere il seguente codice:
#include#include
utilizzando lo spazio dei nomi std ;
int principale ( vuoto ) {
mappa_non ordinata < car , int > nonmp = {
{ 'In' , 9 } ,
{ 'UN' , 6 } ,
{ 'P' , 8 } ,
{ 'M' , 3 } ,
{ 'S' , 4 } } ;
auto ittr = nonmp. Trovare ( 'P' ) ;
cout << 'Iteratore' ' << ittr->primo << ' ' punta a = ' << ittr -> secondo << fine ;
ritorno 0 ; }
Analizziamo il codice per averne una comprensione chiara e migliore:
#include#include
Sono inclusi i file di intestazione necessari:
Lo spazio dei nomi 'std' semplifica il codice. Ti consente di utilizzare gli elementi della libreria C++ standard senza prefissarli con 'std::'.
mappa_non ordinata < car , int > nonmp = { { 'In' , 9 } , { 'UN' , 6 } , { 'P' , 8 } , { 'M' , 3 } , { 'S' , 4 } } ;Viene creata una 'mappa_non ordinata' denominata 'um' con i caratteri ('w', 'a', 'p', 'm', 's') come chiavi e i corrispondenti numeri interi (9, 6, 8, 3, 4 ) come valori.
auto ittr = nonmp. Trovare ( 'P' ) ;La funzione find() viene utilizzata per cercare l'elemento con la chiave 'p' in 'unordered_map' che è 'unomp'. L'iteratore “ittr” punta all'elemento identificato.
cout << 'Iteratore' ' << ittr->primo << ' ' punta a = ' << ittr -> secondo << fine ;Il contenuto a cui punta l'iteratore viene stampato sulla console. In questo caso stampa la chiave (“p”) e il valore associato (8).
ritorno 0 ;Il programma termina, restituendo 0 per indicare un'esecuzione riuscita.
L'output del codice è riportato di seguito come riferimento:
Questo codice è un semplice esempio di utilizzo di unordered_map::find() per cercare e accedere in modo efficiente agli elementi all'interno di una 'unordered_map'. L'iteratore fornisce un modo conveniente per accedere sia alla chiave che al valore associato dell'elemento trovato.
Esempio 2:
Ecco un altro semplice esempio della funzione unordered_map::find(). Questo codice dimostra l'utilizzo di 'unordered_map' per memorizzare i valori booleani associati alle chiavi intere e quindi utilizza la funzione find() per verificare l'esistenza di chiavi specifiche. Vediamo il seguente codice e poi capiamo come funziona:
#includeutilizzando lo spazio dei nomi std ;
int principale ( ) {
mappa_non ordinata < int , bool > nonmp ;
nonmp [ 2 ] = VERO ;
nonmp [ 67 ] = falso ;
nonmp [ Quattro cinque ] = VERO ;
nonmp [ 98 ] = falso ;
Se ( nonmp. Trovare ( 67 ) == nonmp. FINE ( ) )
cout << 'Elemento non trovato' << fine ;
altro
cout << 'Elemento trovato' << fine ;
Se ( nonmp. Trovare ( 42 ) == nonmp. FINE ( ) )
cout << 'Elemento non trovato' << fine ;
altro
cout << 'Elemento trovato' << fine ;
ritorno 0 ;
}
Ecco una descrizione dettagliata del codice:
#includeQuesta riga include un file di intestazione che copre la maggior parte delle librerie C++ standard spesso utilizzate nella programmazione competitiva. Tuttavia, in un normale sviluppo C++, è consigliabile includere intestazioni specifiche.
mappa_non ordinata < int , bool > nonmp ;Viene creata una 'mappa_non ordinata' denominata 'unomp' con chiavi intere e valori booleani.
nonmp [ 2 ] = VERO ;nonmp [ 67 ] = falso ;
nonmp [ Quattro cinque ] = VERO ;
nonmp [ 98 ] = falso ;
Le coppie chiave-valore vengono inserite nella 'unordered_map'. Ad ogni chiave (intero) è associato un valore booleano.
Se ( nonmp. Trovare ( 67 ) == nonmp. FINE ( ) )cout << 'Elemento non trovato' << fine ;
altro
cout << 'Elemento trovato' << fine ;
La funzione find() viene utilizzata all'interno della condizione if-else per cercare chiavi specifiche (67 e 42) all'interno di 'unordered_map'. Se la chiave viene trovata, viene stampato 'Elemento trovato'. Altrimenti viene stampato “Elemento non trovato”. Vedere il seguente output:
Questo codice mostra l'utilizzo di base di 'unordered_map' e della funzione find() per determinare la presenza o l'assenza di chiavi specifiche nella mappa.
Esempio 3:
Esploriamo un altro esempio che dimostra il rilevamento di un valore fornendo un input in fase di esecuzione. Questo semplice programma utilizza una 'mappa_non ordinata' per memorizzare i nomi (come chiavi) e i valori numerici associati (in questo caso, che rappresentano alcuni attributi). Quindi richiede all'utente di inserire un nome, cercare quel nome nella mappa utilizzando la funzione find() e stampare il valore associato se il nome viene trovato. Il codice è riportato di seguito come riferimento:
#include#include
#include
utilizzando lo spazio dei nomi std ;
int principale ( ) {
standard :: mappa_non ordinata < standard :: corda , Doppio > nonmp = {
{ 'Herry' , 23 } ,
{ 'Altri' , 7.4 } ,
{ 'Kalsom' , 1.2 } } ;
stringa chi ;
cout << 'Chi stai cercando? ' ;
getline ( mangiare , Chi ) ;
mappa_non ordinata < corda , Doppio >:: const_iterator trova = nonmp. Trovare ( Chi ) ;
Se ( trova == nonmp. FINE ( ) )
cout << 'non trovato' ;
altro
cout << fine << trova -> Primo << ' È ' << trova -> secondo << fine ;
ritorno 0 ;
}
Di seguito è riportata la suddivisione del codice per la tua comprensione:
mappa_non ordinata < corda , Doppio > nonmp = { } ;Viene creata una 'mappa_non ordinata' denominata 'unomp' con chiavi stringa (nomi) e valori doppi.
stringa chi ;All'utente viene richiesto di inserire un nome sullo schermo e l'input viene memorizzato nella variabile stringa 'chi'.
mappa_non ordinata < corda , Doppio >:: const_iterator trova = nonmp. Trovare ( Chi ) ;La funzione find() viene utilizzata per cercare il nome inserito in “unordered_map”. Il risultato viene memorizzato nell'iteratore 'fnd'.
Se ( trova == nonmp. FINE ( ) )cout << 'non trovato' ;
altro
cout << fine << trova -> Primo << ' È ' << trova -> secondo << fine ;
Se l'iteratore “fnd” raggiunge la fine di “unordered_map” (end()), significa che il nome non è stato trovato e viene stampato “non trovato”. Altrimenti vengono stampati il nome ed il valore associato. Ecco l'output del codice:
Questo codice agisce essenzialmente come un semplice strumento di ricerca del nome utilizzando una 'unordered_map'. Richiede l'input dell'utente, cerca il nome nella mappa e fornisce il valore associato se il nome viene trovato.
Conclusione
La funzione unordered_map::find() in C++ fornisce un potente meccanismo per individuare in modo efficiente gli elementi all'interno dei contenitori 'unordered_map'. La sua complessità temporale media costante lo rende la scelta preferita per le operazioni di ricerca in scenari in cui è necessario accedere rapidamente alle coppie chiave-valore. Gli esempi forniti ne mostrano l'utilizzo pratico, sottolineandone la semplicità e l'efficacia. In conclusione, padroneggiare la funzione unordered_map::find() migliora la capacità di un programmatore C++ di sfruttare tutto il potenziale dei contenitori “unordered_map”, contribuendo alla creazione di applicazioni ottimizzate e ad alte prestazioni.