Programmeringens konst - Stack och kö

Innehållsförteckning

1. Introduktion till stapel och kö
2. Stapel - sist in först ut (LIFO)
3. Kö - först in först ut (FIFO)
4. Implementering av stapel (push, pop och top funktioner)
5. Exempel: Testa palindrom med hjälp av stapel
6. Implementering av kö (enqueue, dequeue och front/rear funktioner)
7. Exempel: Modellera utskriftskö
8. Användningsområden för stapel och kö
9. Sammanfattning
10. Resurser

👉🏼 Introduktion till stapel och kö

Stapel och kö är två olika typer av containerstrukturer som bygger på listor. Dessa strukturer möjliggör gruppering av individuella dataelement och tillhandahåller specifika och begränsade tillgångspunkter för att hantera data i program. I den här artikeln kommer vi att titta närmare på hur stapel och kö fungerar och hur de kan användas i olika programmeringssituationer.

👉🏼 Stapel - sist in först ut (LIFO)

En stapel är en enkel och kraftfull struktur som följer principen "sist in först ut" (LIFO). Det innebär att endast det översta elementet är synligt och kan nås. När vi lägger till ett nytt element på en stapel utförs en operation som kallas "push", där det nya elementet placeras överst på stapeln. För att ta bort ett element från stapeln använder vi operationen "pop", vilket tar bort det översta elementet. Det finns också en funktion som kallas "top" som ger oss möjlighet att titta på det översta elementet utan att ta bort det från stapeln.

Fördelar med stapel:

• Enkel att implementera och använda
• Effektiv vid omvändning av element

Nackdelar med stapel:

• Begränsad åtkomst till dataelement
• Svårigheter vid åtkomst till osynliga element

👉🏼 Kö - först in först ut (FIFO)

En kö är en annan containerstruktur som bygger på listor. Till skillnad från en stapel följer en kö principen "först in först ut" (FIFO). Det betyder att det första elementet som läggs till är det första som tas bort. En kö är användbar i situationer där det finns en skillnad mellan hastigheten på inkommande data och behandlingshastigheten. En kö tillhandahåller två operationer: "enqueue" för att lägga till ett element i kön och "dequeue" för att ta bort element från kön. Det finns också funktioner som ger oss möjlighet att titta på det första och sista elementet i kön utan att ta bort dem.

Fördelar med kö:

• Användbar vid ojämn utfodrings- och behandlingshastighet
• Enkel att implementera med länkade listor

Nackdelar med kö:

• Begränsad åtkomst till dataelement
• Kräver mer minnesutrymme än en stapel på grund av länkade listor

👉🏼 Implementering av stapel

För att implementera en stapel kan vi använda antingen en array eller en länkad lista. I båda fallen behöver vi definiera vissa funktioner för att kunna använda stapeln i våra program. De viktigaste funktionerna är:

1. Push: Lägger till ett nytt element överst på stapeln.
2. Pop: Tar bort det översta elementet från stapeln och returnerar det.
3. Top: Returnerar värdet på det översta elementet utan att ta bort det från stapeln.

Utöver dessa grundläggande funktioner kan vi också ha en funktion för att kontrollera om stapeln är tom och en funktion för att initialisera stapeln.

Implementationsexempel:

# Kodexempel på implementering av en stapel i Python

class Stack:
    def __init__(self, max_size):
        self.max_size = max_size  # Maximalt antal element på stapeln
        self.elements = []  # Lista för att lagra stapelns element

    def push(self, item):
        if len(self.elements) < self.max_size:
            self.elements.append(item)
        else:
            raise Exception("Stack Overflow")

    def pop(self):
        if self.elements:
            return self.elements.pop()
        else:
            raise Exception("Stack Underflow")

    def top(self):
        if self.elements:
            return self.elements[-1]
        else:
            raise Exception("Stack is empty")

    def is_empty(self):
        return len(self.elements) == 0

# Användning av stacken
stack = Stack(5)
stack.push(10)
stack.push(20)
stack.push(30)
print(stack.pop())  # Output: 30
print(stack.top())  # Output: 20
print(stack.is_empty())  # Output: False

👉🏼 Exempel: Testa palindrom med hjälp av stapel

Ett praktiskt exempel på användning av en stapel är att testa om en sträng är ett palindrom, det vill säga ett ord eller en fras som är likadan när det läses framåt och bakåt. Vi kan använda en stapel för att omvända strängen och jämföra den med det ursprungliga ordet.

Implementationsexempel:

# Kodexempel på att använda en stapel för att testa palindrom

def is_palindrome(word):
    stack = Stack(len(word))
    for char in word:
        stack.push(char)

    reversed_word = ''
    while not stack.is_empty():
        reversed_word += stack.pop()

    return reversed_word.lower() == word.lower()

# Testa palindrom
print(is_palindrome("radar"))  # Output: True
print(is_palindrome("hello"))  # Output: False

I detta exempel lägger vi varje bokstav i strängen på en stapel och sedan bygger vi ett omvänt ord genom att ta bort bokstäverna från stapeln. Slutligen jämför vi det resulterande omvända ordet med det ursprungliga ordet för att avgöra om det är ett palindrom.

För att testa om en sträng är ett palindrom behöver vi bara anropa is_palindrome() funktionen och skicka in strängen som ett argument.

👉🏼 Implementering av kö

Kö kan också implementeras med antingen en array eller en länkad lista. Precis som med en stapel behöver vi definiera vissa funktioner för att kunna använda kön. De viktigaste funktionerna för en kö är:

1. Enqueue: Lägger till ett nytt element i slutet av kön.
2. Dequeue: Tar bort det första elementet från kön och returnerar det.
3. Front: Returnerar värdet på det första elementet utan att ta bort det från kön.
4. Rear: Returnerar värdet på det sista elementet utan att ta bort det från kön.

Precis som med stapel kan vi ha ytterligare funktioner för att kontrollera om kön är tom och för att initialisera kön.

👉🏼 Exempel: Modellera utskriftskö

Ett exempel där kö är användbart är att modellera en utskriftskö. I detta exempel kan vi använda en kö för att hantera utskriftsjobb som kommer in medan skrivaren bearbetar tidigare jobb. Detta hjälper till att organisera och schemalägga utskriftsjobben i ordning och ger en smidigare utskriftsprocess.

Implementationsexempel:

# Kodexempel på användning av kö för att modellera en utskriftskö

class PrintQueue:
    def __init__(self):
        self.queue = []

    def enqueue(self, job):
        self.queue.append(job)

    def dequeue(self):
        if self.queue:
            return self.queue.pop(0)
        else:
            raise Exception("Queue Underflow")

    def front(self):
        if self.queue:
            return self.queue[0]
        else:
            raise Exception("Queue is empty")

    def rear(self):
        if self.queue:
            return self.queue[-1]
        else:
            raise Exception("Queue is empty")

    def is_empty(self):
        return len(self.queue) == 0

# Användning av utskriftskön
print_queue = PrintQueue()
print_queue.enqueue("Job 1")
print_queue.enqueue("Job 2")
print_queue.enqueue("Job 3")
print(print_queue.dequeue())  # Output: Job 1
print(print_queue.front())  # Output: Job 2
print_queue.enqueue("Job 4")
print(print_queue.rear())  # Output: Job 4
print(print_queue.is_empty())  # Output: False

I detta exempel använder vi en kö för att lägga till utskriftsjobb i kön och ta bort dem i turordning när de ska skrivas ut. Vi kan också kolla på det första och sista jobbet i kön utan att ta bort dem. Funktionen is_empty() används för att kontrollera om kön är tom.

👉🏼 Användningsområden för stapel och kö

Stapel och kö är grundläggande containerstrukturer som kan användas på många olika sätt. Här är några exempel på användningsområden:

1. Stack:

   • Ångra/ångra åtgärder i textredigerare.
   • Implementera call stack för funktioner och återgång från rekursiva anrop.
   • Hantera webbläsarens fram-/tillbakaknapp.
   • Genomföra postfix-/omvända polska noteringar i matematiska beräkningar.

2. Kö:

   • Hantera processer i operativsystemet för att schemalägga och ge prioritet åt exekvering.
   • Modellera kösystem som hanterar inkommande telefonsamtal, e-post eller supportärenden.
   • Hantera utskriftsköer för att organisera och behandla utskriftsjobb.
   • Implementera buffertar för dataöverföring och nätverkskommunikation.

Dessa är bara några exempel på hur stapel och kö kan användas. Beroende på den specifika programmeringssituationen kan det finnas många andra användningsområden där dessa strukturer kan vara användbara.

👉🏼 Sammanfattning

Stapel och kö är två viktiga containerstrukturer som används inom programmering. En stapel är en LIFO-struktur där det översta elementet är synligt och nåbart. En kö är en FIFO-struktur där det första elementet som läggs till är det första som tas bort. Båda dessa strukturer kan implementeras med antingen arrayer eller länkade listor och har olika fördelar och nackdelar.

Genom att förstå hur dessa strukturer fungerar och hur de kan användas i olika programmeringssituationer kan du öka din förmåga att lösa problem och optimera dina program.

👉🏼 Resurser

• GeeksforGeeks: Stack Data Structure
• GeeksforGeeks: Queue Data Structure
• Wikipedia: Stack (abstract data type)
• Wikipedia: Queue (abstract data type)