DoublyLinkedList.java

public class DoublyLinkedList {
    // Head and Tail pointers for the list
    private Node head;
    private Node tail;
    private int size;

    // Constructor
    public DoublyLinkedList() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }

    // --- Basic Operations ---

    /**
     * Adds a new node to the front (head) of the list.
     */
    public void addFirst(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            // List is empty
            head = newNode;
            tail = newNode;
        } else {
            // List is not empty
            newNode.next = head;
            head.prev = newNode;
            head = newNode;
        }
        size++;
    }

    /**
     * Adds a new node to the end (tail) of the list.
     */
    public void addLast(int data) {
        Node newNode = new Node(data);
        if (tail == null) {
            // List is empty
            head = newNode;
            tail = newNode;
        } else {
            // List is not empty
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
        }
        size++;
    }

    /**
     * Deletes the first occurrence of a node with the given data.
     */
    public boolean deleteNode(int data) {
        Node current = head;

        // Traverse to find the node
        while (current != null && current.data != data) {
            current = current.next;
        }

        // If the node was not found
        if (current == null) {
            return false;
        }

        // 1. If it's the HEAD node
        if (current == head) {
            head = head.next;
            if (head != null) {
                head.prev = null;
            } else {
                // List became empty
                tail = null;
            }
        }
        // 2. If it's the TAIL node
        else if (current == tail) {
            tail = tail.prev;
            tail.next = null;
        }
        // 3. If it's a node in the MIDDLE
        else {
            current.prev.next = current.next;
            current.next.prev = current.prev;
        }

        size--;
        return true;
    }

    /**
     * Prints the list from head to tail.
     */
    public void printForward() {
        Node current = head;
        System.out.print("Forward List: ");
        while (current != null) {
            System.out.print(current.data + (current.next != null ? " <-> " : ""));
            current = current.next;
        }
        System.out.println();
    }

    /**
     * Prints the list from tail to head.
     */
    public void printBackward() {
        Node current = tail;
        System.out.print("Backward List: ");
        while (current != null) {
            System.out.print(current.data + (current.prev != null ? " <-> " : ""));
            current = current.prev;
        }
        System.out.println();
    }

    // --- Main Method for Testing ---

    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();

        System.out.println("--- Adding Elements ---");
        list.addLast(10);  // List: [10]
        list.addFirst(5);  // List: [5 <-> 10]
        list.addLast(20);  // List: [5 <-> 10 <-> 20]
        list.addFirst(1);  // List: [1 <-> 5 <-> 10 <-> 20]
        list.addLast(30);  // List: [1 <-> 5 <-> 10 <-> 20 <-> 30]

        list.printForward();
        list.printBackward();
        System.out.println("Current Size: " + list.size);

        System.out.println("\n--- Deleting Elements ---");
        System.out.println("Deleting 1 (Head): " + list.deleteNode(1)); // Delete Head
        System.out.println("Deleting 30 (Tail): " + list.deleteNode(30)); // Delete Tail
        System.out.println("Deleting 10 (Middle): " + list.deleteNode(10)); // Delete Middle
        System.out.println("Deleting 99 (Not Found): " + list.deleteNode(99)); // Not Found

        list.printForward(); // Should be [5 <-> 20]
        list.printBackward(); // Should be [20 <-> 5]
        System.out.println("New Size: " + list.size);
    }
}