Lecture 6 : LinkedList in Python | DSA in Python

Managing data with traditional arrays can become difficult when items need to be added or removed often. In many cases, arrays require elements to be shifted or memory to be resized, which can slow down performance. The Linked List in Python provides a flexible solution by storing elements separately and connecting them through links. Learning this implementation helps beginners understand memory management and prepares them for more advanced concepts in Python DSA.

Importance of Linked List in Python

A Python Linked List is a linear data structure where elements are not stored next to each other in memory. Instead, each element is stored inside a node, and every node points to the next node in the sequence. This design allows memory to be allocated dynamically as needed, making it easy to grow or shrink the structure during program execution.

The main parts of a linked list are:

Node

A node is the basic building block of a linked list. Every node contains two important parts:

• The actual data value

• A reference or link to the next node

Each node stores information and helps connect the list together.

Head

The head is the first node in the linked list. It acts as the starting point of the structure. Every operation, such as traversal, insertion, or deletion, usually begins from the head node.

Tail

The tail is the last node in the linked list. Since there is no node after it, the tail points to None, which marks the end of the list.

[ Head ] ---> [ Data | Next ] ---> [ Data | Next ] ---> [ Data | None ] (Tail)

This structure makes the linked list data highly flexible because elements can be added or removed without shifting other items in memory. That is why the Linked List is an important topic for learners who want to learn Python DSA and build efficient software solutions.

Linked List in Python vs Arrays

Understanding when to choose this data structure over regular Python lists involves analyzing time complexity variations. The operational differences dictate how applications scale.

The table below breaks down the structural differences:

Key Trade-offs

• Memory Allocations: Regular arrays demand a continuous block of memory. A Python Linked List fragments elements across random memory addresses, linking them via explicit references.

• Storage Overhead: Nodes require higher overall storage per element because they must hold both the primary payload value and the reference address pointer.

• Access Barriers: Random access is not allowed. Developers must traverse from the head node sequentially to locate any target index.

Building a Linked List in Python

Python lacks a native built-in linked list class inside its standard collections library. To construct a functional Python linked list implementation, developers define custom object classes using object-oriented principles.

Step 1: Defining the Node Class

The node class acts as the structural blueprint. It initializes with a specific data value and a default pointer set to none.

Python

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

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

Step 2: Creating the Management Class

The main wrapper class manages structural interactions and tracks the initial entry point.

Python

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

Setting the initial head reference to none explicitly declares that the list instance starts completely empty.

Step 3: Traversal Logic

To read or display values, the system starts from the head pointer and visits each node sequentially until it encounters a terminating none value.

Python

def print_list(self):
    temp = self.head
    while temp is not None:
        print(temp.data, end=" -> ")
        temp = temp.next
    print("None")

Insertion Operations in Linked List in Python

Adding records to a linked list data requires reassigning the pointers of adjacent elements. There are three primary ways to insert nodes.

1. Inserting at the Beginning

Placing a new node at the start takes place in constant time O(1). The new node points to the current head, and the head variable updates to hold the new node.

Python

def insert_at_beginning(self, new_data):
    new_node = Node(new_data)
    new_node.next = self.head
    self.head = new_node

2. Inserting at the End

To append an item, the script checks if the list is empty. If it is not empty, it walks down to the last node and changes its next reference from none to the new node.

Python

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

3. Inserting in the Middle

Inserting after a specific node requires re-linking the pointers so the previous node points to the new node, and the new node points to the subsequent node.

Python

def insert_after(self, prev_node, new_data):
    if prev_node is None:
        print("The given previous node must exist.")
        return
   
    new_node = Node(new_data)
    new_node.next = prev_node.next
    prev_node.next = new_node

Deletion Operations in Linked List in Python

Removing data records from a Python linked list requires bypassing the target node completely. The previous element updates its pointer to point directly to the node following the deleted one.

Python

def delete_node(self, key):
    current = self.head
    if current is not None and current.data == key:
        self.head = current.next
        current = None
        return
    prev = None
    while current is not None and current.data != key:
        prev = current
        current = current.next
    if current is None:
        return
    prev.next = current.next
    current = None

This procedure works seamlessly because Python handles memory deallocation automatically via its built-in garbage collector once a node loses all active references.

Linked List in Python Types

Different problems require different types of linked lists. Choosing the right type can make data handling easier and improve performance when working with Python DSA.

Singly Linked Lists

A Singly Linked List is the simplest type of linked list. In this structure, each node contains data and a reference to the next node only.

You can move through the list in one direction, starting from the head and ending at the tail. Since each node stores only one link, it uses less memory than other linked list types.

Doubly Linked Lists

A Doubly Linked List stores an extra reference in every node. Along with the link to the next node, it also keeps a link to the previous node.

This allows movement in both forward and backward directions. Because of the additional pointer, a doubly linked list uses more memory, but it makes navigation and certain operations easier.

Circular Linked Lists

A Circular Linked List is a special type of linked list where the last node does not point to None. Instead, the tail node connects back to the head node.

This creates a continuous loop that can be traversed repeatedly without reaching an end point. Circular linked lists are useful in applications that work in cycles, such as round-robin scheduling, multiplayer game turns, and repeating task systems.

Understanding these different Types of Python Linked List helps you choose the best structure for a specific problem and builds a stronger foundation in Python DSA.

Applications of Linked List in Python

The linked list data structure is used in many real-world applications and forms the base for several advanced data structures. Because it allows easy insertion and deletion of elements, it is useful in situations where data changes frequently.

Stack and Queue Implementations

Linked lists are often used to build stacks and queues. They allow elements to be added and removed quickly without the need to shift data or resize memory. This makes operations more efficient and easier to manage.

Undo and Redo Systems

The undo and redo functionality in many text editors and software applications are handled with linked lists. In a doubly linked list, users may easily go back to prior actions, and ahead to later actions .

Browser Navigation History

The Back and Forward buttons in web browsers are based on linked list ideas. All the pages visited can be linked with the previous and next pages, so the navigation is easy and fast.

Graph Adjacency Lists

Graph data structures make extensive use of linked lists. They provide for the storage of links between nodes . They simplify the expression of relationships in graph algorithms and network based applications.

Dynamic Memory Management

Linked lists increase and shrink throughout the execution of a program. They are useful in applications where the amount of data is not known in advance. This flexibility helps with better memory management.