Java LinkedList

// Simplified representation of LinkedList's internal Node class
private static class Node<E> {
    E item;       // The actual data stored in this node
    Node<E> next; // Reference to the next node in the list
    Node<E> prev; // Reference to the previous node in the list

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

// LinkedList maintains only two pointers internally:
transient Node<E> first; // pointer to the head node
transient Node<E> last;  // pointer to the tail node
transient int size = 0;  // total number of elements

  HEAD                                          TAIL
  ┌────────────────┐    ┌────────────────┐    ┌────────────────┐
  │ prev │ 10 │next│───▶│ prev │ 20 │next│───▶│ prev │ 30 │next│
  │ null │    │    │◀───│      │    │    │◀───│      │    │null│
  └────────────────┘    └────────────────┘    └────────────────┘

  - Adding to head or tail: O(1) — just update first/last pointer
  - Accessing index 2: O(n) — must traverse from head node by node

import java.util.*;

public class CreateLinkedList {
    public static void main(String[] args) {

        // 1. Empty LinkedList (most common)
        LinkedList<String> names = new LinkedList<>();

        // 2. Using List interface reference (recommended for flexibility)
        List<Integer> numbers = new LinkedList<>();

        // 3. Using Deque interface reference (when used as queue/stack)
        Deque<String> taskQueue = new LinkedList<>();

        // 4. Initialize from an existing collection
        List<String> source = Arrays.asList("Apple", "Banana", "Cherry");
        LinkedList<String> fruits = new LinkedList<>(source);
        System.out.println(fruits); // [Apple, Banana, Cherry]

        // 5. LinkedList of custom objects
        LinkedList<Employee> employees = new LinkedList<>();
    }
}

import java.util.*;

public class LinkedListMethods {
    public static void main(String[] args) {

        LinkedList<String> list = new LinkedList<>();

        // --- Adding elements ---
        list.add("Banana");          // [Banana]
        list.addFirst("Apple");       // [Apple, Banana]
        list.addLast("Cherry");       // [Apple, Banana, Cherry]
        list.add(1, "Avocado");       // [Apple, Avocado, Banana, Cherry]
        System.out.println("After adds: " + list);

        // --- Accessing elements ---
        System.out.println("First: " + list.getFirst());   // Apple
        System.out.println("Last: "  + list.getLast());    // Cherry
        System.out.println("Index 2: " + list.get(2));     // Banana

        // --- Updating ---
        list.set(1, "Apricot");
        System.out.println("After set: " + list);

        // --- Removing ---
        list.removeFirst();
        list.removeLast();
        System.out.println("After remove first/last: " + list);

        // --- Search ---
        System.out.println("Contains Banana: " + list.contains("Banana"));
        System.out.println("Index of Banana: " + list.indexOf("Banana"));

        // --- Size ---
        System.out.println("Size: " + list.size());
    }
}

import java.util.*;

public class LinkedListAsQueue {
    public static void main(String[] args) {

        Queue<String> queue = new LinkedList<>();

        // offer() adds to the tail — O(1)
        queue.offer("Task-1");
        queue.offer("Task-2");
        queue.offer("Task-3");
        System.out.println("Queue: " + queue);

        // peek() — see front without removing
        System.out.println("Front: " + queue.peek());  // Task-1

        // poll() — remove from front (FIFO order)
        System.out.println("Processed: " + queue.poll()); // Task-1
        System.out.println("Processed: " + queue.poll()); // Task-2
        System.out.println("Remaining: " + queue);
    }
}

import java.util.*;

public class LinkedListAsStack {
    public static void main(String[] args) {

        Deque<String> stack = new LinkedList<>();

        // push() adds to the front (head) — O(1)
        stack.push("Page-1");
        stack.push("Page-2");
        stack.push("Page-3");
        System.out.println("Stack (top first): " + stack);

        // pop() removes from front (LIFO order)
        System.out.println("Back: " + stack.pop()); // Page-3
        System.out.println("Back: " + stack.pop()); // Page-2
        System.out.println("Remaining: " + stack);
    }
}

import java.util.*;

public class IterateLinkedList {
    public static void main(String[] args) {

        LinkedList<String> list = new LinkedList<>(Arrays.asList("Java", "Python", "Go", "Rust"));

        // 1. Enhanced for-each (recommended — uses Iterator internally)
        System.out.println("--- for-each ---");
        for (String lang : list) {
            System.out.println(lang);
        }

        // 2. Iterator (best when you need to remove during iteration)
        System.out.println("--- Iterator ---");
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String lang = it.next();
            if (lang.equals("Go")) {
                it.remove(); // safe removal during iteration
            } else {
                System.out.println(lang);
            }
        }
        System.out.println("After removal: " + list);

        // 3. ListIterator (supports bidirectional traversal)
        System.out.println("--- Reverse (ListIterator) ---");
        ListIterator<String> lit = list.listIterator(list.size());
        while (lit.hasPrevious()) {
            System.out.println(lit.previous());
        }

        // 4. descendingIterator() — reverse order without ListIterator
        System.out.println("--- descendingIterator ---");
        Iterator<String> desc = list.descendingIterator();
        while (desc.hasNext()) {
            System.out.println(desc.next());
        }

        // 5. forEach with lambda (Java 8+)
        System.out.println("--- Lambda forEach ---");
        list.forEach(lang -> System.out.println(lang.toUpperCase()));

        // ❌ AVOID THIS — O(n²) performance!
        // for (int i = 0; i < list.size(); i++) { list.get(i); }
    }
}

import java.util.*;

class Employee implements Comparable<Employee> {
    String name;
    int salary;

    Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    @Override
    public int compareTo(Employee other) {
        return Integer.compare(this.salary, other.salary); // sort by salary ascending
    }

    @Override
    public String toString() {
        return name + "(₹" + salary + ")";
    }
}

public class LinkedListCustomObjects {
    public static void main(String[] args) {

        LinkedList<Employee> employees = new LinkedList<>();
        employees.add(new Employee("Rahul",   75000));
        employees.add(new Employee("Priya",   92000));
        employees.add(new Employee("Amit",    68000));
        employees.addFirst(new Employee("Neha", 105000));

        System.out.println("Original: " + employees);

        // Sort by salary (uses compareTo)
        Collections.sort(employees);
        System.out.println("By salary: " + employees);

        // Sort by name using lambda Comparator
        employees.sort(Comparator.comparing(e -> e.name));
        System.out.println("By name: " + employees);

        // Highest paid — getLast() after salary sort
        Collections.sort(employees);
        System.out.println("Highest paid: " + employees.getLast());
    }
}

import java.util.*;

public class BrowserHistory {
    private LinkedList<String> history = new LinkedList<>();
    private int currentIndex = -1;

    public void visit(String url) {
        // Remove all forward history on new visit
        while (history.size() > currentIndex + 1) {
            history.removeLast();
        }
        history.addLast(url);
        currentIndex++;
        System.out.println("Visited: " + url);
    }

    public void back() {
        if (currentIndex > 0) {
            currentIndex--;
            System.out.println("Back to: " + history.get(currentIndex));
        } else {
            System.out.println("No more history.");
        }
    }

    public void forward() {
        if (currentIndex < history.size() - 1) {
            currentIndex++;
            System.out.println("Forward to: " + history.get(currentIndex));
        } else {
            System.out.println("No forward history.");
        }
    }

    public static void main(String[] args) {
        BrowserHistory browser = new BrowserHistory();
        browser.visit("https://google.com");
        browser.visit("https://techsustainify.com");
        browser.visit("https://github.com");
        browser.back();
        browser.back();
        browser.forward();
        browser.visit("https://stackoverflow.com");
    }
}

import java.util.*;

class Task {
    String name;
    int priority;

    Task(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }

    @Override
    public String toString() {
        return "[" + name + ", P" + priority + "]";
    }
}

public class TaskScheduler {
    public static void main(String[] args) {

        Deque<Task> taskQueue = new LinkedList<>();

        // High-priority tasks go to the front
        taskQueue.offerLast(new Task("Send Email",   2));
        taskQueue.offerLast(new Task("Generate Report", 2));
        taskQueue.offerFirst(new Task("DB Backup",   1)); // urgent — front
        taskQueue.offerLast(new Task("Cleanup Logs", 3));

        System.out.println("Task Queue: " + taskQueue);

        System.out.println("\nProcessing tasks:");
        while (!taskQueue.isEmpty()) {
            Task t = taskQueue.poll();
            System.out.println("Processing: " + t);
        }
    }
}