# What are Linked Lists? Complete Guide (2023)

Linked lists are a fundamental data structure in computer science, which store and organize data elements in a linear fashion. Each element, referred to as a node, contains a reference to the next node in the sequence. This complete guide will walk you through the concepts of linked lists, their types, and their advantages and disadvantages. We will also dive into practical examples and implementation in Python, providing a comprehensive understanding for beginners and seasoned programmers alike.

## Understanding Linked Lists

Linked lists are a dynamic data structure, which means they can grow or shrink in size during the execution of a program. Unlike arrays, they don't require a contiguous block of memory, as each element in the list is stored separately and connected through pointers or references.

### Elements of a Linked List

A linked list is made up of nodes, each containing two parts:

**Data**: The actual information or value stored in the node.**Next**: A reference or pointer to the next node in the list.

The first node in the list is called the **head** and the last node is called the **tail**. The tail node's `next`

reference points to `None`

, indicating the end of the list.

### Types of Linked Lists

There are two primary types of linked lists:

**Singly Linked List**: Each node in the list has a reference to the next node. This is the simplest form of a linked list.**Doubly Linked List**: Each node in the list has references to both the previous node and the next node, allowing for traversal in both directions.

In this guide, we will focus on singly linked lists.

## Singly Linked List Implementation

Now that we have a basic understanding of linked lists, let's see how we can implement a singly linked list in Python.

### Defining a Node

First, we need to define a `Node`

class that represents an element in the list.

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

The `Node`

class has an initializer method (`__init__`

) that takes a single parameter, `data`

, which is the value to be stored in the node. The `next`

attribute is initialized to `None`

.

### Creating a Linked List

To create a linked list, we need a separate class that will manage the list and its operations. Let's create a `LinkedList`

class with the following methods:

`__init__`

: Initializes an empty linked list with a`head`

set to`None`

.`is_empty`

: Checks if the list is empty.`length`

: Returns the length of the list.`append`

: Adds a new node to the end of the list.`insert`

: Inserts a new node at a specified position.`delete`

: Removes a node with the given data from the list.`search`

: Searches for a node with the given data in the list and returns its position.`display`

: Prints the contents of the list.

`class LinkedList: def __init__(self): self.head = None def is_empty(self): return self.head is None def length(self): current = self.head count = 0 while current: count += 1 current = current.next return count def append(self, data): new_node = Node(data) if self.is_empty(): self.head = new_node else: current = self.head while current.next: current = current.next current.next = new_node def insert(self, position, data): if position < 0 orposition > self.length(): raise IndexError("Invalid position") new_node = Node(data) if position == 0: new_node.next = self.head self.head = new_node else: current = self.head for _ in range(position - 1): current = current.next new_node.next = current.next current.next = new_node def delete(self, data): if self.is_empty(): raise ValueError("List is empty") if self.head.data == data: self.head = self.head.next else: current = self.head while current.next and current.next.data != data: current = current.next if current.next is None: raise ValueError("Data not found") current.next = current.next.next def search(self, data): current = self.head position = 0 while current: if current.data == data: return position position += 1 current = current.next raise ValueError("Data not found") def display(self): current = self.head while current: print(current.data, end=" -> ") current = current.next print("None")`

With this implementation, we can create and manipulate singly linked lists. Here's an example of how to use the `LinkedList`

class:

`my_list = LinkedList() my_list.append(1) my_list.append(2) my_list.append(3) my_list.insert(1, 5) my_list.display() # Output: 1 -> 5 -> 2 -> 3 -> None print(my_list.search(5)) # Output: 1 my_list.delete(5) my_list.display() # Output: 1 -> 2 -> 3 -> None`

## FAQ

### 1. What is the difference between linked lists and arrays?

Arrays are a contiguous block of memory, while linked lists store elements separately and connect them through pointers. Arrays have constant-time access to elements, while linked lists require traversing the list to access elements, taking linear time. Linked lists can grow or shrink dynamically without the need for resizing, whereas arrays need resizing when they exceed their allocated capacity.

### 2. When should I use linked lists instead of arrays?

Linked lists are a better choice when you need to frequently insert or delete elements at the beginning or middle of the list, as they can do this in constant time. If you need constant-time access to elements or a fixed-size data structure, arrays might be more suitable.

### 3. How can I reverse a linked list?

To reverse a linked list, you can use an iterative or recursive approach. The iterative approach involves updating the `next`

pointers of each node to point to the previous node. The recursive approach involves reversing the remaining list and updating the `next`

pointer of the current node to point to the previous node.

### 4. What is the time complexity of various operations on linked lists?

Here are the time complexities of some common operations on linked lists:

- Access: O(n)
- Search: O(n)
- Insertion: O(1) at the beginning or end, O(n) at a specific position
- Deletion: O(1) at the beginning, O(n) at a specific position or the end

### 5. Can linked lists be used to implement other data structures?

Yes, linked lists can serve as a foundation for other data structures, such as stacks, queues, and symbol tables.

Sharing is caring

Did you like what Mehul Mohan wrote? Thank them for their work by sharing it on social media.

## No comments so far

Curious about this topic? Continue your journey with these coding courses:

4.13k students learning

Piyush Garg

Master Linear Data Structures

3.46k students learning

Piyush Garg

Master Non-Linear Data Structures