feat(LinkedListDemo): add demo for Java LinkedList operations and complexities

What
- Created `LinkedListDemo` class to demonstrate:
  - Adding elements with `add()`, `addFirst()`, and `addLast()`.
  - Accessing elements using `get(index)` and `getLast()`.
  - Printing the list contents.
- Added comments comparing time complexity with `ArrayList`.

Why
- Show how Java’s `LinkedList` (doubly-linked) differs from `ArrayList` in performance:
  - Frequent insertions/deletions → `O(1)` with LinkedList.
  - Random access (`get(index)`) → `O(n)` with LinkedList vs `O(1)` in ArrayList.
- Helps learners understand when to use `LinkedList` vs `ArrayList`.

How
- Declared `LinkedList<Integer> linkedList`.
- Added elements: `1, 2, 3`.
- Retrieved an element at index `2` (`linkedList.get(2)` → O(n)).
- Inserted new elements:
  - `addLast(4)` → constant time append.
  - `addFirst(0)` → constant time prepend.
- Retrieved last element using `getLast()`.
- Printed the list to show final contents.

Logic
1. Start with empty `LinkedList`.
2. Add elements → `[1, 2, 3]`.
3. Access element at index 2 → returns `3`.
4. Add `4` at the end → `[1, 2, 3, 4]`.
5. Add `0` at the beginning → `[0, 1, 2, 3, 4]`.
6. Print → final state shown.

Complexity
- `addFirst()`, `addLast()`, `getFirst()`, `getLast()` → O(1).
- `get(index)`, `remove(index)` → O(n) due to traversal.
- ArrayList contrast:
  - Access by index: O(1).
  - Insert/remove in middle: O(n) due to shifting elements.

Applications
- Use LinkedList when:
  - Insertions/removals happen frequently in middle/start.
  - Order of elements matters and random access is not critical.
- Use ArrayList when:
  - Random access dominates.
  - Insertions/removals mostly at the end.

Notes
- Java’s `LinkedList` is **doubly-linked**, so each node has `next` and `previous` pointers.
- Example also includes commented manual `Node` creation to reinforce internal structure.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section 25 Collections Frameworks/List Interface/LinkedList/src/LinkedListDemo.java

@@ -0,0 +1,38 @@
+import java.util.LinkedList;
+
+public class LinkedListDemo {
+    public static void main(String[] args) {
+          //JAVA Ke Andar doubly linked list hoti hai.
+          LinkedList<Integer> linkedList = new LinkedList<>();
+          linkedList.add(1);
+          linkedList.add(2);
+          linkedList.add(3);
+
+          System.out.println(linkedList.get(2)); // O(n) Time Complexity
+
+          linkedList.addLast(4);
+          // O(1) Koi loop nahi laga rahe hai element ko add karne mai.
+          // Loop hota toh O(n) hoti like in ArrayList
+
+          linkedList.addFirst(0); // O(1)
+
+          linkedList.getLast();
+
+          System.out.println(linkedList);
+          /*
+          Data and Pointer.Next and previous pointer to a linked list.
+          Time Complexity: Insertion and deletions are frequent. O(1)
+          */
+
+          /*
+          Node node1 = new Node();
+          Node node2 = new Node();
+
+          node2.value = 2;
+          node1.value = 1;
+
+          node1.next = node2;
+          node2.next = null;
+          */
+    }
+}