Node Structure and Representation of Singly Linked List

A singly linked list is a data structure that consists of nodes, where each node contains two parts: a data field that holds the actual value and a pointer that points to the next node in the list. This structure allows for efficient insertion and deletion of elements, making it a flexible way to manage data collections.

This article will explore the node structure and how it represents a linked list.

Node Structure of Linked List

A singly linked list consists of nodes, where each node contains:

• Data Field: Holds the actual data.
• Next Field: A pointer/reference to the next node.

Node Structure of Singly Linked List in Different Languages:

// Define the structure for a node
struct Node
{
    // Data field to hold the actual data
    int data;
    // Next field as a pointer to the next node
    Node *next;
    // Constructor to initialize the node
    Node(int value){
        // Set the data
        data = value;
        // Initialize next pointer to nullptr
        next = nullptr;
    }
};

// Define the structure for a node
struct Node
{
    // Data field to hold the actual data
    int data;
    // Next field as a pointer to the next node
    struct Node *next;
};

// Function to create a new node
struct Node *createNode(int value){

    // Allocate memory
    struct Node *newNode = 
      (struct Node *)malloc(sizeof(struct Node));

    // Set the data
    newNode->data = value;  
    // Initialize next to NULL
    newNode->next = NULL;
    // Return the new node
    return newNode;
}

// Define the Node class
class Node {

    // Data field to hold the actual data
    int data;
    // Next field as a reference to the next node
    Node next;
    // Constructor to initialize the node
    Node(int value) {
        // Set the data
        data = value;
        // Initialize next pointer to null
        next = null;
    }
}

# Define the Node class
class Node:
    def __init__(self, value):

       # Data field to hold the actual data
        self.data = value
        # Next field initialized to None
        self.next = None

// Define the Node class
class Node {

    // Data field to hold the actual data
    public int data;
    // Next field as a reference to the next node
    public Node next;
  
    // Constructor to initialize the node
    public Node(int value) {
        // Set the data
        data = value;
        // Initialize next pointer to null
        next = null;
    }
}

// Define the Node class
class Node {
    constructor(value) {
        // Data field to hold the actual data
        this.data = value;
        // Next field initialized to null
        this.next = null;
    }
}

Memory Representation of a Linked List

Unlike arrays, where elements are stored in contiguous memory locations, linked lists allocate memory dynamically for each node. This means that each node can be located anywhere in the memory and they are connected via pointers.

Before looking at the memory representation of singly linked list. Let's first create a linked list having four nodes. Each node has two parts: one part holds a value (data) and the other part holds the address of the next node. The first node is called the head node and it points to the first element in the list. The last node in the list points to NULL, which means there are no more nodes after it.

In the above singly linked list, each node is connected by pointers. These pointers show the address of the next node, which allowing us to move through the list in forward direction. This connection is shown with arrows in the diagram, making it clear how each node links to the next one.

How is Memory Allocation done for Linked List?

Let's see how memory is allocated for the linked list. The images below illustrate this more clearly.

• Heap Memory: The nodes of the linked list are dynamically allocated, which allocate memory from the heap. Heap memory is used for objects whose size may not be known at compile time and allows for dynamic memory management.
• Stack Memory: The pointer "head" is typically defined within a function (like main). Local variables, including pointers, are stored in the stack, which has a fixed size and is managed automatically when the function is called and returns.

Why is Memory Deallocation important for Linked List?

Memory deallocation is crucial for linked lists due to several reasons:

1. Prevention of Memory Leaks

• Memory Leak: When memory allocated dynamically is not properly deallocated, it leads to memory leaks, where the memory remains allocated but is no longer used by the program. Over time, especially in long-running applications, this can cause the program to consume an increasing amount of memory, eventually leading to a crash or system slowdown.
• Linked Lists: In a linked list, each node is dynamically allocated. If these nodes are not properly deallocated when they are no longer needed (e.g., when deleting the list or removing nodes), it results in memory leaks.

2. Efficient Memory Management

• Releasing Memory: Proper deallocation of memory allows the operating system to reclaim the memory that is no longer in use, making it available for other processes or future allocations within the same program.
• Linked Lists: Since linked lists typically involve numerous nodes, failing to deallocate even a single node can lead to inefficient memory usage, especially in environments with limited memory.

3. Avoiding Undefined Behavior

• Dangling Pointers: If memory is deallocated but a pointer to that memory is still used, it leads to a dangling pointer. Accessing memory through a dangling pointer can cause undefined behavior, such as crashes or data corruption.
• Linked Lists: When deleting nodes from a linked list, it's essential to properly update pointers and deallocate memory to avoid dangling pointers.

4. Maintaining Program Stability

• Program Crashes: Failure to deallocate memory properly can lead to resource exhaustion, which may cause the program or even the entire system to become unstable and crash.
• Linked Lists: In a linked list, especially when dealing with large amounts of data, proper memory deallocation ensures that the program runs smoothly without unexpected terminations.

5. Good Programming Practice

• Resource Management: Properly managing resources, including memory, is a hallmark of good programming. It ensures that the program is efficient, stable, and maintainable.
• Linked Lists: In linked list implementations, systematically deallocating memory as nodes are removed or when the list is destroyed is considered best practice and is crucial for writing robust code.

How to do Memory Deallocation for Linked List?

Memory deallocation is a critical aspect of managing linked lists across different programming languages. Properly freeing memory helps prevent memory leaks, dangling pointers, and other issues that could affect the stability and performance of your application. Here’s a quick overview of how to handle memory deallocation in various programming languages.

1. Memory Deallocation for Linked List in C++

• In C++, memory allocated with new must be deallocated using delete.
• After deallocation, always set the pointer to nullptr to avoid dangling pointers.

// Deallocate memory and nullify the pointer
delete pointer;
pointer = nullptr;

2. Memory Deallocation for Linked List in C

• In C, memory allocated with malloc or calloc must be deallocated using free.
• Set the pointer to NULL after freeing memory to prevent it from becoming a dangling pointer.

// Deallocate memory and nullify the pointer
free(pointer);
pointer = NULL;

3. Memory Deallocation for Linked List in Python

• Python's garbage collector automatically manages memory, but you can explicitly delete objects using del.
• Set the reference to None to remove references to an object, helping the garbage collector reclaim memory.

# Explicit deletion and nullification
del pointer
pointer = None

4. Memory Deallocation for Linked List in Java

• Java uses automatic garbage collection, so explicit memory deallocation isn't necessary.
• Nullify references by setting them to null to make objects eligible for garbage collection.

// Nullify the pointer
pointer = null;

5. Memory Deallocation for Linked List in C#

• Like Java, C# relies on garbage collection to manage memory.
• Set references to null to assist the garbage collector in freeing up memory.

// Nullify the pointer
pointer = null;

6. Memory Deallocation for Linked List in JavaScript

• JavaScript automatically manages memory via garbage collection.
• Nullifying references can help ensure that objects are properly collected and memory is freed.

// Nullify the pointer
pointer = null;