Singly Linked List Tutorial

// Define the Node class
class Node {
    int data;
    Node next;

    public Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}

// Define a LinkedList class to encapsulate operations
public class LinkedList {
    // Function to traverse and print the elements of the
    // linked list
    public static void traverseLinkedList(Node head)
    {
        // Start from the head of the linked list
        Node current = head;

        // Traverse the linked list until reaching the end
        // (null)
        while (current != null) {
            // Print the data of the current node
            System.out.print(current.data + " ");

            // Move to the next node
            current = current.next;
        }

        System.out.println();
    }

    // Main method for example usage
    public static void main(String[] args)
    {
        // Create nodes
        Node head = new Node(1);
        Node second = new Node(2);
        Node third = new Node(3);

        // Connect nodes
        head.next = second;
        second.next = third;

        // Call the traverseLinkedList function to print the
        // linked list elements
        traverseLinkedList(head);
    }
}

public class LinkedList {
    // Define the Node class
    static class Node {
        int data;
        Node next;

        // Constructor to create a new node
        Node(int data)
        {
            this.data = data;
            this.next = null;
        }
    }

    Node head; // head of list

    // Function to find the length of the linked list
    public int findLength()
    {
        int length
            = 0; // Initialize a counter for the length
        Node current
            = head; // Start from the head of the list

        // Traverse the list and increment the length for
        // each node
        while (current != null) {
            length++;
            current = current.next;
        }

        // Return the final length of the linked list
        return length;
    }

    // Helper function to add new node at the front of the
    // list
    public void push(int newData)
    {
        Node newNode
            = new Node(newData); // allocate the Node and
                                 // put in the data
        newNode.next
            = head; // make next of new Node as head
        head = newNode; // move the head to point to the new
                        // Node
    }

    // Main method to create and manipulate a linked list
    public static void main(String[] args)
    {
        LinkedList llist = new LinkedList();

        // Adding elements to the list
        llist.push(1);
        llist.push(3);
        llist.push(5);

        // Printing the length of the list
        System.out.println("Length of the linked list is: "
                           + llist.findLength());
    }
}

/* This function is in LinkedList class. Inserts a
new Node at front of the list. This method is
defined inside LinkedList class shown above */
public void push(int new_data)
{
    /* 1 & 2: Allocate the Node &
            Put in the data*/
    Node new_node = new Node(new_data);

    /* 3. Make next of new Node as head */
    new_node.next = head;

    /* 4. Move the head to point to new Node */
    head = new_node;
}

/* Appends a new node at the end. This method is
defined inside LinkedList class shown above */
public void append(int new_data) {
    /* 1. Allocate the Node &
    2. Put in the data
    3. Set next as null */
    Node new_node = new Node(new_data);

    /* 4. If the Linked List is empty, then make the
        new node as head */
    if (head == null) {
        head = new Node(new_data);
        return;
    }

    /* 5. This new node is going to be the last node, so
        make next of it as null */
    new_node.next = null;

    /* 6. Else traverse till the last node */
    Node last = head;
    while (last.next != null)
        last = last.next;

    /* 7. Change the next of last node */
    last.next = new_node;
    return;
}

// Assuming the Node class is defined like this:
class Node {
    public int data;
    public Node next;

    public Node(int value) {
        this.data = value;
        this.next = null;
    }
}

// Declare the head pointer globally
Node head = null;

// Function to insert a new node at a specific position in the list
void insertAtPosition(int value, int position) {
    // Create a new node with the given data
    Node newNode = new Node(value);

    // If position is 0 or the list is empty, insert at the beginning
    if (position == 0 || head == null) {
        newNode.next = head;
        head = newNode;
        return;
    }

    // Traverse to the node just before the specified position
    Node current = head;
    for (int i = 1; i < position && current.next != null; ++i) {
        current = current.next;
    }

    // Insert the new node at the specified position
    newNode.next = current.next;
    current.next = newNode;
}

class Node {
    int data;
    Node next;

    // Constructor to create a new node
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList {
    static Node head = null; // assuming head is a global variable

    // Method to delete the node at the beginning
    public static void deleteAtBeginning() {
        // If the list is empty, do nothing
        if (head == null) {
            System.out.println("List is empty. Cannot delete from the beginning.");
            return;
        }

        // Store the current head in a temporary variable
        Node temp = head;

        // Update the head to the next node
        head = head.next;

    }

    // Method to insert a node at the beginning (for testing purposes)
    public static void insertAtBeginning(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Method to print the list (for testing purposes)
    public static void printList() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // Inserting nodes for testing
        insertAtBeginning(3);
        insertAtBeginning(2);
        insertAtBeginning(1);

        System.out.println("Initial List:");
        printList();

        // Deleting the node at the beginning
        deleteAtBeginning();

        System.out.println("List after deleting the node at the beginning:");
        printList();
    }
}

class Node {
    int data;
    Node next;

    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList {
    static Node head = null; // assuming head is a static variable

    public static void deleteAtEnd() {
        // If the list is empty, do nothing
        if (head == null) {
            System.out.println("List is empty. Cannot delete from the end.");
            return;
        }

        // If there is only one node, delete it and set head to null
        if (head.next == null) {
            head = null;
            return;
        }

        // Traverse to the second last node
        Node current = head;
        while (current.next.next != null) {
            current = current.next;
        }

        // Delete the last node
        current.next = null;
    }

    public static void main(String[] args) {
        // Example usage
        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);

        System.out.println("Original List:");
        printList(head);

        deleteAtEnd();

        System.out.println("List after deleting at end:");
        printList(head);
    }

    // Helper method to print the list
    public static void printList(Node node) {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
        System.out.println();
    }
}

// This code is contributed by Shivam

// Define a class named GFG
public class GFG {
    
    // Define a Node class for the linked list
    static class Node {
        int data; // Data stored in the node
        Node next; // Pointer to the next node

        // Constructor to initialize node with given value
        Node(int val) {
            data = val;
            next = null;
        }
    }
    
    // Define the deleteAtPosition method
    public static void deleteAtPosition(Node head, int position) {
        // If the list is empty, do nothing
        if (head == null) {
            System.out.println("List is empty. Cannot delete from a specific position.");
            return;
        }

        // If deleting the head node
        if (position == 0) {
            Node temp = head;
            head = head.next;
            temp = null; // Free memory by making the node eligible for garbage collection
            return;
        }

        // Traverse to the node just before the specified position
        Node current = head;
        for (int i = 1; i < position && current.next != null; ++i) {
            current = current.next;
        }

        // If position is beyond the end of the list, do nothing
        if (current.next == null) {
            System.out.println("Position is beyond the end of the list. Cannot delete.");
        } else {
            // Delete the node at the specified position
            Node temp = current.next;
            current.next = current.next.next;
            temp = null; // Free memory by making the node eligible for garbage collection
        }
    }
}