Hoe een gekoppelde lijst in Python te implementeren?

Python-programmeertaal is een open-source taal met verschillende out-of-the-box implementaties die het uniek en gemakkelijker te leren maken. Hoewel ondersteunt het concept van een gelinkte lijst niet, er is een manier omheen via een andere implementatie om een ​​gelinkte lijst te krijgen. In dit artikel zullen we leren hoe we een gelinkte lijst kunnen maken in Python. Hieronder volgen de onderwerpen die in deze blog worden behandeld:

• Wat is een gekoppelde lijst?
• Een gekoppelde lijst implementeren
• Methoden van gekoppelde lijst

Laten we beginnen!!

Wat is een gekoppelde lijst?

De koppelingslijst is een reeks knooppunten met een soortgelijk gegevenstype, elk knooppunt bevat een gegevensobject en een aanwijzer naar het volgende knooppunt.

Een gekoppelde lijst is een lineaire datastructuur met de verzameling van meerdere knooppunten. Waar each element slaat zijn eigen data op en een pointer naar de locatie van het volgende element. De laatste schakel in een gekoppelde lijst verwijst naar null, wat het einde van de ketting aangeeft. Een element in een gekoppelde lijst wordt een genoemd knooppunt . Het eerste knooppunt heet de hoofd .Het laatste knooppunt wordt genoemdde staart .
Standaard python-bibliotheek heeft geen gekoppelde lijst. We kunnen het concept van de datastructuur van een linklijst implementeren door het concept van knooppunten te gebruiken.

Nu we hebben geleerd wat is gekoppeld. Laten we dus verder gaan met het implementeren van een gekoppelde lijst.

Een gekoppelde lijst implementeren

Voor het maken van een gekoppelde lijst maken we een knooppuntobject en maken we een andere klasse om dit knooppuntobject te gebruiken.
Code voor het maken van een knooppuntklasse.
Het bovenstaande programma maakt een gekoppelde lijst met drie gegevenselementen.

class Node (object): # Constructor om klassevariabelen te initialiseren def __init __ (self, data = None, next_node = None): self.data = data self.next_node = next_node #get data def get_data (self): return self.data # haal volgende waarde def get_next (self): retourneer self.next_node # set next data def set_next (self, new_next): self.next_node = new_next

Implementatie van linklijst bestaat uit de volgende functionaliteit in een gelinkte lijst
een. Invoegen : Deze methode voegt een nieuw knooppunt in een gekoppelde lijst in.
2. Grootte : Deze methode retourneert de grootte van de gekoppelde lijst.
3. Zoeken : Deze methode retourneert een knooppunt met de gegevens, anders zal er een fout optreden
Vier. Verwijderen : Deze methode verwijdert een knooppunt met de gegevens, anders zal er een fout optreden

Laten we eens kijken naar de methoden van gekoppelde lijst

hoe typecast in java

Init-methode in een gekoppelde lijst

class LinkedList (object): def __init __ (self, head = None): self.head = head

Init-methode wordt gebruikt voor de initialisatie van een klasse variabele als de lijst geen knooppunten heeft, wordt deze op geen gezet.

Invoegen:

def insert (self, data): new_node = Node (data) new_node.set_next (self.head) self.head = new_node

Deze invoegmethode neemt gegevens, initialiseert een nieuw knooppunt met de gegeven gegevens en voegt deze toe aan de lijst. Technisch gezien kun je overal in de lijst een knooppunt invoegen, maar de eenvoudigste manier om dit te doen is door het bovenaan de lijst te plaatsen en het nieuwe knooppunt naar de oude kop te wijzen (een soort van duwen van de andere knooppunten langs de lijn).

Grootte

# Geeft het totale aantal knooppunten terug in lijst def size (self): current = self. Head count = 0 while current: count + = 1 current = current.get_next () retourneert telling

De groottemethode is heel eenvoudig, het telt in feite knooppunten totdat het niet meer kan vinden, en geeft het aantal gevonden knooppunten terug. De methode begint bij het hoofdknooppunt, loopt langs de rij knooppunten tot het einde (de stroom zal Geen zijn wanneer het einde bereikt), terwijl het bijhoudt hoeveel knooppunten het heeft gezien.

Zoeken

binair naar decimaal in java

# Retourneert het knooppunt in de lijst met nodeData, er is een fout opgetreden als het knooppunt niet aanwezig is def zoeken (self, nodeData): current = self.head isPresent = False terwijl current en isPresent is False: if current.get_data () == nodeData: isPresent = Waar anders: current = current.get_next () if current is None: raise ValueError ('Data niet aanwezig in lijst') retourneer current

Zoeken lijkt eigenlijk erg op de grootte, maar in plaats van de hele lijst met knooppunten te doorlopen, controleert het bij elke stop of het huidige knooppunt de gevraagde gegevens heeft. Als dit het geval is, retourneert het het knooppunt met die gegevens. Als de methode de volledige lijst doorloopt maar de gegevens nog steeds niet heeft gevonden, wordt er een waardefout gegenereerd en wordt de gebruiker geïnformeerd dat de gegevens niet in de lijst staan.

Verwijderen

# Remove the node from linked list retourneert een fout als node niet aanwezig is def delete (self, nodeData): current = self.head previous = None isPresent = False terwijl current en isPresent is False: if current.get_data () == nodeData: isPresent = Waar anders: vorige = huidige huidige = huidige.get_next () als huidige Geen is: verhoog ValueError ('Gegevens niet aanwezig in lijst') als vorige Geen is: self.head = huidige.get_next () anders: vorige.set_next ( current.get_next ())

De verwijdermethode doorloopt de lijst op dezelfde manier als de zoekactie, maar naast het bijhouden van het huidige knooppunt onthoudt de verwijdermethode ook het laatste bezochte knooppunt. Wanneer delete eindelijk arriveert bij het knooppunt dat het wil verwijderen. Het verwijdert simpelweg dat knooppunt uit de keten door er een sprong over te maken.

Hiermee bedoel ik dat wanneer de verwijdermethode het knooppunt bereikt dat het wil verwijderen, het naar het laatste knooppunt dat het heeft bezocht (het 'vorige' knooppunt) kijkt en de aanwijzer van dat vorige knooppunt opnieuw instelt. In plaats van te verwijzen naar het knooppunt dat binnenkort wordt verwijderd.

Het wijst naar het volgende knooppunt in de rij. Aangezien er geen knooppunten zijn die verwijzen naar het slechte knooppunt dat wordt verwijderd, wordt het effectief uit de lijst verwijderd!

Dit brengt ons bij het einde van dit artikel waar we hebben geleerd hoe we een gelinkte lijst in python kunnen maken met een vergelijkbare implementatie, ook al ondersteunt Python het concept van een gelinkte lijst niet echt. Ik hoop dat je duidelijk bent met alles wat in deze tutorial met je is gedeeld.

Als je dit artikel over 'Linked List In Python' relevant vond, bekijk dan het Een vertrouwd online leerbedrijf met een netwerk van meer dan 250.000 tevreden leerlingen verspreid over de hele wereld.

We zijn hier om je te helpen bij elke stap op je reis en om een ​​curriculum te bedenken dat is ontworpen voor studenten en professionals die een . De cursus is ontworpen om u een voorsprong te geven in het programmeren van Python en u te trainen in zowel kern- als geavanceerde Python-concepten, samen met verschillende Leuk vinden

Mocht je vragen tegenkomen, stel dan gerust al je vragen in het commentaargedeelte van 'Linked List In Python' en ons team zal je graag beantwoorden.