Trees — Binary Trees & BST

          1          ← Root (no parent)
        /   \
       2     3       ← Internal nodes (have children)
      / \     \
     4   5     6    ← Leaf nodes (no children)

 Node 1: depth = 0, height = 2
 Node 2: depth = 1, height = 1
 Node 4: depth = 2, height = 0  (leaf)

 Tree height   = longest root-to-leaf path = 2
 Subtree of 2  = the entire tree rooted at node 2

 Full BT    : every node has 0 or 2 children
 Complete BT: all levels full except last (left-filled)
 Perfect BT : all internal nodes 2 children, all leaves same depth
 Balanced BT: |height(left) - height(right)| <= 1 at EVERY node
 BST        : left < root < right at EVERY node

class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int val) { this.val = val; }
}
// This is ALL you need. Every LeetCode tree problem uses this exact class.
// left and right are null by default — no child = null reference.

// Preorder: ROOT first — use when root context needed before children (clone, prefix)
void preorder(TreeNode n) {
    if (n == null) return;
    process(n.val);          // ROOT
    preorder(n.left);
    preorder(n.right);
}
// Inorder: Left-ROOT-Right — gives SORTED output for a BST
void inorder(TreeNode n) {
    if (n == null) return;
    inorder(n.left);
    process(n.val);          // ROOT
    inorder(n.right);
}
// Postorder: children before root — use when children results needed first (height, delete)
void postorder(TreeNode n) {
    if (n == null) return;
    postorder(n.left);
    postorder(n.right);
    process(n.val);          // ROOT
}

// Iterative Preorder — push RIGHT first, then LEFT (so left is processed first)
List<Integer> preorderIterative(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    if (root == null) return res;
    Deque<TreeNode> stack = new ArrayDeque<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode n = stack.pop();
        res.add(n.val);                     // visit ROOT immediately
        if (n.right != null) stack.push(n.right);  // right first → processed last
        if (n.left  != null) stack.push(n.left);
    }
    return res;
}

// Iterative Inorder — go left until null, pop & visit, then go right
List<Integer> inorderIterative(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode curr = root;
    while (curr != null || !stack.isEmpty()) {
        while (curr != null) { stack.push(curr); curr = curr.left; }
        curr = stack.pop();
        res.add(curr.val);
        curr = curr.right;
    }
    return res;
}
// Time O(n), Space O(h). Key trick for preorder: push RIGHT before LEFT.

List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();
    if (root == null) return res;
    Queue<TreeNode> q = new LinkedList<>();
    q.offer(root);
    while (!q.isEmpty()) {
        int size = q.size();                    // ← snapshot current level
        List<Integer> level = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            TreeNode n = q.poll();
            level.add(n.val);
            if (n.left  != null) q.offer(n.left);
            if (n.right != null) q.offer(n.right);
        }
        res.add(level);
    }
    return res;
}
// Variants built on this template:
//   Right side view   → last element of each level
//   Zigzag traversal  → alternate direction per level (LinkedList.addFirst)
//   Average of levels → sum/size per level

int maxDepth(TreeNode n) {
    if (n == null) return 0;
    int lh = maxDepth(n.left), rh = maxDepth(n.right);
    return 1 + Math.max(lh, rh);
}

// Balanced tree — use -1 as a sentinel for "unbalanced", O(n) single pass:
boolean isBalanced(TreeNode root) { return check(root) != -1; }
int check(TreeNode n) {
    if (n == null) return 0;
    int lh = check(n.left);   if (lh == -1) return -1;
    int rh = check(n.right);  if (rh == -1) return -1;
    if (Math.abs(lh - rh) > 1) return -1;
    return 1 + Math.max(lh, rh);
}

int maxD = 0;                      // global answer

int diameterOfBinaryTree(TreeNode root) {
    dfs(root);
    return maxD;
}
int dfs(TreeNode n) {               // returns HEIGHT, not diameter
    if (n == null) return 0;
    int lh = dfs(n.left), rh = dfs(n.right);
    maxD = Math.max(maxD, lh + rh);  // diameter through THIS node
    return 1 + Math.max(lh, rh);     // height returned to parent
}
// Diameter at a node = leftHeight + rightHeight (edges through it)
// We check EVERY node as a potential "peak" of the diameter path

int maxSum = Integer.MIN_VALUE;  // global: reset per problem instance

int maxPathSum(TreeNode root) {
    gain(root);
    return maxSum;
}
// gain(n) = max contribution this subtree can add to a path going UP to parent
int gain(TreeNode n) {
    if (n == null) return 0;
    int lGain = Math.max(0, gain(n.left));   // ignore negative branches
    int rGain = Math.max(0, gain(n.right));
    maxSum = Math.max(maxSum, lGain + n.val + rGain);  // path THROUGH this node
    return n.val + Math.max(lGain, rGain);  // can only go ONE direction up
}
// Why max(0, gain)? A negative subtree hurts the path — better to skip it.
// Why return only ONE direction? A path going up can't branch — parent picks one side.

// Validate BST — range propagation:
boolean isValidBST(TreeNode root) { return check(root, Long.MIN_VALUE, Long.MAX_VALUE); }
boolean check(TreeNode n, long lo, long hi) {
    if (n == null) return true;
    if (n.val <= lo || n.val >= hi) return false;
    return check(n.left, lo, n.val) && check(n.right, n.val, hi);
}

// Kth Smallest — inorder = sorted, count as you go:
int k, result;
void kth(TreeNode n) {
    if (n == null) return;
    kth(n.left);
    if (--k == 0) { result = n.val; return; }
    kth(n.right);
}

// INSERT: navigate like search until null spot found, place node there
TreeNode insertIntoBST(TreeNode root, int val) {
    if (root == null) return new TreeNode(val);
    if (val < root.val) root.left  = insertIntoBST(root.left,  val);
    else               root.right = insertIntoBST(root.right, val);
    return root;  // return root so parent pointer stays valid
}

// DELETE: 3 cases
// Case 1: leaf node    → return null
// Case 2: one child    → return that child
// Case 3: two children → swap with inorder successor, delete successor below
TreeNode deleteNode(TreeNode root, int key) {
    if (root == null) return null;
    if      (key < root.val) root.left  = deleteNode(root.left,  key);
    else if (key > root.val) root.right = deleteNode(root.right, key);
    else {
        if (root.left  == null) return root.right;   // Cases 1 & 2
        if (root.right == null) return root.left;
        TreeNode succ = root.right;
        while (succ.left != null) succ = succ.left;      // leftmost = successor
        root.val = succ.val;                               // copy value up
        root.right = deleteNode(root.right, succ.val);   // delete old successor
    }
    return root;
}
// Time O(h): O(log n) balanced BST, O(n) worst case (skewed)

// Binary Tree — works for any tree:
TreeNode lca(TreeNode n, TreeNode p, TreeNode q) {
    if (n == null || n == p || n == q) return n;
    TreeNode l = lca(n.left,  p, q);
    TreeNode r = lca(n.right, p, q);
    if (l != null && r != null) return n;  // split here → this IS the LCA
    return l != null ? l : r;
}

// BST — exploit ordering (simpler):
TreeNode lcaBST(TreeNode n, TreeNode p, TreeNode q) {
    if (p.val < n.val && q.val < n.val) return lcaBST(n.left,  p, q);
    if (p.val > n.val && q.val > n.val) return lcaBST(n.right, p, q);
    return n;  // split point → LCA
}