Data Structures in Python (Stack, Queue, and Linked List)

Data structures are essential components of computer science and programming. In Python, you can implement data structures like the stack, queue, and linked list to manage and organize data efficiently. This guide will explore these data structures, their applications, and how to implement them in Python.

Stack

A stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle. It’s like a stack of plates where the last plate added is the first to be removed. Stacks are used in various applications, such as function call management and parsing expressions.

Example:

Here’s an example of implementing a stack in Python:

class Stack:
    def __init__(self):
        self.items = []

    def is_empty(self):
        return not self.items

    def push(self, item):
        self.items.append(item)

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

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

    def size(self):
        return len(self.items)

# Create a stack and perform stack operations
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)

print(stack.pop())  # Output: 3

Queue

A queue is another linear data structure that follows the First-In-First-Out (FIFO) principle. It’s like a queue of people waiting in line; the first person to join is the first to be served. Queues are used in tasks that involve handling tasks or processes in an ordered manner.

Example:

Here’s an example of implementing a queue in Python:

class Queue:
    def __init__(self):
        self.items = []

    def is_empty(self):
        return not self.items

    def enqueue(self, item):
        self.items.insert(0, item)

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

    def size(self):
        return len(self.items)

# Create a queue and perform queue operations
queue = Queue()
queue.enqueue("Alice")
queue.enqueue("Bob")
queue.enqueue("Charlie")

print(queue.dequeue())  # Output: "Alice"

Linked List

A linked list is a data structure where elements are connected using pointers or references. It provides flexibility in inserting and deleting elements at any position. Linked lists are used in many applications, such as implementing dynamic data structures.

Example:

Here’s an example of implementing a singly linked list in Python:

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

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

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        current = self.head
        while current.next:
            current = current.next
        current.next = new_node

    def display(self):
        elements = []
        current = self.head
        while current:
            elements.append(current.data)
            current = current.next
        return elements

# Create a linked list and perform linked list operations
linked_list = LinkedList()
linked_list.append(1)
linked_list.append(2)
linked_list.append(3)

print(linked_list.display())  # Output: [1, 2, 3]

Conclusion

Understanding data structures like stacks, queues, and linked lists is crucial for solving various programming problems. These data structures provide efficient ways to manage and manipulate data, making them valuable tools in Python and other programming languages. When faced with specific challenges, you can choose the appropriate data structure to optimize your code and create more efficient algorithms.