Skip to content

stack_and_queue.md

Latest commit

 

History

History
134 lines (91 loc) · 4.57 KB

stack_and_queue.md

File metadata and controls

134 lines (91 loc) · 4.57 KB

The Gourmet Data Diner: Serving Up Stacks and Queues! 🍽️👨‍🍳

Welcome, culinary coders and data chefs, to the most exquisite restaurant in the programming world! Today, we're featuring two signature dishes: the Towering Stack and the Orderly Queue. Let's savor the flavors of these delectable data structures! 🍴😋

The Stack: The Towering Pancake Extravaganza! 🥞

Imagine a towering stack of fluffy pancakes, each one a delicious piece of data!

Key Ingredients of Our Pancake Tower:

  1. The Plate (Base): Where our pancake adventure begins.
  2. Pancakes (Elements): Each pancake represents a piece of data.
  3. The Syrupy Top (Top of Stack): Where we add and remove pancakes.

The Pancake Chef's Special Moves:

  1. Push (Add a Pancake): 🔼 Slide a fresh, hot pancake onto the top of the stack.

  2. Pop (Remove a Pancake): 🔽 Take the topmost pancake off the stack and enjoy!

  3. Peek (Check the Top Pancake): 👀 Take a quick look at the top pancake without removing it.

class PancakeStack:
    def __init__(self):
        self.stack = []

    def push(self, pancake):
        self.stack.append(pancake)

    def pop(self):
        if not self.is_empty():
            return self.stack.pop()

    def peek(self):
        if not self.is_empty():
            return self.stack[-1]

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

Flavor Profile (Characteristics):

  • LIFO (Last In, First Out): The last pancake added is the first one eaten!
  • Fast Operations: Adding and removing from the top is quick and easy.
  • Limited Access: You can only interact with the top pancake.

Real-World Taste Test (Applications):

  1. Undo Functionality: Each action is a pancake. Need to undo? Just pop a pancake off!
  2. Browser History: Each webpage visited is a new pancake on the stack.
  3. Function Call Stack: In programming, function calls stack up like pancakes.

The Queue: The Orderly Sushi Conveyor Belt! 🍣

Picture a sushi restaurant with a conveyor belt, where sushi plates (data) move in an orderly fashion.

Key Components of Our Sushi Conveyor:

  1. The Belt: Our queue structure.
  2. Sushi Plates (Elements): Each plate represents a piece of data.
  3. Chef's End (Rear): Where new sushi plates are added.
  4. Diner's End (Front): Where sushi plates are removed and enjoyed.

The Sushi Master's Techniques:

  1. Enqueue (Add Sushi): 🔚 The chef places a new sushi plate at the rear of the conveyor.

  2. Dequeue (Remove Sushi): 🔝 A diner picks up the frontmost sushi plate.

  3. Peek (Check First Sushi): 👀 Look at the first sushi plate without taking it.

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

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

    def dequeue(self):
        if not self.is_empty():
            return self.queue.pop(0)

    def peek(self):
        if not self.is_empty():
            return self.queue[0]

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

Flavor Profile (Characteristics):

  • FIFO (First In, First Out): The first sushi added is the first one eaten!
  • Fair Serving: Everyone gets their sushi in the order it was prepared.
  • Two-Ended Operations: Add at one end, remove from the other.

Real-World Taste Test (Applications):

  1. Print Queue: Documents wait their turn to be printed.
  2. Breadth-First Search: Explore all neighbors before moving to the next level.
  3. Task Scheduling: Processes wait their turn for CPU time.

Gourmet Coding Challenges 👨‍🍳💻

  1. The Balanced Bracket Buffet: Use a stack to check if brackets in a code snippet are balanced.
  2. The Hot Potato Simulation: Implement the Hot Potato game using a queue.
  3. The Palindrome Platter: Use a stack and a queue to determine if a word is a palindrome.

Chef's Special: The Deque (Double-Ended Queue) 🍱

For our adventurous diners, try our Deque special - add or remove from both ends!

from collections import deque

sushi_deque = deque(["Tuna", "Salmon", "Eel"])
sushi_deque.appendleft("Octopus")  # Add to front
sushi_deque.append("Shrimp")  # Add to rear
print(sushi_deque.popleft())  # Remove from front
print(sushi_deque.pop())  # Remove from rear

Remember, aspiring data chefs, mastering Stacks and Queues is like perfecting your mise en place - it's the foundation of efficient and organized coding cuisine!

Are you ready to start cooking up some delicious data structures? The kitchen is open, and the code is sizzling! 👩‍🍳🔥🍳