Inserting a Node in a Doubly Linked List in Java

A doubly linked list is a data structure where each node contains two references, one pointing to the previous node and another pointing to the next node. This allows for efficient traversal in both directions. Inserting a node in a doubly linked list involves updating the references of the neighbouring nodes to maintain the correct order. In this article, we will explore how to insert a node in a doubly linked list using Java.

Let's start by defining the structure of a node in the doubly linked list:

Class Node {
    Int data;
    Node prev;
    Node next;
    public Node(int data) {
        This.data = data;
        This.prev = null;
        This.next = null;
    }
}

Here, each node contains an integer value data, and references to the previous and next nodes (prev and next).

To insert a new node in a doubly linked list, we need to consider three cases:

Insertion at the beginning of the list.
Insertion at the end of the list.
Insertion at a specific position within the list.

Insertion at the beginning of the list:

To insert a node at the beginning, we need to update the next reference of the new node to point to the current first node, and update the prev reference of the current first node to point back to the new node. Additionally, we need to update the prev reference of the new node to be null, as it will be the new first node.

public void insertAtBeginning(int data) {
    Node newNode = new Node(data);
    If (head == null) {
        Head = newNode;
    } else {
        newNode.next = head;
        head.prev = newNode;
        head = newNode;
    }
}

Insertion at the end of the list:

To insert a node at the end, we need to traverse the list until we reach the last node. Then, we update the next reference of the current last node to point to the new node, and update the prev reference of the new node to point back to the current last node. Finally, we update the next reference of the new node to be null, as it will be the new last node.

public void insertAtEnd(int data) {
    Node newNode = new Node(data);
    If (head == null) {
        Head = newNode;
    } else {
        Node current = head;
        While (current.next != null) {
            Current = current.next;
        }
        Current.next = newNode;
        newNode.prev = current;
    }
}

Insertion at a specific position within the list:

To insert a node at a specific position, we need to traverse the list until we reach the desired position. Then, we update the references of the neighbouring nodes to include the new node. Specifically, we update the next reference of the previous node to point to the new node, update the prev reference of the new node to point back to the previous node, update the next reference of the new node to point to the next node, and update the prev reference of the next node to point back to the new node.

public void insertAtPosition(int data, int position) {
    Node newNode = new Node(data);
    If (position == 1) {
        newNode.next = head;
        if (head != null) {
            head.prev = newNode;
        }
        Head = newNode;
    } else {
        Node current = head;
        Int currentPosition = 1;
        While (currentPosition < position - 1 && current != null) {
            Current = current.next;
            currentPosition++;
        }
        If (current != null) {
            newNode.next = current.next;
            newNode.prev = current;
            if (current.next != null) {
                current.next.prev = newNode;
            }
            Current.next = newNode;
        } else {
            System.out.println("Invalid position");
        }
    }
}

InsertNodeExample.java

class Node {
    int data;
    Node prev;
    Node next;
    public Node(int data) {
        this.data = data;
        this.prev = null;
        this.next = null;
    }
}
class DoublyLinkedList {
    Node head;
    public void insertAtBeginning(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            newNode.next = head;
            head.prev = newNode;
            head = newNode;
        }
    }
    public void insertAtEnd(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
            newNode.prev = current;
        }
    }
    public void insertAtPosition(int data, int position) {
        Node newNode = new Node(data);
        if (position == 1) {
            newNode.next = head;
            if (head != null) {
                head.prev = newNode;
            }
            head = newNode;
        } else {
            Node current = head;
            int currentPosition = 1;
            while (currentPosition < position - 1 && current != null) {
                current = current.next;
                currentPosition++;
            }
            if (current != null) {
                newNode.next = current.next;
                newNode.prev = current;
                if (current.next != null) {
                    current.next.prev = newNode;
                }
                current.next = newNode;
            } else {
                System.out.println("Invalid position");
            }
        }
    }
    public void display() {
        Node current = head;
        System.out.print("Doubly Linked List: ");
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }
}
public class InsertNodeExample {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();
        // Inserting nodes
        list.insertAtEnd(10);
        list.insertAtEnd(20);
        list.insertAtEnd(30);
        list.display(); // Output: Doubly Linked List: 10 20 30
        list.insertAtBeginning(5);
        list.display(); // Output: Doubly Linked List: 5 10 20 30
        list.insertAtPosition(15, 2);
        list.display(); // Output: Doubly Linked List: 5 15 10 20 30
    }
}

Output:

Doubly Linked List: 10 20 30
Doubly Linked List: 5 10 20 30
Doubly Linked List: 5 15 10 20 30

With these three insertion methods, you can easily add new nodes to a doubly linked list in Java. Remember to handle special cases such as an empty list or an invalid position.

In conclusion, the doubly linked list is a versatile data structure that allows for efficient insertion and traversal in both directions. By understanding how to insert a node in different positions within the list, you can utilize the doubly linked list effectively in your Java programs.

Next TopicJava 9 Immutable Collections

← prev next →