Creating a Linked List Structure Using Nodes

A Linked List is a data structure where data elements are organized into individual units called Nodes which are interconnected.

Each node is made up of Data and a Pointer pointing to the next node.

Linked lists have the following structure and characteristics.

The basic unit of a linked list.

Each node contains data and one or two pointers that reference the next node (and sometimes the previous node).

A pointer that references the first node of the linked list.

It signifies the starting point of the linked list.

A pointer that references the last node of the linked list.

The pointer in the tail node generally points to None.

Below is a Python example that implements a Singly Linked List.

Copy
class Node:
    def __init__(self, data):
        # Node data
        self.data = data
        # Pointer to the next node
        self.next = None

class LinkedList:
    def __init__(self, data):
        # Create the first node
        self.head = Node(data)
        # Initially, head and tail are the same
        self.tail = self.head

    def append(self, data):
        # Create a new node and link it
        node = Node(data)
        # Link the new node to the tail node
        self.tail.next = node
        # Set the new node as the tail
        self.tail = node

    def print_all(self):
        # Print the linked list
        node = self.head

        # Traverse the nodes while printing data
        while node:
            print(node.data, end=" ")
            node = node.next
        print()

# Create the linked list
linked_list = LinkedList(5)

# Add nodes
linked_list.append(12)
linked_list.append(7)

# Print the linked list
linked_list.print_all()
# Output: 5 12 7

Linked lists are categorized according to how nodes are connected.

The simplest form of a linked list where each node points only to the next node.

Each node points to both the previous node and the next node.

Allows bidirectional traversal, making insertion and deletion more efficient.

The last node points to the first node, forming a circular structure.

Useful for cyclic iterations.

Linked lists are advantageous for memory management and insertion/deletion operations, while arrays are better suited for random access and faster data processing.