Time Complexity: O(n) where n is the length of the string + *
Space Complexity: O(1) - only uses a constant amount of extra space + */ public boolean areNumbersAscending(String s) { int previousNumber = 0; int currentNumber = 0; @@ -23,6 +34,7 @@ public boolean areNumbersAscending(String s) { for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); if (c == ' ') { + // End of a token - check if it was a number if (currentNumber > 0) { if (currentNumber <= previousNumber) { return false; @@ -32,9 +44,11 @@ public boolean areNumbersAscending(String s) { } } else if (c >= '0' && c <= '9') { + // Build the current number digit by digit currentNumber = currentNumber * 10 + (c - '0'); } } + // Check the last token if it's a number return currentNumber == 0 || currentNumber > previousNumber; } diff --git a/src/main/java/com/forketyfork/codingproblems/ConstructTargetArrayWithMultipleSums.java b/src/main/java/com/forketyfork/codingproblems/ConstructTargetArrayWithMultipleSums.java index 365872b..7fc66e7 100644 --- a/src/main/java/com/forketyfork/codingproblems/ConstructTargetArrayWithMultipleSums.java +++ b/src/main/java/com/forketyfork/codingproblems/ConstructTargetArrayWithMultipleSums.java @@ -1,21 +1,53 @@ package com.forketyfork.codingproblems; +/** + * You are given an array target of n integers. From a starting array arr consisting of n 1's, + * you may perform the following procedure repeatedly: + *
Time Complexity: O(n * log(max_value)) where n is the array length + *
Space Complexity: O(1) - the heap is built in-place + * + *
Algorithm: Work backwards from target to [1,1,...,1] by repeatedly: + * 1. Finding the max element (using a max heap) + * 2. Computing what it must have been before the last operation + * 3. Checking if the reconstruction is valid + */ public boolean isPossible(int[] target) { if (target.length == 1) { return target[0] == 1; } + // Calculate the initial sum long sum = 0; for (int el : target) { sum += el; } + // Build a max heap to efficiently find the largest element buildHeap(target); + // Work backwards: keep reducing the max element until we reach all 1's while (sum > target.length) { int max = target[0]; int maxChild = Math.max(target[1], outOfRange(target, 2) ? Integer.MIN_VALUE : target[2]); int diffToMaxChild = max - maxChild; long rest = sum - max; + // Optimization: instead of subtracting rest once, calculate how many times we can subtract long timesToSubtractSum = diffToMaxChild / rest; if (timesToSubtractSum == 0) { timesToSubtractSum = 1; @@ -26,15 +58,22 @@ public boolean isPossible(int[] target) { } target[0] = (int) maxUpdated; sum = rest + maxUpdated; + // Restore heap property after updating the root sinkTop(target); } return true; } + /** + * Builds a max heap from the array by bubbling up each element. + * + * @param array the array to heapify + */ private void buildHeap(int[] array) { for (int i = 0; i < array.length; i++) { int idx = i; int parentIdx = getParentIdx(idx); + // Bubble up the element to maintain heap property while (!outOfRange(array, parentIdx) && array[parentIdx] < array[idx]) { swap(array, idx, parentIdx); idx = parentIdx; @@ -43,6 +82,12 @@ private void buildHeap(int[] array) { } } + /** + * Sinks the top element down to restore the max heap property. + * Used after updating the root element. + * + * @param array the heap array + */ private void sinkTop(int[] array) { int idx = 0; int maxIdx = 0; @@ -59,6 +104,12 @@ private void sinkTop(int[] array) { } } + /** + * Calculates the parent index in a binary heap. + * + * @param idx the child index + * @return the parent index, or -1 if idx is the root + */ private int getParentIdx(int idx) { if (idx == 0) { return -1; @@ -66,14 +117,34 @@ private int getParentIdx(int idx) { return ((idx + 1) >> 1) - 1; } + /** + * Calculates the left child index in a binary heap. + * + * @param idx the parent index + * @return the left child index + */ private int getChildLeftIdx(int idx) { return ((idx + 1) << 1) - 1; } + /** + * Checks if an index is out of bounds for the array. + * + * @param array the array to check against + * @param idx the index to check + * @return true if the index is out of range, false otherwise + */ private boolean outOfRange(int[] array, int idx) { return idx < 0 || idx >= array.length; } + /** + * Swaps two elements in the array. + * + * @param array the array containing the elements + * @param idx1 the first index + * @param idx2 the second index + */ private void swap(int[] array, int idx1, int idx2) { if (idx1 == idx2) { return; diff --git a/src/main/java/com/forketyfork/codingproblems/CopyListWithRandomPointer.java b/src/main/java/com/forketyfork/codingproblems/CopyListWithRandomPointer.java index f82a2c5..8519b67 100644 --- a/src/main/java/com/forketyfork/codingproblems/CopyListWithRandomPointer.java +++ b/src/main/java/com/forketyfork/codingproblems/CopyListWithRandomPointer.java @@ -31,8 +31,24 @@ */ class CopyListWithRandomPointer { + /** + * Creates a deep copy of a linked list where each node has a random pointer. + * This solution uses an interleaving technique to avoid using extra space for a HashMap. + * + * @param head the head of the original linked list + * @return the head of the deep copied linked list + * + *
Time Complexity: O(n) where n is the number of nodes + *
Space Complexity: O(1) auxiliary space (excluding the output list) + * + *
Algorithm: + * 1. Interleave: Insert a copy of each node right after the original node + * 2. Set random pointers: For each copy, set random = original.random.next + * 3. Separate: Extract the copied nodes into a separate list + */ public RandomPointerListNode copyRandomList(RandomPointerListNode head) { + // Phase 1: Create copied nodes and interleave them with originals var p = head; while (p != null) { var newp = p.next; @@ -42,12 +58,14 @@ public RandomPointerListNode copyRandomList(RandomPointerListNode head) { p = newp; } + // Phase 2: Set random pointers for copied nodes p = head; while (p != null) { p.next.random = p.random == null ? null : p.random.next; p = p.next.next; } + // Phase 3: Separate the copied list from the original list p = head; var dummy = node(0); var curr = dummy; diff --git a/src/main/java/com/forketyfork/codingproblems/CountAndSay.java b/src/main/java/com/forketyfork/codingproblems/CountAndSay.java index cdbe93f..0d005bf 100644 --- a/src/main/java/com/forketyfork/codingproblems/CountAndSay.java +++ b/src/main/java/com/forketyfork/codingproblems/CountAndSay.java @@ -21,6 +21,15 @@ */ public class CountAndSay { + /** + * Generates the nth term of the count-and-say sequence recursively. + * + * @param n the term number (1-indexed) + * @return the nth term of the count-and-say sequence + * + *
Time Complexity: O(2^n) in the worst case, as each term can be roughly twice the length of the previous term + *
Space Complexity: O(2^n) for storing the result string, plus O(n) for recursion stack + */ public String countAndSay(int n) { if (n == 1) { return "1"; @@ -28,6 +37,15 @@ public String countAndSay(int n) { return convert(countAndSay(n - 1)); } + /** + * Converts a string by counting consecutive identical characters. + * For each group of identical characters, outputs the count followed by the character. + * + * @param string the input string to convert + * @return the converted string in count-and-say format + * + *
Example: "3322251" -> "23" (two 3's) + "32" (three 2's) + "15" (one 5) + "11" (one 1) = "23321511" + */ private String convert(String string) { var builder = new StringBuilder(); var count = 1; @@ -38,11 +56,13 @@ private String convert(String string) { count++; } else { + // Append count and character for the completed group builder.append(count).append(prev); prev = next; count = 1; } } + // Append the last group builder.append(count).append(prev); return builder.toString(); } diff --git a/src/main/java/com/forketyfork/codingproblems/DiagonalTraverse.java b/src/main/java/com/forketyfork/codingproblems/DiagonalTraverse.java index 3c8cfa2..43f5bc6 100644 --- a/src/main/java/com/forketyfork/codingproblems/DiagonalTraverse.java +++ b/src/main/java/com/forketyfork/codingproblems/DiagonalTraverse.java @@ -1,20 +1,37 @@ package com.forketyfork.codingproblems; /** - * * Given an m x n matrix mat, return an array of all the elements of the array in a diagonal order. + * The diagonal traversal alternates direction: up-right, then down-left, then up-right, etc. + * * @see LeetCode #498. Diagonal Traverse */ public class DiagonalTraverse { + /** + * Traverses the matrix diagonally, alternating between up-right and down-left directions. + * When reaching a boundary, the direction changes and the traversal continues from the edge. + * + * @param mat the input matrix + * @return an array containing all matrix elements in diagonal order + * + *
Time Complexity: O(m * n) where m and n are the dimensions of the matrix + *
Space Complexity: O(1) auxiliary space (excluding the output array) + * + *
Traversal pattern: + * - Start at (0,0) going up-right + * - When hitting top or right edge, change to down-left + * - When hitting bottom or left edge, change to up-right + * - Continue until all elements are visited + */ public int[] findDiagonalOrder(int[][] mat) { int m = mat.length; int n = mat[0].length; int[] result = new int[n * m]; - boolean up = true; - int i = 0; - int j = 0; + boolean up = true; // Direction flag: true = up-right, false = down-left + int i = 0; // Row index + int j = 0; // Column index int right = n - 1; int bottom = m - 1; @@ -22,27 +39,34 @@ public int[] findDiagonalOrder(int[][] mat) { result[k] = mat[i][j]; + // Determine next position based on current position and direction if (up && j == right) { + // Hit right edge while going up: move down and change direction up = false; i++; } else if (up && i == 0) { + // Hit top edge while going up: move right and change direction up = false; j++; } else if (!up && i == bottom) { + // Hit bottom edge while going down: move right and change direction up = true; j++; } else if (!up && j == 0) { + // Hit left edge while going down: move down and change direction up = true; i++; } else if (up) { + // Continue going up-right i--; j++; } else { + // Continue going down-left i++; j--; } diff --git a/src/main/java/com/forketyfork/codingproblems/DivideTwoIntegers.java b/src/main/java/com/forketyfork/codingproblems/DivideTwoIntegers.java index d1699d4..c238e39 100644 --- a/src/main/java/com/forketyfork/codingproblems/DivideTwoIntegers.java +++ b/src/main/java/com/forketyfork/codingproblems/DivideTwoIntegers.java @@ -1,24 +1,51 @@ package com.forketyfork.codingproblems; +/** + * Given two integers dividend and divisor, divide two integers without using multiplication, + * division, and mod operator. The integer division should truncate toward zero. + * Return the quotient after dividing dividend by divisor. + * + * @see LeetCode #29. Divide Two Integers + */ class DivideTwoIntegers { + /** + * Divides two integers using bit shifting and subtraction. + * The algorithm repeatedly doubles the divisor (via left shift) to find the largest + * multiple that fits in the dividend, then subtracts and repeats. + * + * @param dividend the number to be divided + * @param divisor the number to divide by + * @return the quotient (truncated toward zero) + * + *
Time Complexity: O(log^2(n)) where n is the dividend + *
Space Complexity: O(1) + * + *
Special case: If dividend is Integer.MIN_VALUE and divisor is -1, + * the result would overflow, so Integer.MAX_VALUE is returned instead. + */ public int divide(int dividend, int divisor) { + // Handle overflow case if (dividend == Integer.MIN_VALUE && divisor == -1) { return Integer.MAX_VALUE; } if (divisor == 1) { return dividend; } + // Use long to avoid overflow when taking absolute value of Integer.MIN_VALUE long ldividend = Math.abs((long) dividend); long ldivisor = Math.abs((long) divisor); + // Determine sign of result (positive if both have same sign) boolean sign = dividend >= 0 && divisor >= 0 || dividend < 0 && divisor < 0; long result = 0; long multiplier = 1; long shiftedDivisor = ldivisor; + // Phase 1: Shift divisor left until it exceeds dividend while (shiftedDivisor <= ldividend) { multiplier <<= 1; shiftedDivisor <<= 1; } + // Phase 2: Shift back right, subtracting when possible while (multiplier > 0) { if (ldividend >= shiftedDivisor) { ldividend -= shiftedDivisor; diff --git a/src/main/java/com/forketyfork/codingproblems/EgyptianFractions.java b/src/main/java/com/forketyfork/codingproblems/EgyptianFractions.java index 141a5f2..6472c81 100644 --- a/src/main/java/com/forketyfork/codingproblems/EgyptianFractions.java +++ b/src/main/java/com/forketyfork/codingproblems/EgyptianFractions.java @@ -2,12 +2,35 @@ import java.util.ArrayList; +/** + * Egyptian fractions are a way to represent rational numbers as a sum of unit fractions + * (fractions with numerator 1). For example, 2/3 = 1/2 + 1/6. + * This class implements the greedy algorithm to decompose a fraction into Egyptian fractions. + */ public class EgyptianFractions { + /** + * Decomposes a fraction into Egyptian fractions using the greedy algorithm. + * The algorithm repeatedly finds the largest unit fraction (1/k) that doesn't exceed + * the remaining fraction, subtracts it, and continues until the numerator becomes 0. + * + * @param num the numerator of the fraction + * @param denom the denominator of the fraction + * @return an array of denominators representing the Egyptian fraction decomposition + * + *
Time Complexity: O(num) in the worst case, but typically much faster + *
Space Complexity: O(num) for storing the result + * + *
Example: egyptian(2, 3) returns [2, 6] representing 1/2 + 1/6 = 2/3
+ */
public Integer[] egyptian(int num, int denom) {
var denominators = new ArrayList Time Complexity: O(n)
+ * Space Complexity: O(1) - only uses two variables regardless of n
+ *
+ * This satisfies the constraint of using only O(1) space, unlike recursive
+ * or memoization approaches which use O(n) space.
+ */
public int fib(int n) {
if (n < 2) {
return n;
}
- int n1 = 0;
- int n2 = 1;
+ // Keep track of only the last two Fibonacci numbers
+ int n1 = 0; // F(i-2)
+ int n2 = 1; // F(i-1)
for (int i = 2; i <= n; i++) {
- int next = n1 + n2;
- n1 = n2;
- n2 = next;
+ int next = n1 + n2; // F(i) = F(i-1) + F(i-2)
+ n1 = n2; // Shift: F(i-2) becomes F(i-1)
+ n2 = next; // Shift: F(i-1) becomes F(i)
}
return n2;
}
diff --git a/src/main/java/com/forketyfork/codingproblems/GroupAnagrams.java b/src/main/java/com/forketyfork/codingproblems/GroupAnagrams.java
index 3c605d2..8a0b255 100644
--- a/src/main/java/com/forketyfork/codingproblems/GroupAnagrams.java
+++ b/src/main/java/com/forketyfork/codingproblems/GroupAnagrams.java
@@ -15,6 +15,19 @@
*/
public class GroupAnagrams {
+ /**
+ * Groups anagrams together from an array of strings.
+ * Uses character frequency counting to identify anagrams efficiently.
+ *
+ * @param strings the input array of strings (all lowercase English letters)
+ * @return a list of lists, where each inner list contains all anagrams of a particular pattern
+ *
+ * Time Complexity: O(n * k) where n is the number of strings and k is the maximum length of a string
+ * Space Complexity: O(n * k) for storing all strings and their keys
+ *
+ * This approach is more efficient than sorting-based approaches (O(n * k * log(k)))
+ * because it uses character frequency arrays as keys.
+ */
public List Time Complexity: O(V + E) where V is the number of vertices and E is the number of edges
+ * Space Complexity: O(V) for the color array and BFS queue
+ *
+ * Algorithm: Use BFS to color the graph. If we ever need to color a vertex that's already
+ * colored with the wrong color, the graph is not bipartite.
+ */
public boolean isBipartite(int[][] graph) {
int n = graph.length;
@@ -35,9 +56,11 @@ public boolean isBipartite(int[][] graph) {
var queue = new ArrayDeque Time Complexity: O(log n) where n is the input value (number of bits)
+ * Space Complexity: O(1)
+ *
+ * Note: This handles non-positive values correctly as the loop condition is n > 0.
+ * An alternative O(1) solution would be: n > 0 && (n & (n - 1)) == 0
+ */
public boolean isPowerOfTwo(int n) {
int setBitCount = 0;
while (n > 0) {
- setBitCount += (n & 1);
- n >>= 1;
+ setBitCount += (n & 1); // Add 1 if the least significant bit is set
+ n >>= 1; // Shift right to check the next bit
}
return setBitCount == 1;
}
diff --git a/src/main/java/com/forketyfork/codingproblems/JumpGame.java b/src/main/java/com/forketyfork/codingproblems/JumpGame.java
index a4d00ef..d3afc8b 100644
--- a/src/main/java/com/forketyfork/codingproblems/JumpGame.java
+++ b/src/main/java/com/forketyfork/codingproblems/JumpGame.java
@@ -21,14 +21,29 @@
*/
public class JumpGame {
+ /**
+ * Determines if it's possible to jump from the first index to the last index.
+ * Uses a greedy approach working backwards from the end.
+ *
+ * @param nums array where nums[i] represents the maximum jump length from index i
+ * @return true if the last index can be reached, false otherwise
+ *
+ * Time Complexity: O(n) where n is the length of the array
+ * Space Complexity: O(1)
+ *
+ * Algorithm: Work right to left. Track the closest position from which we know
+ * we can reach the end. For each position i, check if we can jump to that closest position.
+ * If yes, update closest to i. If closest reaches 0, we can jump from start to end.
+ */
public boolean canJump(int[] nums) {
- int closest = nums.length - 1;
+ int closest = nums.length - 1; // Closest position from which we can reach the end
for (int i = closest - 1; i >= 0; i--) {
+ // If from position i we can reach or pass the closest reachable position
if (i + nums[i] >= closest) {
- closest = i;
+ closest = i; // Update: we can now reach the end from position i
}
}
- return closest == 0;
+ return closest == 0; // Check if we can reach the end from the start
}
}
diff --git a/src/main/java/com/forketyfork/codingproblems/JumpGame2.java b/src/main/java/com/forketyfork/codingproblems/JumpGame2.java
index 7aada5e..109bf6a 100644
--- a/src/main/java/com/forketyfork/codingproblems/JumpGame2.java
+++ b/src/main/java/com/forketyfork/codingproblems/JumpGame2.java
@@ -13,16 +13,29 @@
*/
public class JumpGame2 {
+ /**
+ * Finds the minimum number of jumps needed to reach the last index.
+ * Uses dynamic programming with memoization to avoid redundant calculations.
+ *
+ * @param nums array where nums[i] represents the maximum jump length from index i
+ * @return the minimum number of jumps to reach the last index
+ *
+ * Time Complexity: O(n * max_jump) where n is array length and max_jump is the maximum jump value
+ * Space Complexity: O(n) for the memoization cache
+ *
+ * Algorithm: Build a cache where cache[i] stores the minimum jumps needed from index i to the end.
+ * For each position, try all possible jumps and select the one requiring minimum total jumps.
+ */
public int jump(int[] nums) {
- // if the array is empty or only has one element, we don't need to jump at all
+ // If the array is empty or only has one element, we don't need to jump at all
if (nums.length <= 1) {
return 0;
}
- // cache[i] - how many steps do you need to get to the last element from the element i.
- // Initialized with -1, which means that this value is not yet calculated.
- // The last element is initialized with 0, as it takes 0 jumps to get to the last element from itself.
+ // cache[i] - minimum number of jumps needed to reach the end from index i
+ // Initialized with -1, which means this value hasn't been calculated yet
+ // The last element is initialized with 0 (no jumps needed from last to last)
int[] cache = new int[nums.length];
Arrays.fill(cache, -1);
cache[cache.length - 1] = 0;
@@ -30,28 +43,44 @@ public int jump(int[] nums) {
return jump(nums, cache, 0);
}
+ /**
+ * Helper method that retrieves the minimum jumps from cache or calculates it.
+ *
+ * @param nums the input array
+ * @param cache the memoization cache
+ * @param start the starting index
+ * @return the minimum number of jumps from start to the end
+ */
private int jump(int[] nums, int[] cache, int start) {
- // check if we already calculated the step value for this element
+ // Check if we already calculated the step value for this element
if (cache[start] == -1) {
cache[start] = calculateSteps(nums, cache, start);
}
return cache[start];
}
+ /**
+ * Calculates the minimum number of jumps from a given position to the end.
+ *
+ * @param nums the input array
+ * @param cache the memoization cache
+ * @param start the starting index
+ * @return the minimum number of jumps from start to the end
+ */
private int calculateSteps(int[] nums, int[] cache, int start) {
int jumpSize = nums[start];
- // if we can immediately jump to the last element from this one, return 1
+ // If we can immediately jump to or past the last element, return 1
if (start + jumpSize >= nums.length - 1) {
return 1;
}
else {
int steps = Integer.MAX_VALUE;
- // find the minimum jump path from all elements that are reachable from the current one
+ // Find the minimum jump path from all positions reachable from current one
for (int i = 1; i <= jumpSize; i++) {
steps = Math.min(steps, jump(nums, cache, start + i));
}
- // If there is a path, adding 1 to it (jump from the current element),
- // otherwise return max value, meaning there's no path.
+ // If there is a valid path, add 1 for the current jump
+ // Otherwise return MAX_VALUE to indicate no path exists
if (steps != Integer.MAX_VALUE) {
steps++;
}
diff --git a/src/main/java/com/forketyfork/codingproblems/LRUCache.java b/src/main/java/com/forketyfork/codingproblems/LRUCache.java
index 92f584e..8796cd0 100644
--- a/src/main/java/com/forketyfork/codingproblems/LRUCache.java
+++ b/src/main/java/com/forketyfork/codingproblems/LRUCache.java
@@ -18,6 +18,10 @@
*/
public class LRUCache {
+ /**
+ * Internal doubly-linked list node used to maintain access order.
+ * The most recently used nodes are kept at the tail of the list.
+ */
static class Node {
int key;
@@ -25,6 +29,14 @@ static class Node {
Node prev;
Node next;
+ /**
+ * Creates a new node with the specified key-value pair and links.
+ *
+ * @param key the cache key
+ * @param value the cache value
+ * @param prev the previous node in the list
+ * @param next the next node in the list
+ */
public Node(int key, int value, Node prev, Node next) {
this.key = key;
this.value = value;
@@ -40,19 +52,39 @@ public Node(int key, int value, Node prev, Node next) {
private final Map Time Complexity: O(1)
+ * Space Complexity: O(1)
+ */
public LRUCache(int capacity) {
this.capacity = capacity;
}
+ /**
+ * Inserts or updates a key-value pair in the cache. If the key already exists,
+ * its value is updated and it's marked as most recently used. If the cache is
+ * at capacity, the least recently used item is evicted before insertion.
+ *
+ * @param key the key to insert or update
+ * @param value the value to associate with the key
+ *
+ * Time Complexity: O(1) average case (HashMap operations)
+ * Space Complexity: O(1)
+ */
public void put(int key, int value) {
- // if a node exists, just bump it and update its value
+ // If a node exists, bump it to the end (most recent) and update its value
Node existingNode = getNode(key);
if (existingNode != null) {
existingNode.value = value;
return;
}
if (size == capacity) {
- // pop the node from the beginning of the list
+ // Evict the least recently used node (first node after head)
Node removedNode = head.next;
head.next = removedNode.next;
if (head.next != null) {
@@ -64,12 +96,23 @@ public void put(int key, int value) {
size++;
}
+ // Add new node at the tail (most recently used position)
var newNode = new Node(key, value, tail, null);
tail.next = newNode;
tail = newNode;
index.put(key, newNode);
}
+ /**
+ * Retrieves the value associated with the given key. If the key exists,
+ * it's marked as most recently used by moving it to the tail of the list.
+ *
+ * @param key the key to look up
+ * @return the value associated with the key, or -1 if the key doesn't exist
+ *
+ * Time Complexity: O(1) average case (HashMap lookup)
+ * Space Complexity: O(1)
+ */
public int get(int key) {
Node node = getNode(key);
if (node == null) {
@@ -78,10 +121,17 @@ public int get(int key) {
return node.value;
}
+ /**
+ * Internal helper method that retrieves a node and moves it to the tail
+ * (most recently used position) if it's not already there.
+ *
+ * @param key the key to look up
+ * @return the node associated with the key, or null if not found
+ */
private Node getNode(int key) {
Node node = index.get(key);
if (node != null && node.next != null) {
- // bump the node to the front of the list
+ // Move the node to the tail (most recently used position)
node.prev.next = node.next;
node.next.prev = node.prev;
tail.next = node;
diff --git a/src/main/java/com/forketyfork/codingproblems/LargestSumOfNonAdjacent.java b/src/main/java/com/forketyfork/codingproblems/LargestSumOfNonAdjacent.java
index fc3c6ca..e81ede5 100644
--- a/src/main/java/com/forketyfork/codingproblems/LargestSumOfNonAdjacent.java
+++ b/src/main/java/com/forketyfork/codingproblems/LargestSumOfNonAdjacent.java
@@ -22,11 +22,28 @@
*/
public class LargestSumOfNonAdjacent {
+ /**
+ * Finds the largest sum of non-adjacent numbers in an array using dynamic programming.
+ * For each element, we decide whether to include it or not based on maximum achievable sum.
+ *
+ * @param array the input array of integers (can contain 0 or negative values)
+ * @return the largest sum of non-adjacent numbers
+ *
+ * Time Complexity: O(n) where n is the length of the array
+ * Space Complexity: O(1) - only uses two variables to track previous states
+ *
+ * Algorithm: At each position, the maximum sum is either:
+ * 1. The current element value alone
+ * 2. The max from previous position (excluding current)
+ * 3. Max from two positions back plus current element
+ * Uses long to prevent integer overflow during calculations.
+ */
public int largestSumOfNonAdjacent(int[] array) {
- long prevmax = Integer.MIN_VALUE;
- long max = Integer.MIN_VALUE;
+ long prevmax = Integer.MIN_VALUE; // Max sum ending 2 positions ago
+ long max = Integer.MIN_VALUE; // Max sum ending 1 position ago
for (int value : array) {
+ // Consider three options for current position
long newmax = maxOfThree(value, max, prevmax + value);
prevmax = max;
max = newmax;
@@ -34,6 +51,14 @@ public int largestSumOfNonAdjacent(int[] array) {
return (int) max;
}
+ /**
+ * Returns the maximum of three long values.
+ *
+ * @param i1 first value
+ * @param i2 second value
+ * @param i3 third value
+ * @return the maximum of the three values
+ */
private long maxOfThree(long i1, long i2, long i3) {
return Math.max(i1, Math.max(i2, i3));
}
diff --git a/src/main/java/com/forketyfork/codingproblems/MaximumDepthBinaryTree.java b/src/main/java/com/forketyfork/codingproblems/MaximumDepthBinaryTree.java
index 00a51df..e042802 100644
--- a/src/main/java/com/forketyfork/codingproblems/MaximumDepthBinaryTree.java
+++ b/src/main/java/com/forketyfork/codingproblems/MaximumDepthBinaryTree.java
@@ -12,12 +12,22 @@
*/
public class MaximumDepthBinaryTree {
+ /**
+ * Calculates the maximum depth of a binary tree using recursion.
+ * The depth is the number of nodes along the longest path from root to leaf.
+ *
+ * @param root the root of the binary tree
+ * @return the maximum depth of the tree
+ *
+ * Time Complexity: O(n) where n is the number of nodes in the tree
+ * Space Complexity: O(h) where h is the height of the tree (recursion stack)
+ */
public int maxDepth(TreeNode root) {
- // base case when the tree is empty
+ // Base case: empty tree has depth 0
if (root == null) {
return 0;
}
- // recursive call with the left and the right part of the tree
+ // Recursive case: 1 (current node) + max depth of left or right subtree
return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}
diff --git a/src/main/java/com/forketyfork/codingproblems/MergeSortedArray.java b/src/main/java/com/forketyfork/codingproblems/MergeSortedArray.java
index 3ab8923..30b85c3 100644
--- a/src/main/java/com/forketyfork/codingproblems/MergeSortedArray.java
+++ b/src/main/java/com/forketyfork/codingproblems/MergeSortedArray.java
@@ -14,18 +14,36 @@
*/
public class MergeSortedArray {
+ /**
+ * Merges two sorted arrays into one sorted array in-place.
+ * Works backwards from the end to avoid overwriting elements in nums1.
+ *
+ * @param nums1 the first sorted array with size m+n (first m elements are valid, last n are zeros)
+ * @param m the number of valid elements in nums1
+ * @param nums2 the second sorted array with size n
+ * @param n the number of elements in nums2
+ *
+ * Time Complexity: O(m + n) where m and n are the sizes of the two arrays
+ * Space Complexity: O(1) - merges in-place without extra space
+ *
+ * Algorithm: Use three pointers - p1 (end of valid nums1), p2 (end of nums2),
+ * and p (end of merged array). Fill from right to left, always picking the larger element.
+ */
public void merge(int[] nums1, int m, int[] nums2, int n) {
int p1 = m - 1, p2 = n - 1;
int p = nums1.length - 1;
while (p1 >= 0 || p2 >= 0) {
int el;
if (p1 == -1) {
+ // All nums1 elements processed, take from nums2
el = nums2[p2--];
}
else if (p2 == -1) {
+ // All nums2 elements processed, take from nums1
el = nums1[p1--];
}
else {
+ // Compare and take the larger element
int e1 = nums1[p1], e2 = nums2[p2];
if (e1 >= e2) {
el = e1;
diff --git a/src/main/java/com/forketyfork/codingproblems/MergeTwoBinaryTrees.java b/src/main/java/com/forketyfork/codingproblems/MergeTwoBinaryTrees.java
index a825333..eae3572 100644
--- a/src/main/java/com/forketyfork/codingproblems/MergeTwoBinaryTrees.java
+++ b/src/main/java/com/forketyfork/codingproblems/MergeTwoBinaryTrees.java
@@ -18,6 +18,22 @@
*/
public class MergeTwoBinaryTrees {
+ /**
+ * Merges two binary trees by summing values of overlapping nodes.
+ * If only one tree has a node at a position, that node is used directly.
+ *
+ * @param tree1 the first binary tree
+ * @param tree2 the second binary tree
+ * @return a new binary tree representing the merged result
+ *
+ * Time Complexity: O(min(n1, n2)) where n1 and n2 are the number of nodes in each tree
+ * Space Complexity: O(min(h1, h2)) for recursion stack, where h1 and h2 are tree heights
+ *
+ * Algorithm: Recursively traverse both trees in parallel. At each position:
+ * - If both nodes exist: create new node with sum of values
+ * - If only one exists: return that node
+ * - If neither exists: return null
+ */
public TreeNode mergeTrees(TreeNode tree1, TreeNode tree2) {
if (tree1 == null && tree2 == null) {
@@ -32,6 +48,7 @@ public TreeNode mergeTrees(TreeNode tree1, TreeNode tree2) {
return tree1;
}
+ // Both nodes exist: create new node with sum and recursively merge children
return node(tree1.val + tree2.val,
mergeTrees(tree1.left, tree2.left),
mergeTrees(tree1.right, tree2.right));
diff --git a/src/main/java/com/forketyfork/codingproblems/MinimumFunctionCalls.java b/src/main/java/com/forketyfork/codingproblems/MinimumFunctionCalls.java
index e31595b..c58504b 100644
--- a/src/main/java/com/forketyfork/codingproblems/MinimumFunctionCalls.java
+++ b/src/main/java/com/forketyfork/codingproblems/MinimumFunctionCalls.java
@@ -14,22 +14,40 @@
*/
public class MinimumFunctionCalls {
+ /**
+ * Calculates the minimum number of operations (additions and multiplications) needed
+ * to create the target array from an array of all zeros. Works backwards by analyzing
+ * the binary representation of target numbers.
+ *
+ * @param nums the target array of non-negative integers
+ * @return the minimum number of operations required
+ *
+ * Time Complexity: O(n * log(max_num)) where n is array length and max_num is the largest value
+ * Space Complexity: O(1)
+ *
+ * Algorithm (working backwards from target):
+ * - Each 1 bit in a number requires one addition operation
+ * - The number of right shifts (multiplications when going forward) is the bit length - 1
+ * - Total ops = sum of all 1-bits + maximum bit-length across all numbers - 1
+ */
public int minOperations(int[] nums) {
int maxMultiplications = 0;
int additions = 0;
for (int num : nums) {
- int multiplications = -1;
+ int multiplications = -1; // Start at -1 to account for the initial value
while (num >= 1) {
- multiplications++;
- additions += (num & 1);
- num >>= 1;
+ multiplications++; // Count the number of bits (positions)
+ additions += (num & 1); // Count 1-bits (addition operations)
+ num >>= 1; // Shift right (division by 2, reverse of multiplication)
}
if (multiplications > maxMultiplications) {
maxMultiplications = multiplications;
}
}
+ // Multiplication operations are global (affect all elements),
+ // so we only need as many as required for the element with most bits
return maxMultiplications + additions;
}
diff --git a/src/main/java/com/forketyfork/codingproblems/MostFrequentSubtreeSum.java b/src/main/java/com/forketyfork/codingproblems/MostFrequentSubtreeSum.java
index 792f8ba..a96133d 100644
--- a/src/main/java/com/forketyfork/codingproblems/MostFrequentSubtreeSum.java
+++ b/src/main/java/com/forketyfork/codingproblems/MostFrequentSubtreeSum.java
@@ -18,9 +18,22 @@
*/
public class MostFrequentSubtreeSum {
+ /**
+ * Finds the most frequent subtree sum(s) in a binary tree.
+ * If there's a tie, returns all sums with the highest frequency.
+ *
+ * @param root the root of the binary tree
+ * @return an array of the most frequent subtree sums
+ *
+ * Time Complexity: O(n) where n is the number of nodes
+ * Space Complexity: O(n) for the HashMap storing counts and recursion stack
+ */
public int[] findFrequentTreeSum(TreeNode root) {
Map Time Complexity: O(n^2) where n is numRows (total number of elements generated)
+ * Space Complexity: O(n^2) for storing the triangle, plus O(n) recursion stack
+ */
public List Time Complexity: O(n) where n is the number of digits
+ * Space Complexity: O(1) in most cases, O(n) when overflow occurs (e.g., 999 -> 1000)
+ *
+ * Algorithm: Walk from right to left. Add 1 to rightmost digit. If < 10, done.
+ * Otherwise, handle carry by setting digit to 0 and continuing left. If all digits
+ * are 9, create new array with leading 1.
+ */
public int[] plusOne(int[] digits) {
- // walking the array from right to left, searching for the first digit which is not 9
- // this digit can be increased without carry
+ // Walk the array from right to left, searching for the first digit which is not 9
+ // This digit can be increased without carry
for (int i = digits.length - 1; i >= 0; i--) {
int digitValue = digits[i] + 1;
diff --git a/src/main/java/com/forketyfork/codingproblems/Problem2.java b/src/main/java/com/forketyfork/codingproblems/Problem2.java
index f511cff..6eb6688 100644
--- a/src/main/java/com/forketyfork/codingproblems/Problem2.java
+++ b/src/main/java/com/forketyfork/codingproblems/Problem2.java
@@ -15,12 +15,28 @@
*/
public class Problem2 {
+ /**
+ * Calculates the product of all elements except the one at each index using division.
+ * This solution computes the total product of all elements, then divides by each element
+ * to get the result at that index.
+ *
+ * @param array the input array of integers
+ * @return a new array where each element at index i is the product of all elements except array[i]
+ *
+ * Time Complexity: O(n) where n is the length of the array
+ * Space Complexity: O(n) for the result array (O(1) auxiliary space)
+ *
+ * Note: This approach assumes no zero values in the input array. If the array contains
+ * zeros, this method will throw an ArithmeticException when dividing by zero.
+ */
public int[] calculate(int[] array) {
int[] result = new int[array.length];
+ // Calculate the product of all elements
int mul = 1;
for (int value : array) {
mul *= value;
}
+ // For each position, divide the total product by the element at that position
for (int i = 0; i < array.length; i++) {
result[i] = mul / array[i];
}
diff --git a/src/main/java/com/forketyfork/codingproblems/Problem2WithoutDivision.java b/src/main/java/com/forketyfork/codingproblems/Problem2WithoutDivision.java
index a164703..59ff1ed 100644
--- a/src/main/java/com/forketyfork/codingproblems/Problem2WithoutDivision.java
+++ b/src/main/java/com/forketyfork/codingproblems/Problem2WithoutDivision.java
@@ -15,13 +15,31 @@
*/
public class Problem2WithoutDivision {
+ /**
+ * Calculates the product of all elements except the one at each index WITHOUT using division.
+ * This solution uses two passes: a forward pass to accumulate products of all elements
+ * to the left, and a backward pass to multiply by products of all elements to the right.
+ *
+ * @param array the input array of integers
+ * @return a new array where each element at index i is the product of all elements except array[i]
+ *
+ * Time Complexity: O(n) where n is the length of the array
+ * Space Complexity: O(n) for the result array (O(1) auxiliary space)
+ *
+ * Algorithm:
+ * 1. Forward pass: result[i] = product of all elements before i
+ * 2. Backward pass: result[i] *= product of all elements after i
+ * This gives result[i] = product of all elements except array[i]
+ */
public int[] calculate(int[] array) {
int[] result = new int[array.length];
+ // Forward pass: accumulate products of elements to the left
int mul = 1;
for (int i = 0; i < array.length; i++) {
result[i] = mul;
mul *= array[i];
}
+ // Backward pass: multiply by products of elements to the right
mul = 1;
for (int i = array.length - 1; i >= 0; i--) {
result[i] *= mul;
diff --git a/src/main/java/com/forketyfork/codingproblems/Problem339.java b/src/main/java/com/forketyfork/codingproblems/Problem339.java
index 2c8eda3..c4e622f 100644
--- a/src/main/java/com/forketyfork/codingproblems/Problem339.java
+++ b/src/main/java/com/forketyfork/codingproblems/Problem339.java
@@ -14,10 +14,23 @@
*/
public class Problem339 {
+ /**
+ * Determines if there are three entries in the array that add up to the specified sum k.
+ * The algorithm reduces the 3-sum problem to multiple 2-sum problems by fixing one element
+ * at a time and searching for two other elements that sum to the remaining target.
+ *
+ * @param array the input array of integers
+ * @param k the target sum
+ * @return true if three elements exist that sum to k, false otherwise
+ *
+ * Time Complexity: O(n^2) where n is the length of the array
+ * Space Complexity: O(n) for the HashSet used in the 2-sum subroutine
+ */
public boolean sum3(int[] array, int k) {
if (array.length < 3) {
return false;
}
+ // Fix each element and look for a 2-sum in the remaining elements
for (int i = 0; i < array.length; i++) {
int diff = k - array[i];
if (sum2(array, diff, i)) {
@@ -27,12 +40,25 @@ public boolean sum3(int[] array, int k) {
return false;
}
+ /**
+ * Helper method that determines if two elements in the array (excluding the element
+ * at excludeIdx) sum to k. Uses a HashSet to achieve linear time complexity.
+ *
+ * @param array the input array of integers
+ * @param k the target sum for two elements
+ * @param excludeIdx the index to exclude from consideration
+ * @return true if two elements (excluding excludeIdx) sum to k, false otherwise
+ *
+ * Time Complexity: O(n) where n is the length of the array
+ * Space Complexity: O(n) for the HashSet
+ */
private boolean sum2(int[] array, int k, int excludeIdx) {
Set Time Complexity: O(n) where n is the length of the array. Although there's a nested
+ * while loop, each element is placed in its correct position at most once, so the total
+ * number of swaps is bounded by n.
+ * Space Complexity: O(1) - the algorithm modifies the input array in-place
+ *
+ * Algorithm:
+ * 1. For each position, attempt to place the value at its "correct" index (value-1)
+ * 2. Chain the displaced values to their correct positions
+ * 3. Scan the array to find the first missing positive integer
+ */
public int calculate(int[] array) {
+ // Phase 1: Place each positive integer at its correct position
for (int i = 0; i < array.length; i++) {
int value = array[i];
array[i] = 0;
+ // Chain placement: keep moving values to their correct positions
while (value > 0 && value <= array.length && array[value - 1] != value) {
int newValue = array[value - 1];
array[value - 1] = value;
@@ -24,11 +44,13 @@ public int calculate(int[] array) {
}
}
+ // Phase 2: Find the first missing positive integer
for (int i = 0; i < array.length; i++) {
if (array[i] <= 0) {
return i + 1;
}
}
+ // If all positions 1..n are filled, return n+1
return array.length + 1;
}
diff --git a/src/main/java/com/forketyfork/codingproblems/Problem8.java b/src/main/java/com/forketyfork/codingproblems/Problem8.java
index 2d317f2..1c01a90 100644
--- a/src/main/java/com/forketyfork/codingproblems/Problem8.java
+++ b/src/main/java/com/forketyfork/codingproblems/Problem8.java
@@ -27,15 +27,39 @@ public class Problem8 {
private int count;
+ /**
+ * Counts the total number of unival subtrees in the given binary tree.
+ * A unival subtree is a subtree where all nodes have the same value.
+ *
+ * @param node the root of the binary tree
+ * @return the total number of unival subtrees
+ *
+ * Time Complexity: O(n) where n is the number of nodes in the tree
+ * Space Complexity: O(h) where h is the height of the tree (recursion stack)
+ */
public int countUnivalTrees(TreeNode node) {
isUnivalTree(node);
return count;
}
+ /**
+ * Recursively checks if a subtree is a unival tree (all nodes have the same value).
+ * This method performs a post-order traversal, checking children before the parent.
+ * If a subtree is unival, it increments the global count.
+ *
+ * @param node the root of the subtree to check
+ * @return true if the subtree rooted at node is a unival tree, false otherwise
+ *
+ * A subtree is unival if:
+ * 1. Both left and right subtrees are unival (or null)
+ * 2. The left child (if exists) has the same value as the node
+ * 3. The right child (if exists) has the same value as the node
+ */
public boolean isUnivalTree(TreeNode node) {
if (node == null) {
return true;
}
+ // Post-order traversal: check children first
boolean result = isUnivalTree(node.left)
&& isUnivalTree(node.right)
&& (node.left == null || node.left.val == node.val)
diff --git a/src/main/java/com/forketyfork/codingproblems/SameTree.java b/src/main/java/com/forketyfork/codingproblems/SameTree.java
index c568916..138edd2 100644
--- a/src/main/java/com/forketyfork/codingproblems/SameTree.java
+++ b/src/main/java/com/forketyfork/codingproblems/SameTree.java
@@ -4,13 +4,23 @@
/**
* Given the roots of two binary trees p and q, write a function to check if they are the same or not.
- *
- * Two binary trees are considered the same if they are structurally identical, and the nodes have the same
+ * Two binary trees are considered the same if they are structurally identical and the nodes have the same values.
*
- * @see LeetCode #100
+ * @see LeetCode #100. Same Tree
*/
public class SameTree {
+ /**
+ * Checks if two binary trees are identical using recursive comparison.
+ * Trees are identical if they have the same structure and node values.
+ *
+ * @param p the root of the first tree
+ * @param q the root of the second tree
+ * @return true if the trees are identical, false otherwise
+ *
+ * Time Complexity: O(n) where n is the number of nodes (we visit each node once)
+ * Space Complexity: O(h) where h is the height (recursion stack)
+ */
public boolean isSameTree(TreeNode p, TreeNode q) {
return (p == null && q == null)
|| (p != null && q != null
diff --git a/src/main/java/com/forketyfork/codingproblems/ThreeSum.java b/src/main/java/com/forketyfork/codingproblems/ThreeSum.java
index 83b774f..aea7fd5 100644
--- a/src/main/java/com/forketyfork/codingproblems/ThreeSum.java
+++ b/src/main/java/com/forketyfork/codingproblems/ThreeSum.java
@@ -7,11 +7,27 @@
/**
* Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that
* i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.
- *
- * Notice that the solution set must not contain duplicate triplets.
+ * The solution set must not contain duplicate triplets.
+ *
+ * @see LeetCode #15. 3Sum
*/
public class ThreeSum {
+ /**
+ * Finds all unique triplets in the array that sum to zero.
+ * Uses sorting and two-pointer technique to achieve O(n^2) complexity.
+ *
+ * @param nums the input array of integers
+ * @return a list of all unique triplets that sum to zero
+ *
+ * Time Complexity: O(n^2) where n is the length of the array
+ * Space Complexity: O(1) auxiliary space (excluding output), O(log n) for sorting
+ *
+ * Algorithm:
+ * 1. Sort the array
+ * 2. Fix the first element and use two pointers for the remaining two
+ * 3. Skip duplicates to avoid duplicate triplets
+ */
public List Time Complexity: O(n)
+ * Space Complexity: O(n) for the array (could be optimized to O(1) with rolling variables)
+ */
public int tribonacci(int n) {
if (n == 0) {
return 0;
diff --git a/src/main/java/com/forketyfork/codingproblems/Trie.java b/src/main/java/com/forketyfork/codingproblems/Trie.java
index eb74e58..09461de 100644
--- a/src/main/java/com/forketyfork/codingproblems/Trie.java
+++ b/src/main/java/com/forketyfork/codingproblems/Trie.java
@@ -22,31 +22,51 @@ public class Trie {
private Trie[] children = new Trie[26];
/**
- * Initialize your data structure here.
+ * Initializes the Trie data structure with an empty root node.
+ * Each node can have up to 26 children (one for each lowercase letter).
+ *
+ * Time Complexity: O(1)
+ * Space Complexity: O(1)
*/
public Trie() {
}
/**
- * Inserts a word into the trie.
+ * Inserts a word into the trie. The method recursively traverses the trie,
+ * creating new nodes as needed for each character in the word.
+ *
+ * @param word the word to insert (must contain only lowercase letters a-z)
+ *
+ * Time Complexity: O(n) where n is the length of the word
+ * Space Complexity: O(n) for the recursive call stack, plus O(n) for new nodes if the word doesn't share prefixes
*/
public void insert(String word) {
if (word.isEmpty()) {
+ // Mark this node as the end of a complete word
this.end = true;
}
else {
+ // Calculate the index for the first character (a=0, b=1, ..., z=25)
int idx = word.charAt(0) - 'a';
if (children[idx] == null) {
var trie = new Trie();
children[idx] = trie;
}
+ // Recursively insert the rest of the word
children[idx].insert(word.substring(1));
}
}
/**
- * Returns if the word is in the trie.
+ * Searches for a complete word in the trie. A word is considered to exist only if
+ * it was previously inserted and the end marker is set at the final character's node.
+ *
+ * @param word the word to search for (must contain only lowercase letters a-z)
+ * @return true if the word exists in the trie, false otherwise
+ *
+ * Time Complexity: O(n) where n is the length of the word
+ * Space Complexity: O(n) for the recursive call stack
*/
public boolean search(String word) {
if (word.isEmpty()) {
@@ -57,7 +77,14 @@ public boolean search(String word) {
}
/**
- * Returns if there is any word in the trie that starts with the given prefix.
+ * Checks if there is any word in the trie that starts with the given prefix.
+ * Unlike search(), this method doesn't require the prefix to be a complete word.
+ *
+ * @param prefix the prefix to search for (must contain only lowercase letters a-z)
+ * @return true if any word in the trie starts with the given prefix, false otherwise
+ *
+ * Time Complexity: O(n) where n is the length of the prefix
+ * Space Complexity: O(n) for the recursive call stack
*/
public boolean startsWith(String prefix) {
if (prefix.isEmpty()) {
diff --git a/src/main/java/com/forketyfork/codingproblems/TwoSum.java b/src/main/java/com/forketyfork/codingproblems/TwoSum.java
index 6c31d39..874a6e2 100644
--- a/src/main/java/com/forketyfork/codingproblems/TwoSum.java
+++ b/src/main/java/com/forketyfork/codingproblems/TwoSum.java
@@ -13,14 +13,30 @@
*/
public class TwoSum {
+ /**
+ * Finds two numbers in the array that add up to the target.
+ * Uses a HashMap for O(1) lookups to achieve linear time complexity.
+ *
+ * @param nums the array of integers
+ * @param target the target sum
+ * @return an array containing the indices of the two numbers that add up to target
+ *
+ * Time Complexity: O(n) where n is the length of the array
+ * Space Complexity: O(n) for the HashMap
+ *
+ * Algorithm: For each element, check if (target - element) exists in the HashMap.
+ * If yes, we found our pair. If no, add the current element to the HashMap.
+ */
public int[] twoSum(int[] nums, int target) {
Map Time Complexity: O(n) where n is the length of the array
+ * Space Complexity: O(n) for the HashSet
+ *
+ * This is the bonus solution that does it in one pass.
+ */
public boolean check(int target, int[] array) {
var seen = new HashSet Time Complexity: O(n + m) where n and m are the lengths of the two strings
+ * Space Complexity: O(1) - uses fixed-size array of 26 elements
+ *
+ * Algorithm: Count character frequencies in s (increment), then decrement
+ * for characters in t. If all counts are zero at the end, they're anagrams.
+ */
public boolean isAnagram(String s, String t) {
char[] chars = new char[26];
+ // Increment count for each character in s
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
chars[c - 'a']++;
}
+ // Decrement count for each character in t
for (int i = 0; i < t.length(); i++) {
char c = t.charAt(i);
chars[c - 'a']--;
}
+ // Check if all counts are zero (or negative, meaning extra chars in t)
for (char aChar : chars) {
- if (aChar > 0) {
+ if (aChar != 0) {
return false;
}
}
diff --git a/src/main/java/com/forketyfork/codingproblems/ValidPalindrome.java b/src/main/java/com/forketyfork/codingproblems/ValidPalindrome.java
index b75c8db..21b5d08 100644
--- a/src/main/java/com/forketyfork/codingproblems/ValidPalindrome.java
+++ b/src/main/java/com/forketyfork/codingproblems/ValidPalindrome.java
@@ -9,9 +9,19 @@
*/
class ValidPalindrome {
+ /**
+ * Checks if a string is a palindrome, considering only alphanumeric characters and ignoring case.
+ * Uses two-pointer technique for O(1) space complexity.
+ *
+ * @param s the string to check
+ * @return true if the string is a palindrome, false otherwise
+ *
+ * Time Complexity: O(n) where n is the length of the string
+ * Space Complexity: O(1)
+ */
public boolean isPalindrome(String s) {
- // start with two pointers to the leftmost and the rightmost character
+ // Start with two pointers to the leftmost and rightmost character
int p1 = 0, p2 = s.length() - 1;
while (p1 < p2) {
@@ -37,14 +47,24 @@ else if (toLowerCase(c1) == toLowerCase(c2)) {
return true;
}
- // we can use !Character.isNumber(c) && !Character.isLetter(c) instead,
- // but since the character set is limited to ASCII, we can implement it in a more performant way
+ /**
+ * Checks if a character is not alphanumeric using ASCII bounds.
+ * More performant than Character.isLetter/isDigit for ASCII-only strings.
+ *
+ * @param c the character to check
+ * @return true if not alphanumeric, false otherwise
+ */
private boolean isNotAlphanumeric(char c) {
return (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && (c < '0' || c > '9');
}
- // we can use Character.toLowerCase(c) instead, but since the character is limited to ASCII,
- // we can implement it in a more performant way
+ /**
+ * Converts a character to lowercase using ASCII arithmetic.
+ * More performant than Character.toLowerCase for ASCII-only strings.
+ *
+ * @param c the character to convert
+ * @return the lowercase version of the character
+ */
private char toLowerCase(char c) {
if (c >= 'A' && c <= 'Z') {
return (char) (c + 32); // c - 'A' + 'a'
diff --git a/src/main/java/com/forketyfork/codingproblems/structures/ListNode.java b/src/main/java/com/forketyfork/codingproblems/structures/ListNode.java
index 78cffec..b628f11 100644
--- a/src/main/java/com/forketyfork/codingproblems/structures/ListNode.java
+++ b/src/main/java/com/forketyfork/codingproblems/structures/ListNode.java
@@ -1,10 +1,21 @@
package com.forketyfork.codingproblems.structures;
+/**
+ * A singly-linked list node used in various list-based coding problems.
+ * Contains an integer value and a pointer to the next node.
+ */
public class ListNode {
public ListNode next;
public int val;
+ /**
+ * Creates a new list node with the specified value and next pointer.
+ *
+ * @param val the integer value for the node
+ * @param next the next node in the list (can be null)
+ * @return a new ListNode instance
+ */
public static ListNode node(int val, ListNode next) {
var node = new ListNode();
node.val = val;
@@ -12,12 +23,25 @@ public static ListNode node(int val, ListNode next) {
return node;
}
+ /**
+ * Creates a new list node with the specified value and null next pointer.
+ *
+ * @param val the integer value for the node
+ * @return a new ListNode instance with null next
+ */
public static ListNode node(int val) {
var node = new ListNode();
node.val = val;
return node;
}
+ /**
+ * Creates a linked list from an array of integers.
+ * Convenience method for testing and initialization.
+ *
+ * @param array the values to create the linked list from
+ * @return the head of the newly created linked list
+ */
public static ListNode from(int... array) {
var dummy = new ListNode();
var current = dummy;
@@ -28,6 +52,13 @@ public static ListNode from(int... array) {
return dummy.next;
}
+ /**
+ * Checks if two linked lists are equal (same values in same order).
+ * Uses recursive comparison.
+ *
+ * @param object the object to compare with
+ * @return true if the lists are equal, false otherwise
+ */
@Override
public boolean equals(Object object) {
if (!(object instanceof ListNode head2)) {
@@ -46,6 +77,12 @@ public boolean equals(Object object) {
return head1.next.equals(head2.next);
}
+ /**
+ * Returns a string representation of the linked list.
+ * Format: "[ val1 val2 val3 ... ]"
+ *
+ * @return string representation of the list
+ */
@Override
public String toString() {
var head = this;
diff --git a/src/main/java/com/forketyfork/codingproblems/structures/RandomPointerListNode.java b/src/main/java/com/forketyfork/codingproblems/structures/RandomPointerListNode.java
index 604c0c5..2570c99 100644
--- a/src/main/java/com/forketyfork/codingproblems/structures/RandomPointerListNode.java
+++ b/src/main/java/com/forketyfork/codingproblems/structures/RandomPointerListNode.java
@@ -1,11 +1,23 @@
package com.forketyfork.codingproblems.structures;
+/**
+ * A linked list node with an additional random pointer.
+ * Used in problems involving deep copying of complex linked list structures.
+ */
public class RandomPointerListNode {
public RandomPointerListNode next;
public int val;
public RandomPointerListNode random;
+ /**
+ * Creates a new node with value, next pointer, and random pointer.
+ *
+ * @param val the integer value for the node
+ * @param next the next node in the list (can be null)
+ * @param random a random pointer to any node in the list (can be null)
+ * @return a new RandomPointerListNode instance
+ */
public static RandomPointerListNode node(int val, RandomPointerListNode next, RandomPointerListNode random) {
var node = new RandomPointerListNode();
node.val = val;
@@ -14,12 +26,25 @@ public static RandomPointerListNode node(int val, RandomPointerListNode next, Ra
return node;
}
+ /**
+ * Creates a new node with just a value (null next and random pointers).
+ *
+ * @param val the integer value for the node
+ * @return a new RandomPointerListNode instance
+ */
public static RandomPointerListNode node(int val) {
var node = new RandomPointerListNode();
node.val = val;
return node;
}
+ /**
+ * Creates a linked list from an array of integers (without random pointers).
+ * Convenience method for testing and initialization.
+ *
+ * @param array the values to create the linked list from
+ * @return the head of the newly created linked list
+ */
public static RandomPointerListNode from(int... array) {
var dummy = new RandomPointerListNode();
var current = dummy;
@@ -30,6 +55,13 @@ public static RandomPointerListNode from(int... array) {
return dummy.next;
}
+ /**
+ * Checks if two linked lists with random pointers are equal.
+ * Compares both the sequential structure and random pointer relationships.
+ *
+ * @param object the object to compare with
+ * @return true if the lists are equal, false otherwise
+ */
@Override
public boolean equals(Object object) {
if (!(object instanceof RandomPointerListNode head2)) {
@@ -54,6 +86,13 @@ public boolean equals(Object object) {
return head1.next.equals(head2.next) && head1.random.equals(head2.random);
}
+ /**
+ * Returns a string representation of the linked list (sequential values only).
+ * Format: "[ val1 val2 val3 ... ]"
+ * Note: Random pointers are not shown in this representation.
+ *
+ * @return string representation of the list
+ */
@Override
public String toString() {
var head = this;
diff --git a/src/main/java/com/forketyfork/codingproblems/structures/TreeNode.java b/src/main/java/com/forketyfork/codingproblems/structures/TreeNode.java
index f86dc21..e8ad926 100644
--- a/src/main/java/com/forketyfork/codingproblems/structures/TreeNode.java
+++ b/src/main/java/com/forketyfork/codingproblems/structures/TreeNode.java
@@ -1,5 +1,9 @@
package com.forketyfork.codingproblems.structures;
+/**
+ * A binary tree node used in various tree-based coding problems.
+ * Contains an integer value and pointers to left and right children.
+ */
public class TreeNode {
public TreeNode left;
@@ -8,6 +12,14 @@ public class TreeNode {
public int val;
+ /**
+ * Creates a new tree node with the specified value and children.
+ *
+ * @param val the integer value for the node
+ * @param left the left child node (can be null)
+ * @param right the right child node (can be null)
+ * @return a new TreeNode instance
+ */
public static TreeNode node(int val, TreeNode left, TreeNode right) {
var node = new TreeNode();
node.val = val;
@@ -16,12 +28,25 @@ public static TreeNode node(int val, TreeNode left, TreeNode right) {
return node;
}
+ /**
+ * Creates a new tree node with the specified value and no children.
+ *
+ * @param val the integer value for the node
+ * @return a new TreeNode instance with null left and right children
+ */
public static TreeNode node(int val) {
var node = new TreeNode();
node.val = val;
return node;
}
+ /**
+ * Checks if two binary trees are structurally identical and have the same node values.
+ * Uses recursive comparison of the tree structure and values.
+ *
+ * @param object the object to compare with
+ * @return true if the trees are equal, false otherwise
+ */
@Override
public boolean equals(Object object) {
if (!(object instanceof TreeNode head2)) {
diff --git a/src/test/java/com/forketyfork/codingproblems/DivideTwoIntegersTest.java b/src/test/java/com/forketyfork/codingproblems/DivideTwoIntegersTest.java
index e2e86f5..0066865 100644
--- a/src/test/java/com/forketyfork/codingproblems/DivideTwoIntegersTest.java
+++ b/src/test/java/com/forketyfork/codingproblems/DivideTwoIntegersTest.java
@@ -20,8 +20,34 @@ void test(DivideTwoIntegersTest.TestCase testCase) {
public static Stream