Java & Programming Fundamentals

// Primitive — value lives IN the variable (stack)
int x = 42;           // x IS 42

// Reference — variable holds ADDRESS pointing to heap
String s = "hello";  // s holds address of "hello" object on heap
int[] arr = {1,2,3};  // arr holds address of the array on heap

// Consequence: == checks identity (same address), not equality!
String a = new String("hi");
String b = new String("hi");
System.out.println(a == b);       // false  (different addresses!)
System.out.println(a.equals(b));  // true   (same content) ← USE THIS

// Widening (implicit, safe) — smaller → larger
int i = 100;
long l = i;          // auto-widens: no data loss
double d = i;        // auto-widens to 100.0

// Narrowing (explicit, lossy) — larger → smaller
double pi = 3.99;
int truncated = (int) pi;   // → 3  (TRUNCATES, does NOT round!)

// ⚠️ GOTCHA 1: integer division truncates
double wrong   = 5 / 2;      // → 2.0  (int division first, THEN widened)
double correct = 5.0 / 2;    // → 2.5  (double division)
double correct2 = (double) 5 / 2; // → 2.5  (cast first)

// ⚠️ GOTCHA 2: int overflow — use long!
int n = 100000;
int overflow = n * n;         // → negative! (wraps around 2.1B limit)
long safe = (long) n * n;    // → 10000000000L ✓

// ⭐ char arithmetic — essential for DSA
int idx = 'e' - 'a';            // → 4  (freq array index)
char c = (char)('a' + 3);       // → 'd'
boolean isLower = (ch >= 'a' && ch <= 'z'); // char range check
char upper = (char)(ch - 32);   // lowercase → uppercase

// ── FOR loop — use when count is known ───────────────────────
for (int i = 0; i < n; i++)          // forward: i goes 0..n-1
for (int i = n-1; i >= 0; i--)        // reverse: suffix processing
for (int i = 0; i < n; i += 2)        // step 2: even indices
for (int i = 0; i < n-1; i++)         // n-1 pairs: adj comparison

// ── WHILE loop — use when count is unknown ───────────────────
while (lo <= hi) { ... }              // binary search template
while (n > 0) { digit = n%10; n/=10;} // digit extraction
while (n > 1) { n /= 2; count++; }   // count divisions → O(log n)
while (fast != null && fast.next != null) // linked list traversal

// ── DO-WHILE — body runs at least once ───────────────────────
do {
    digit = n % 10;
    reversed = reversed * 10 + digit;
    n /= 10;
} while (n != 0);                    // handles n=0 correctly

// ── FOR-EACH — read-only traversal ───────────────────────────
for (int x : arr) sum += x;           // array
for (String s : list) process(s);    // collection
for (Map.Entry<K,V> e : map.entrySet()) // map iteration

// ── NESTED LOOPS — know the complexity! ──────────────────────
for (int i = 0; i < n; i++)          // ┐ O(n²) — all pairs
    for (int j = i+1; j < n; j++) {}  // ┘ j starts at i+1: n(n-1)/2 pairs

// ── BREAK / CONTINUE ─────────────────────────────────────────
break;    // exits the INNERMOST loop only
continue; // skips to NEXT iteration of innermost loop
// To break an outer loop: use labeled break
outer: for (...) {
    for (...) { if (found) break outer; } // exits outer loop!
}

// Standard if-else
if (x > 0) { ... }
else if (x == 0) { ... }
else { ... }

// Ternary — for simple single-value selection
int max = (a > b) ? a : b;
int abs = (x < 0) ? -x : x;     // ternary absolute value

// Switch (Java 14+ — enhanced switch expression)
int days = switch (month) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    case 4, 6, 9, 11 -> 30;
    default -> 28;
};

// ⭐ Short-circuit evaluation — CRITICAL for null safety!
// && stops at first FALSE condition
if (node != null && node.val == target) { ... }
// if node==null, right side NEVER evaluates → no NullPointerException

// || stops at first TRUE condition
if (arr == null || arr.length == 0) return;
// if arr==null, second check NEVER runs → safe!

// ⚠️ Integer.MAX_VALUE and MIN_VALUE — essential constants
int max = Integer.MAX_VALUE;  // 2^31 - 1 = 2,147,483,647
int min = Integer.MIN_VALUE;  // -2^31  = -2,147,483,648
int res = Math.max(a, b);      // Math utility methods
int abs = Math.abs(x);
double sq = Math.sqrt(n);

//  access    static   return   name          parameters
public static   int   binarySearch(int[] arr, int target) {
    // body
    return -1;  // must return int (matches return type)
}

// void methods — no return value (but can still return early!)
public static void swap(int[] arr, int i, int j) {
    int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp;
}

// Method overloading — same name, different params
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; } // different return type too

// Varargs — variable number of args (used in DSA for flexibility)
int sum(int... nums) {
    int total = 0;
    for (int n : nums) total += n;
    return total;
}
// call: sum(1), sum(1,2), sum(1,2,3,4,5) — all valid

// PRIMITIVE: copy of value — original unchanged
void tryChange(int x) { x = 99; }
int a = 5;
tryChange(a);
System.out.println(a);  // still 5 — x was a COPY

// ARRAY: copy of reference — mutations visible to caller!
void mutate(int[] arr) { arr[0] = 99; }
int[] arr = {1,2,3};
mutate(arr);
System.out.println(arr[0]);  // 99 — mutation persisted!

// REFERENCE REASSIGNMENT: doesn't affect caller
void reassign(int[] arr) { arr = new int[]{9,9,9}; }
reassign(arr);
System.out.println(arr[0]);  // still 99 — local arr was a copy of address

// ⭐ Consequence: swap(int a, int b) NEVER works
//   swap(int[] arr, int i, int j) DOES work (mutations on shared array)

// ── Declaration & Initialization ─────────────────────────────
int[] a = new int[5];          // [0,0,0,0,0] — auto-initialized to 0
boolean[] vis = new boolean[n]; // [false,false,...] auto init
int[] b = {3, 1, 4, 1, 5};     // literal init
int[][] mat = new int[3][4];   // 3 rows, 4 cols — all 0
int[][] grid = {{1,2},{3,4}};  // 2D literal

// ── Access ────────────────────────────────────────────────────
a.length                        // FIELD (no parens!) — O(1)
mat.length                      // number of rows
mat[0].length                   // number of cols in row 0

// ── java.util.Arrays methods ──────────────────────────────────
Arrays.sort(a);                 // O(n log n) — dual-pivot quicksort
Arrays.sort(a, 0, 5);          // sort subarray [0,5)
Arrays.fill(a, -1);             // fill all with -1  O(n)
Arrays.fill(a, 2, 5, 0);       // fill range [2,5) with 0
Arrays.copyOf(a, a.length);    // full copy — O(n)
Arrays.copyOfRange(a, 1, 4);   // subarray copy — indices [1,4)
Arrays.equals(a, b);           // element-wise comparison
Arrays.binarySearch(a, target); // O(log n) — array must be sorted!
Arrays.toString(a);            // "[1, 2, 3]" for printing

// ── Custom sort with Comparator ───────────────────────────────
Integer[] arr = {3,1,4,1,5};
Arrays.sort(arr, (a, b) -> b - a); // descending — note: needs Integer[], not int[]
// Sort by absolute value:
Arrays.sort(arr, (a, b) -> Math.abs(a) - Math.abs(b));

// The class you'll write/use constantly in tree problems
class TreeNode {
    int val;
    TreeNode left, right;

    TreeNode(int val) { this.val = val; }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val; this.left = left; this.right = right;
    }
}

// ListNode — for linked list problems
class ListNode {
    int val;
    ListNode next;
    ListNode(int val) { this.val = val; }
}

// Custom sorting — appears in interval, scheduling, and K-th problems

// Sort intervals by start time
Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

// Sort strings by length
Arrays.sort(words, (a, b) -> a.length() - b.length());

// Max-heap (reverse natural order) — used constantly!
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a,b) -> b-a);

// Min-heap by second element of pair
PriorityQueue<int[]> pq = new PriorityQueue<>((a,b) -> a[1] - b[1]);

// Generics — type-safe collections
List<Integer> list = new ArrayList<>();
Map<String, List<Integer>> graph = new HashMap<>();
Set<Integer> visited = new HashSet<>();

// static — belongs to the CLASS, shared across all instances
class Counter {
    static int count = 0;   // shared across ALL instances
    int id;                  // unique per instance
    Counter() { id = ++count; }
}

// static methods can't access instance fields (no 'this')
// Why main() is static: JVM calls it without creating an object

// final — prevents reassignment / inheritance / override
final int MAX = 100;        // constant; convention: ALL_CAPS
final String s = "hi"; s = "bye";  // ✗ COMPILE ERROR

// DSA constants you'll use constantly:
static final int INF = Integer.MAX_VALUE;  // Dijkstra, DP
static final int MOD = 1_000_000_007;       // modular arithmetic

class Point {
    int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Point)) return false;
        Point p = (Point) o;
        return x == p.x && y == p.y;
    }

    @Override
    public int hashCode() {
        return 31 * x + y;  // must be consistent with equals()
    }
}
// Without overriding: map.get(new Point(1,2)) → null even after put!
Map<Point, String> map = new HashMap<>();
map.put(new Point(1,2), "origin");
map.get(new Point(1,2));  // → "origin" ✓ (with both overrides)

// ── O(1) — fixed number of operations ────────────────────────
arr[i];                          // array access
map.get(key);                    // hashmap lookup
pq.peek();                       // heap peek

// ── O(log n) — input HALVED each step ────────────────────────
while (n > 1) { n /= 2; }      // log₂n iterations
// Binary search, heap operations, balanced BST ops

// ── O(√n) — loop to square root ──────────────────────────────
for (int i = 2; i*i <= n; i++) // prime check — √n iterations

// ── O(n) — single pass ───────────────────────────────────────
for (int i = 0; i < n; i++) {}  // n iterations
// Two-pointer, sliding window (both pointers move ≤ n times total)

// ── O(n log n) — sort, or divide + linear merge ──────────────
Arrays.sort(arr);               // O(n log n)
// Merge sort: log n levels × O(n) merge = O(n log n)

// ── O(n²) — nested loops over same input ─────────────────────
for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) // always O(n²) even if j=i+1

// ── O(2ⁿ) — two recursive calls or all subsets ───────────────
// fib(n-1) + fib(n-2), or all 2ⁿ subsets of an array

// ── O(n!) — all permutations ─────────────────────────────────
// Generating all arrangements of n elements

// O(1) space — only fixed number of extra variables
int sum = 0;
for (int x : arr) sum += x;   // one variable, regardless of n

// O(n) space — proportional to input
int[] copy = Arrays.copyOf(arr, n);   // n-size extra array
Map<?,?> map = new HashMap<>();      // up to n entries

// O(n) space — RECURSION! Each call frame is on the stack
int factorial(int n) {
    if(n==0) return 1;
    return n * factorial(n-1);  // depth n → O(n) stack space
}

// O(log n) space — binary search (recursive) depth = log n
// O(n) space  — merge sort call stack depth = log n, but merge arrays = O(n)

// Auxiliary space = extra space beyond input storage
// Total space = input + auxiliary

// ── ArrayList ─────────────────────────────────────────────────
List<Integer> list = new ArrayList<>();
list.add(5);               // append
list.add(0, 5);            // insert at index 0 — O(n)!
list.get(i);               // O(1)
list.remove(i);            // by index — O(n); shifts everything
list.remove(Integer.valueOf(5)); // by value — O(n)
list.size(); list.isEmpty(); list.contains(x);
Collections.sort(list);    // O(n log n)
Collections.reverse(list);

// ── HashMap ───────────────────────────────────────────────────
Map<String,Integer> map = new HashMap<>();
map.put("a", 1);
map.get("a");                        // returns null if absent
map.getOrDefault("a", 0);           // ← use this to avoid null checks!
map.containsKey("a"); map.containsValue(1);
map.put("a", map.getOrDefault("a",0)+1); // frequency count pattern
map.putIfAbsent("a", new ArrayList<>()); // graph adjacency list
for (var e : map.entrySet())          // iterate all entries
    System.out.println(e.getKey() + " → " + e.getValue());

// ── PriorityQueue ─────────────────────────────────────────────
PriorityQueue<Integer> minPQ = new PriorityQueue<>();    // min-heap
PriorityQueue<Integer> maxPQ = new PriorityQueue<>(Collections.reverseOrder());
minPQ.offer(5);  // add
minPQ.peek();    // view min without removing — O(1)
minPQ.poll();    // remove and return min — O(log n)

// ── ArrayDeque as Stack ──────────────────────────────────────
Deque<Integer> stack = new ArrayDeque<>();
stack.push(5);   // push to front
stack.pop();     // remove from front
stack.peek();    // view front without removing

// ── ArrayDeque as Queue ──────────────────────────────────────
Deque<Integer> queue = new ArrayDeque<>();
queue.offer(5);  // enqueue at back
queue.poll();    // dequeue from front
queue.peek();    // view front