Länkade listor i Python: handledning med exempel

En länkad lista är en datastruktur som spelar en avgörande roll för organisering och hantering av data. Den innehåller en serie noder som lagras på slumpmässiga platser i minnet, vilket möjliggör effektiv minneshantering. Varje nod i en länkad lista innehåller två huvudkomponenter: dataparten och en referens till nästa nod i sekvensen.

Om det här konceptet känns komplext vid första anblick, oroa dig inte!

Vi bryter ner det till grunderna för att förklara vad länkade listor är, varför vi använder dem och vilka unika fördelar de erbjuder.

Varför länkade listor?

Länkade listor skapades för att övervinna olika nackdelar som är förknippade med att lagra data i vanliga listor och arrayer, enligt nedan:

Enkelt att infoga och ta bort

I listor kräver infogning eller borttagning av ett element på någon annan position än slutet att alla efterföljande element flyttas till en ny position. Denna process har en tidskomplexitet på O(n) och kan försämra prestandan avsevärt, särskilt när listan blir större. Om du inte redan är bekant med hur listor fungerar eller hur de implementeras, kan du läsa vår handledning om Python-listor.

Länkade listor fungerar däremot annorlunda. De lagrar element på olika, icke-sammanhängande minnesplatser och kopplar ihop dem via pekare till efterföljande noder. Denna struktur gör det möjligt för länkade listor att lägga till eller ta bort element på valfri position genom att helt enkelt ändra länkarna för att inkludera ett nytt element eller hoppa över det borttagna.

När du väl har en direkt referens till noden vid infognings- eller borttagningspunkten är själva operationen O(1). Att hitta den positionen kräver dock fortfarande O(n) genomgång, så O(1)-fördelen gäller bara när du redan har en pekare till den relevanta noden (till exempel när du arbetar vid listans huvud).

Dynamisk storlek

Python-listor är dynamiska arrayer, vilket innebär att de ger flexibilitet att ändra storlek.

Denna process involverar dock en serie komplexa operationer, inklusive att allokera om arrayen till ett nytt, större minnesblock. En sådan omallokering är ineffektiv eftersom elementen kopieras till ett nytt block, vilket potentiellt allokerar mer utrymme än vad som omedelbart behövs.

Länkade listor kan däremot växa och krympa dynamiskt utan behov av omallokering eller storleksändring. Detta gör dem till ett föredraget alternativ för uppgifter som kräver hög flexibilitet.

Minneseffektivitet

Listor allokerar minne för alla sina element i ett sammanhängande block. Om en lista behöver växa bortom sin initiala storlek måste den allokera ett nytt, större block av sammanhängande minne och sedan kopiera alla befintliga element till detta nya block. Denna process är tidskrävande och ineffektiv, särskilt för stora listor. Å andra sidan, om den initiala storleken på listan överskattas, slösas det oanvända minnet bort.

Länkade listor allokerar däremot minne för varje element separat. Denna struktur leder till bättre minnesutnyttjande eftersom minne för nya element kan allokeras i takt med att de läggs till.

När ska du använda länkade listor?

Även om länkade listor ger vissa fördelar jämfört med vanliga listor och arrayer, såsom dynamisk storlek och minnes­effektivitet, har de också sina begränsningar. Eftersom pekare för varje element måste lagras för att referera till nästa nod, är minnesanvändningen per element högre när man använder länkade listor. Dessutom tillåter denna datastruktur inte direkt åtkomst till data. Åtkomst till ett element kräver sekventiell genomgång från början av listan, vilket ger en söktidskomplexitet på O(n).

Valet mellan att använda en länkad lista eller en array beror på applikationens specifika behov. Länkade listor är mest användbara när:

• Du ofta behöver infoga och ta bort många element
• Datamängdens storlek är oförutsägbar eller sannolikt kommer att ändras ofta
• Direktåtkomst till element inte är ett krav
• Datasetet innehåller stora element eller strukturer

Typer av länkade listor

Det finns tre typer av länkade listor, som var och en erbjuder unika fördelar för olika scenarier. Dessa typer är:

Enkelriktade länkade listor

Enkelriktad länkad lista

En enkelriktad länkad lista är den enklaste typen av länkad lista, där varje nod innehåller viss data och en referens till nästa nod i sekvensen. De kan endast genomgås i en riktning – från huvudet (den första noden) till svansen (den sista noden).

Varje nod i en enkelriktad länkad lista består typiskt av två delar:

• Data: Den faktiska informationen som lagras i noden.
• Nästa pekare: En referens till nästa nod. Den sista nodens nästa pekare är vanligtvis satt till null.

Eftersom dessa datastrukturer bara kan genomgås i en riktning kräver åtkomst till ett specifikt element via värde eller index att man börjar från huvudet och sekventiellt flyttar sig genom noderna tills önskad nod hittas. Denna operation har en tidskomplexitet på O(n), vilket gör den mindre effektiv för stora listor.

Att infoga och ta bort en nod i början av en enkelriktad länkad lista är mycket effektivt med en tidskomplexitet på O(1). Infogning och borttagning i mitten eller i slutet kräver dock att man går igenom listan fram till den punkten, vilket ger en tidskomplexitet på O(n).

Utformningen av enkelriktade länkade listor gör dem till en användbar datastruktur när man utför operationer som sker i början av listan.

Dubbellänkade listor

Dubbellänkad lista

En nackdel med enkelriktade länkade listor är att vi bara kan gå igenom dem i en riktning och inte kan iterera tillbaka till föregående nod vid behov. Denna begränsning inskränker vår förmåga att utföra operationer som kräver dubbelriktad navigering.

Dubbellänkade listor löser detta problem genom att lägga till en extra pekare i varje nod, vilket säkerställer att listan kan genomgås i båda riktningarna. Varje nod i en dubbellänkad lista innehåller tre element: datan, en pekare till nästa nod och en pekare till föregående nod.

Cirkulära länkade listor

Cirkulär länkad lista

Cirkulära länkade listor är en specialiserad form av länkad lista där den sista noden pekar tillbaka på den första noden, vilket skapar en cirkulär struktur. Det betyder att, till skillnad från de enkel- och dubbellänkade listor vi hittills sett, tar den cirkulära länkade listan inte slut; i stället går den runt.

Den cykliska naturen hos cirkulära länkade listor gör dem idealiska för scenarier som behöver loopas kontinuerligt, såsom brädspel som går från sista spelaren tillbaka till den första, eller i datoralgoritmer som round-robin-schemaläggning.

Tidskomplexitet i korthet

Det är nyttigt att snabbt se hur länkade listor står sig mot Python-listor:

Huvudpoängen: länkade listor vinner på infogningar och borttagningar vid huvudet (O(1)), men förlorar på allt annat. Om du inte ofta lägger till eller tar bort element i början av din datastruktur är en vanlig Python-lista sannolikt det bättre valet.

Hur skapar man en länkad lista i Python

Nu när vi förstår vad länkade listor är, varför vi använder dem och deras varianter, går vi vidare till att implementera dessa datastrukturer i Python. Anteckningsboken för denna handledning finns också i denna DataLab-arbetsbok; om du skapar en kopia kan du redigera och köra koden. Detta är ett utmärkt alternativ om du stöter på problem med att köra koden själv!

Initiera en nod

Som vi lärde oss tidigare är en nod ett element i den länkade listan som lagrar data och en referens till nästa nod i sekvensen. Så här kan du definiera en nod i Python:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

    def __repr__(self):
        return f"Node({self.data})"

Koden ovan initierar en nod genom att utföra två primära åtgärder: Noden tilldelas ett värde i attributet ”data” som representerar den faktiska informationen noden ska innehålla. Attributet ”next” representerar adressen till nästa nod. Detta är för närvarande satt till None, vilket betyder att den inte länkar till någon annan nod i listan. När vi fortsätter att lägga till nya noder i den länkade listan kommer detta attribut att uppdateras för att peka på efterföljande nod.

Skapa en klass för länkad lista

Därefter behöver vi skapa klassen för den länkade listan. Den kommer att kapsla in alla operationer för att hantera noderna, såsom infogning och borttagning. Vi börjar med att initiera den länkade listan:

class LinkedList:
    def __init__(self):
        self.head = None  # Initialize head as None

Genom att sätta self.head till None anger vi att den länkade listan initialt är tom och att det inte finns några noder i listan att peka på. Vi går nu vidare till att fylla listan genom att infoga nya noder.

Infoga en ny nod i början av en länkad lista

I klassen LinkedList ska vi lägga till en metod för att skapa en ny nod och placera den i början av listan:

    def insertAtBeginning(self, new_data):
        new_node = Node(new_data)  # Create a new node 
        new_node.next = self.head  # Next for new node becomes the   current head
        self.head = new_node  # Head now points to the new node

Varje gång du anropar metoden ovan skapas en ny nod med din angivna data. Nästa pekare för denna nya nod sätts till listans nuvarande huvud, vilket placerar denna nod framför de befintliga noderna. Slutligen görs den nyskapade noden till listans huvud.

Vi ska nu fylla denna länkade lista med en serie ord för att få en bättre förståelse för hur infogningsoperationen fungerar. För att åstadkomma detta skapar vi först en metod som är avsedd att gå igenom och skriva ut listans innehåll:

    def printList(self):
        temp = self.head # Start from the head of the list
        while temp:
            print(temp.data,end=' ') # Print the data in the current node
            temp = temp.next # Move to the next node
        print()  # Ensures the output is followed by a new line

Metoden ovan skriver ut innehållet i vår länkade lista. Låt oss nu använda de metoder vi har definierat för att fylla vår lista med en serie ord: ”the quick brown fox”.

if __name__ == '__main__':
    # Create a new LinkedList instance
    llist = LinkedList()

    # Insert each letter at the beginning using the method we created
    llist.insertAtBeginning('fox') 
    llist.insertAtBeginning('brown') 
    llist.insertAtBeginning('quick')  
    llist.insertAtBeginning('the')  

    # Now 'the' is the head of the list, followed by 'quick', then 'brown' and 'fox'

    # Print the list
    llist.printList()

Raderna ovan bör ge följande utdata:

"the quick brown fox"

Infoga en ny nod i slutet av en länkad lista

Vi ska nu skapa en metod som heter insertAtEnd i klassen LinkedList, för att skapa en ny nod i slutet av listan. Om listan är tom blir den nya noden listans huvud. Annars läggs den till efter den nuvarande sista noden i listan. Låt oss se hur detta fungerar i praktiken:

    def insertAtEnd(self, new_data):
        new_node = Node(new_data)
        if self.head is None:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node

Metoden ovan börjar med att skapa en ny nod. Den kontrollerar sedan om listan är tom, och i så fall tilldelas den nya noden som listans huvud. Annars går den igenom listan för att hitta den sista noden och sätter pekaren för denna nod till den nya noden.

Vi behöver nu inkludera denna metod i vår klass LinkedList och använda den för att lägga till ett ord i slutet av vår lista. För att göra detta, ändra din main-funktion så att den ser ut så här:

if __name__ == '__main__':
    llist = LinkedList()

    # Insert words at the beginning
    llist.insertAtBeginning('fox')
    llist.insertAtBeginning('brown')
    llist.insertAtBeginning('quick')
    llist.insertAtBeginning('the')

    # Insert a word at the end
    llist.insertAtEnd('jumps')

    # Print the list
    llist.printList()

Observera att vi helt enkelt har anropat metoden insertAtEnd för att skriva ut ordet ”jumps” i slutet av listan. Koden ovan bör ge följande utdata:

"the quick brown fox jumps"

Ta bort en nod från början av en länkad lista

Att ta bort den första noden i en länkad lista är enkelt eftersom det bara innebär att peka listans huvud mot den andra noden. På så sätt kommer den första noden inte längre vara en del av listan. För att göra detta, inkludera följande metod i klassen LinkedList:

def deleteFromBeginning(self):
    if self.head is None:
        return "The list is empty" # If the list is empty, return this string
    self.head = self.head.next  # Otherwise, remove the head by making the next node the new head

Ta bort en nod från slutet av en länkad lista

För att ta bort den sista noden i en länkad lista måste vi gå igenom listan för att hitta den näst sista noden och ändra dess next-pekare till None. På så sätt kommer den sista noden inte längre vara en del av listan. Kopiera och klistra in följande metod i din klass LinkedList för att göra detta:

def deleteFromEnd(self):
    if self.head is None:
        return "The list is empty" 
    if self.head.next is None:
        self.head = None  # If there's only one node, remove the head by making it None
        return
    temp = self.head
    while temp.next.next:  # Otherwise, go to the second-last node
        temp = temp.next
    temp.next = None  # Remove the last node by setting the next pointer of the second-last node to None

Metoden ovan kontrollerar först om den länkade listan är tom, och returnerar ett meddelande till användaren om så är fallet. Om listan innehåller en enda nod tas den noden bort. För listor med flera noder lokaliseras den näst sista noden och dess referens till nästa nod uppdateras till None.

Låt oss nu uppdatera main-funktionen för att ta bort element från början och slutet av den länkade listan:

if __name__ == '__main__':
    llist = LinkedList()

    # Insert words at the beginning
    llist.insertAtBeginning('fox')
    llist.insertAtBeginning('brown')
    llist.insertAtBeginning('quick')
    llist.insertAtBeginning('the')

    # Insert a word at the end
    llist.insertAtEnd('jumps')

    # Print the list before deletion
    print("List before deletion:")
    llist.printList()

    # Deleting nodes from the beginning and end
    llist.deleteFromBeginning()
    llist.deleteFromEnd()

    # Print the list after deletion
    print("List after deletion:")
    llist.printList()

Koden ovan kommer att skriva ut listan före och efter borttagning, och visar hur infognings- och borttagningsoperationer fungerar i länkade listor. Du bör se följande utdata efter att ha kört koden:

List before deletion:
the quick brown fox jumps 
List after deletion:
quick brown fox

Söka i den länkade listan efter ett specifikt värde

Den sista operationen vi lär oss i detta kapitel är hämtning av ett specifikt värde i den länkade listan. För att göra detta ska metoden börja vid listans huvud och iterera genom varje nod, och kontrollera om nodens data matchar sökvärdet. Här är en praktisk implementering av denna operation:

def search(self, value):
    current = self.head  # Start with the head of the list
    position = 0  # Counter to keep track of the position
    while current: # Traverse the list
        if current.data == value: # Compare the list's data to the search value
            return f"Value '{value}' found at position {position}" # Print the value if a match is found
        current = current.next
        position += 1
    return f"Value '{value}' not found in the list" 

För att hitta specifika värden i den länkade lista vi har skapat, uppdatera din main-funktion för att inkludera sökmetoden vi just skapat:

if __name__ == '__main__':
    llist = LinkedList()

    # Insert words at the beginning
    llist.insertAtBeginning('fox')
    llist.insertAtBeginning('brown')
    llist.insertAtBeginning('quick')
    llist.insertAtBeginning('the')

    # Insert a word at the end
    llist.insertAtEnd('jumps')

   # Print the list before deletion
    print("List before deletion:")
    llist.printList()

    # Deleting nodes from beginning and end
    llist.deleteFromBeginning()
    llist.deleteFromEnd()

    # Print the list after deletion
    print("List after deletion:")
    llist.printList()
    
        # Search for 'quick' and 'lazy' in the list
    print(llist.search('quick'))  # Expected to find
    print(llist.search('lazy'))   # Expected not to find

Koden ovan kommer att ge följande utdata:

List before deletion:
the quick brown fox jumps 
List after deletion:
quick brown fox 
Value 'quick' found at position 0
Value 'lazy' not found in the list

Ordet ”quick” har hittats i den länkade listan eftersom det finns på listans första position. Ordet ”lazy” är däremot inte en del av listan, vilket är anledningen till att det inte hittades.

Avslutande tankar

Om du tagit dig ända hit, grattis! Du har nu en solid förståelse för de grundläggande principerna för länkade listor, inklusive deras struktur, typer, hur man lägger till och tar bort element och hur man traverserar dem.

Men resan slutar inte här. Länkade listor är bara början på världen av datastrukturer och algoritmer. Här är några potentiella nästa steg för att fördjupa din förståelse för ämnet:

Skapa ditt eget projekt

Fördjupa dig i praktiska tillämpningar av länkade listor genom att integrera dem i ett programmerings- eller data science-projekt. Länkade listor används för att utveckla filsystem, konstruera hash-tabeller och till och med skapa GPS-navigationssystem och brädspel. För att komma igång med egna projekt, kolla in våra kostnadsfria guidade data science-projekt som lär dig hur du löser verkliga problem i Python, R och SQL.

Lär dig om datastrukturer och algoritmer

Att lära sig andra datastrukturer, såsom träd, stackar och köer, är ett naturligt steg efter att ha förstått länkade listor. Dessa strukturer bygger vidare på principerna bakom länkade listor och hjälper dig att lösa ett bredare spektrum av beräkningsproblem effektivt. Träd och binära sökträd, till exempel, utvidgar konceptet med länkade listor till en hierarkisk form, vilket gör att varje nod kan kopplas till flera element i datastrukturen.

Om dessa koncept låter obekanta, oroa dig inte! Datacamp har en hel kurs om datastrukturer och algoritmer i Python som tar dig igenom dessa koncept mer ingående. Du kommer först att lära dig om datastrukturer som stackar, träd, hash-tabeller, köer och grafer. I takt med att du går vidare i kursen får du förståelse för sök- och sorteringsalgoritmer, vilket hjälper dig att bli en mer effektiv programmerare och problemlösare.

Utforska avancerade koncept för länkade listor

Vi har implementerat enkelriktade länkade listor i denna handledning och täckt operationer som infogning, borttagning och genomgång.

Du kan ta denna kunskap ett steg längre genom att lära dig implementeringen av dubbellänkade och cirkulära länkade listor. Skip lists är en annan utvidgning av länkade listor som möjliggör snabbare sökoperationer genom att underlätta snabbare åtkomst till element.

Att lära dig dessa avancerade datastrukturer kommer att ta dina tekniska färdigheter till nästa nivå och dramatiskt förbättra din programmeringsförmåga, och förbereda dig för mer komplexa utmaningar inom områden som data science, programvaruutveckling och maskininlärnings­engineering.

Om du vill ha en mer nybörjarvänlig introduktion till programmering innan du tar dig an dessa avancerade ämnen, utforska vår Python Programmer-karriärväg. Den erbjuder en serie kurser som lär dig grunderna i språket.