Com sabem que HashSet és una classe famosa a Java. HashSet s'utilitza per emmagatzemar els valors mitjançant una taula hash. En aquest tutorial, tractarem HashSet a Python. També aprendrem sobre com podem dissenyar HashSet a Python.
Un HashSet és una estructura de dades fonamental en programació, que es troba habitualment en llenguatges com Java. Pertany al Java Collections Framework i serveix com a implementació de la interfície conjunta. La característica distintiva d'un HashSet és la seva capacitat per emmagatzemar elements d'una manera que facilita la comprovació eficient de l'existència d'elements específics i garanteix la singularitat dins del conjunt. A diferència d'estructures com ara llistes, un HashSet no manté cap ordre específic entre els seus elements.
Una característica clau d'un HashSet és la seva garantia d'unicitat; no permet elements duplicats. Operacions com afegir, eliminar i comprovar la presència d'elements solen tenir un rendiment mitjà en temps constant, cosa que la converteix en una opció eficient per a aquestes tasques. Tanmateix, és essencial tenir en compte que l'ordre dels elements en un HashSet no està garantit.
Característiques clau:
Singularitat: Un HashSet no permet elements duplicats. Utilitza el mètode equals() per comprovar si hi ha duplicats, assegurant-se que cada element del conjunt és únic.
No Order: Els elements d'un HashSet no s'emmagatzemen en cap ordre concret. Si necessiteu mantenir l'ordre dels elements, podeu considerar utilitzar un LinkedHashSet, que manté l'ordre d'inserció.
Estructura de dades subjacent: Internament, un HashSet utilitza una taula hash per emmagatzemar elements. Això permet una complexitat mitjana en temps constant per a operacions bàsiques com afegir, eliminar i contenir.
Elements nuls: Un HashSet permet un element nul. Si intenteu afegir un element nul duplicat, substituirà l'existent.
Introducció
Podem dissenyar HashSet sense utilitzar cap biblioteca de taules hash. A continuació es mostren les múltiples funcions diferents:
afegir (x) - El mètode add(x) s'utilitza principalment per inserir un valor x al HashSet.
conté (x) - El mètode contains(x) s'utilitza principalment per comprovar si un valor x està present al HashSet o no.
eliminar (x) - El mètode remove(x) s'utilitza principalment per eliminar x del HashSet. Si el HashSet no té cap valor, no farà res.
Entendrem aquests mètodes amb l'exemple següent.
Primer, inicialitzeu el HashSet i truqueu a la funció add(1). Afegirà 1 al conjunt hash. Truqueu a add(3), que afegirà 3, després crida a conté (1). Comprovarà si 1 està present o no al conjunt hash. Ara anomenem conté (2), afegir (2), conté (2), eliminar (2), conté (2).
La sortida es retornarà com a vertader per a 1, fals per a 2 no present, vertader per a 2, fals per a 2 no present, respectivament.
Operacions bàsiques de HashSet a Python
Podem realitzar algunes operacions bàsiques a HashSet utilitzant els mètodes següents. Entenem aquests mètodes.
Afegint nous valors a HashSet
A l'exemple següent, afegirem el valor al conjunt hash mitjançant la funció add(). La funció add() afegeix el valor d'un en un. Vegem el següent codi.
Exemple -
from hs import HashSet obj = HashSet() obj.add(2) obj.add(7) obj.add(6)
Sortida:
Adding value: 2 Adding value: 7 Adding value: 6
Eliminació de valors a HashSet
Podem eliminar el valor existent mitjançant la funció remove(). Entenem el codi següent.
Exemple -
from hs import HashSet obj = HashSet() obj.add(2) obj.add(7) obj.add(6) obj.remove(7) obj.remove(6)
Sortida:
Adding value: 2 Adding value: 7 Adding value: 6 Removed value: 7 Removed value: 6
Comprovant si existeixen valors a HashSet
En aquest exemple, demostrarem com podem comprovar si un valor determinat existeix o no fa servir el conté () funció. Entenem el codi següent.
Exemple -
from hs import HashSet obj = HashSet() obj.add(2) obj.add(7) obj.add(6) obj.contains(2)
Sortida:
Adding value: 2 Adding value: 7 Adding value: 6 It contains: 2
Algorisme per al HashSet en Python
En el primer pas, definim una estructura de dades anomenada HashList. A continuació, inicialitzem una llista buida com a una nova_llista . Aleshores, definim una funció update() en la qual find emmagatzemarà un valor booleà False. Ara, fem servir el bucle for per a cada índex I i K. si la clau és la mateixa que 'k', aleshores nova_llista[i]=k i el valor trobat establert en True. El valor s'inserirà a l'últim de la llista si no es troba cap valor.
El següent pas és definir la funció get(), que utilitzarem per al bucle, i si el valor de k és el mateix que la clau, la sortida serà True; en cas contrari, fals. Si la clau és la mateixa que 'k', suprimiu el valor de la llista nova_llista. El mateix procés s'aplicarà a la funció remove().
Ara, crearem el HashSet de classe principal. Aquesta classe declararà la funció d'inicialització on el valor key_space = 2096. La hash_table tindrà una llista d'objectes de tipus new_list de mida espai_clau . Aleshores, crearem la funció add(), en la qual hash_key = clau%key_space i actualitzeu la clau de hash_table[hash_key]. Després d'això, trucarem al eliminar la funció , en què hash_key = clau % key_space, i suprimiu la clau de hash_table[hash_key]. Després d'això, trucarem al conté la funció , en quin
hash_key = clau % key_space, i obteniu la clau de hash_table[hash_key].
Vegem l'algoritme d'implementació pas a pas.
algorisme -
- Creeu una estructura de dades anomenada HashSet, inicialitzeu-la com a continuació
- nova_lista = []
- Definiu una actualització de funció(). Això prendrà clau
- trobat:= Fals
- per a cada índex i i clau k de new_list, feu
- si la clau és la mateixa que k, aleshores
- nova_lista[i]:= clau
- trobat:= Veritable
- sortir del bucle
- si es troba fals, aleshores
- inseriu la clau al final de new_list
- Definiu una funció get() . Això prendrà clau
- per a cada k de new_list, do
- si k és el mateix que clau, aleshores
- torna Veritat
- retornar Fals
- Definiu una funció remove(). Això prendrà clau
- per a cada índex i i clau k de new_list, feu
- si la clau és la mateixa que k, aleshores
- suprimir new_list[i]
- Ara creeu un hashSet personalitzat. Hi haurà pocs mètodes de la següent manera
- Inicialitzar-ho de la següent manera:
- espai_clau := 2096
- hash_table:= una llista d'objectes tipus cub de mida key_space
- Definiu una funció add(). Això prendrà clau
- hash_key:= clau mod key_space
- truca a l'actualització (clau) de hash_table[hash_key]
- Definiu una funció remove(). Això prendrà clau
- hash_key:= keymodkey_space
- suprimir la clau de hash_table[hash_key]
- Definiu una funció conté(). Això prendrà clau
- hash_key:= keymodkey_space
- retorna get(clau) de hash_table[hash_key]
Implementació de HashSet a Python
Aquí implementarem l'algorisme anterior i crearem el programa Python. Definirem les dues classes: HashSet i CreateHashset. Vegem el codi següent.
Codi -
# Here, we are Designing the HashSet in python # Here, we are checking the values and will return the output class class verifyvalues: # Here, we are initialization function which has list new_list def __init__(self): self.new_list=[] # Here, we have the function to update values def update(self, key): found=False for i,k in enumerate(self.new_list): if key==k: self.new_list[i]=key found=True break if not found: self.new_list.append(key) # Here, we have function to get values def get(self, key): for k in self.new_list: if k==key: return True return False # Here, we have function to remove values def remove(self, key): for i,k in enumerate(self.new_list): if key==k: del self.new_list[i] # Here, we have defined a class as HashSet class HashSet: # Here, we have defined an Initialization function def __init__(self): self.key_space = 2096 self.hash_table=[verifyvalues() for i in range(self.key_space)] def hash_values(self, key): hash_key=key%self.key_space return hash_key # Here, we have also defined an add function def add(self, key): self.hash_table[self.hash_values(key)].update(key) # Here, we have also defined a remove function def remove(self, key): self.hash_table[self.hash_values(key)].remove(key) # Here, we have defined the contains function def contains(self, key): return self.hash_table[self.hash_values(key)].get(key) def display(self): ls=[] for i in self.hash_table: if len(i.new_list)!=0:ls.append(i.new_list[0]) print(ls) ob = HashSet() print(ob.hash_values(10)) print('Add 10') ob.add(10) print(ob.hash_values(6)) print('Add 6 ') ob.add(6) print(ob.hash_values(5)) print('Add 5 ') ob.add(5) print('Contains 10 : ',ob.contains(10)) print('Contains 3: ',ob.contains(3)) print('Contains 8 : ',ob.contains(9))
Sortida:
10 Add 10 6 Add 6 5 Add 5 Contains 10 : True Contains 3: False Contains 8 : False 2 Add 2 3 Add 3 Contains 2 : True Remove 2 Contains 2 : False Contains 3 : True [3, 5, 6, 10]
Explicació:
fer mentre java