A Beginner's Guide to Linked List Insertions in Python: Learn the Basics

Introduction

As aspiring programmers, it’s crucial to grasp the fundamentals of data structures, and one such fundamental structure is the linked list. In this blog post, we will dive into the details of inserting elements into a linked list. Whether it’s at the beginning, end, or a specific position, mastering these insertion techniques will strengthen your foundation in programming. Let’s explore these operations with clear explanations and Python code examples.

Understanding Linked Lists

A linked list is a linear data structure where elements are stored in nodes. Each node contains data and a reference (or link) to the next node in the sequence. Unlike arrays, linked lists allow dynamic memory allocation and efficient insertion and deletion operations.

Node Structure

Before diving into insertions, let’s define the structure of a node:

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

Inserting at the Beginning

Inserting a node at the beginning of a linked list is a straightforward process. We create a new node, set its next_node to the current head, and update the head to point to the new node.

def insert_at_beginning(head, data):
    new_node = Node(data)
    new_node.next_node = head
    return new_node

Let’s visualize this with an example:

# Creating a linked list: 1 -> 2 -> 3
linked_list_head = Node(1)
linked_list_head.next_node = Node(2)
linked_list_head.next_node.next_node = Node(3)

# Inserting at the beginning: 0 -> 1 -> 2 -> 3
linked_list_head = insert_at_beginning(linked_list_head, 0)

Inserting at the End

To insert a node at the end of a linked list, we traverse the list until we reach the last node and then append the new node.

def insert_at_end(head, data):
    new_node = Node(data)
    if not head:
        return new_node

    current_node = head
    while current_node.next_node:
        current_node = current_node.next_node

    current_node.next_node = new_node
    return head

Let’s see this in action:

# Creating a linked list: 1 -> 2 -> 3
linked_list_head = Node(1)
linked_list_head.next_node = Node(2)
linked_list_head.next_node.next_node = Node(3)

# Inserting at the end: 1 -> 2 -> 3 -> 4
linked_list_head = insert_at_end(linked_list_head, 4)

Inserting at a Specific Position

Inserting a node at a specific position involves traversing the list to the desired position and adjusting the links to incorporate the new node.

def insert_at_position(head, data, position):
    if position == 0:
        new_node = Node(data)
        new_node.next_node = head
        return new_node

    new_node = Node(data)
    current_node = head
    count = 0

    while current_node and count < position - 1:
        current_node = current_node.next_node
        count += 1

    if not current_node:
        return head # Position is beyond the length of the list

    new_node.next_node = current_node.next_node
    current_node.next_node = new_node
    return head

Let’s try inserting it at a specific position:

# Creating a linked list: 1 -> 2 -> 3
linked_list_head = Node(1)
linked_list_head.next_node = Node(2)
linked_list_head.next_node.next_node = Node(3)

# Inserting at position 1: 1 -> 4 -> 2 -> 3
linked_list_head = insert_at_position(linked_list_head, 4, 1)

Conclusion

This article offers an in-depth explanation of inserting elements into a linked list, a fundamental data structure in programming. We will begin with understanding the concept of linked lists and the structure of a node. The article then guides you through Python code examples demonstrating how to insert a node at the beginning, at the end, and at a specific position in a linked list. This knowledge is essential for efficient memory allocation and operations in programming.