Data Structures & Algorithms in Java + 150 Leetcode Problems

Master time and space complexity by learning how to count operations, assess runtime and RAM growth, and express results in big O notation.

Explore the language of time and space complexity through Big O notation, including linear, constant, quadratic, and logarithmic time, and how they relate to runtime and memory.

Analyze time complexity of for loops by counting operations and applying big-O rules, from simple loops to O(n) cases, with emphasis on ignoring constants and lower-order terms.

Evaluate big O acceptability in interviews by estimating operations from constraints, comparing O(n^2) and O(n log n), and using binary search and problem hints to guide solution direction.

Analyze time complexity of loops, including a doubling while loop and nested loops, using counts of iterations to derive O(log n) and O(mn) patterns.

Uncover the myth that time complexity equals runtime; compare two loops, A and B, showing identical growth rates despite different actual times, emphasizing relative growth.

Explore how recursion drives time complexity, using a factorial example, recursion trees, and function-call simulations to show why the time complexity is O(n).

Explore the time and space complexity of the Fibonacci function using a recursive approach, analyze a two-branch recursion tree, and recognize exponential time growth.

Watch a live demonstration of time complexity by coding a Fibonacci function and comparing its exponential runtime to a factorial's linear time, illustrating how recursion growth impacts actual runtime.

Develop a solid understanding of space complexity by analyzing memory growth from variables, external data structures, and recursion, and learn to compute it by summing these contributions.

Analyze space usage by examining variables, data structures, and recursion in a simple array doubling program, noting the input array is not counted and space is O(1).

See how recursion uses the call stack to store n−1 frames and explicit variables, determining space complexity and the O(n) space bound.

Explore how recursion depth determines space complexity in the fibonacci example, showing the call stack stores n-1 integers of constant size, yielding O(n) space.

Explore arrays as contiguous, homogeneous data structures stored in RAM, learn how their memory layout enables constant-time access through simple address calculations, and discover the drawbacks of contiguity.

Explains the drawbacks of arrays: static size and costly middle or beginning insertions, while noting dynamic arrays, vectors, and linked lists as remedies.

Explore how resizable arrays overcome static sizing by using array list and vector that double capacity, copy elements, and track size and capacity behind the scenes, yielding amortized O(1) additions.

Learn essential array methods in Java using the Arrays class, including Arrays.asList to convert arrays to lists and Arrays.sort to sort whole arrays or subranges with an end index exclusive.

Explore Java's Arrays.binarySearch and other pre-built array methods, focusing on binary search for sorted arrays, including variations with fromIndex and toIndex, and how results show found or not found.

Learn how to fill arrays with a single value using arrays.fill, and perform custom sorting on arrays of objects with comparable and comparator, illustrated with a tuple example.

Explore the maximum sum subarray problem with Kadane's algorithm to find the best contiguous subarray sum, and implement it in Java using a current sum and max so far.

Learn to maximize profit from one stock transaction by tracking the minimum price and updating the maximum profit as you scan daily prices, with a Java implementation.

Master the maximum product subarray by maintaining both max and min products at each index to handle negative numbers and zeros, illustrated with a Java solution.

Compute the product of array elements except the i-th using left and right products in O(n) time without division, ensuring correct results for every index.

Rotate the array to the right by k steps using an in-place, linear-time method: apply k mod n, then reverse the whole array, the first k, and the last n-k.

Scan a binary array to find the max consecutive ones using a running count that resets on zeros, yielding an O(n) Java solution.

Validate a 9x9 sudoku by checking rows, columns, and 3x3 boxes for digits 1–9 with no repetition, skipping empties, using nine sets and grid index (i/3)*3 + (j/3) in Java.

Explains the k closest points to origin problem on a 2d plane, using the distance formula and quickselect with partitioning to find the top k efficiently.

Encode a list of strings into a single string and decode it back, using an escaping scheme for delimiters and backslashes to handle any ascii characters.

Discover why sorting matters in data structures and algorithms in java, from diverse algorithms to divide and conquer, and why many algorithms—like binary search—rely on sorted input to reveal patterns.

Explore fundamental sorting techniques and algorithms, from bubble sort to quicksort, and see how sorted data enables efficient problem solving with binary search and two-pointer methods in Java.

Bubble sort compares adjacent elements in the unsorted portion and swaps when out of order, pushing the largest element to the end as the list ascends.

Implement bubble sort to sort an array in ascending order using nested loops, swapping out-of-order elements, and analyze its O(n^2) time complexity.

Select the smallest element from the unsorted portion and swap it to the front, gradually growing the sorted part of the array while shrinking the unsorted portion.

implement the selection sort algorithm in Java by repeatedly selecting the highest element from the unsorted portion and swapping it with the end, achieving O(n^2) time.

Explore insertion sort theory: how it builds a sorted and unsorted part, shifts elements to insert each item at its correct position, and its time complexity.

Learn the insertion sort implementation with an outer loop and a shifting inner loop that places each key, and assess its best and worst-case complexities (O(n) to O(n^2)).

Learn the merge operation: merge two sorted arrays a and b into a sorted c using two pointers, achieving linear time O(n+m) and enabling merge sort.

Merge two sorted arrays in Java by using two pointers i and j, building a result array, comparing a[i] and b[j], and appending remaining elements.

Explore how merge sort uses a divide-and-conquer strategy to divide an array into two parts, sort each part recursively, and merge them into a fully sorted result.

Implement a Java merge sort with a mergeSort method using start and end indices and a combine function that merges left and right halves via a two-pointer approach.

Learn the partition function in quicksort, which arranges an array around a pivot so elements less than, equal to, and greater than the key form regions using a left pointer.

Explore quicksort by partitioning around a pivot into less than, greater than, and equal parts, placing the pivot in its correct position, then recursively sorting the left and right parts.

Explore counting sort, a non-comparison based sorting algorithm that achieves linear time by counting frequencies, building a cumulative frequency, and using a temporary result while ensuring stability.

Implement counting sort by building a frequency count array, computing cumulative frequencies, and placing elements in a stable order using reverse iteration; analyze time and space complexity.

Learn how to make counting sort stable by iterating from right to left, preserving the order of equal elements, and enabling its stable use in radix sort.

Learn radix sort, a non comparison based sorting algorithm that uses counting sort to sort numbers by digits, starting from the ones place and moving to the tens and hundreds place.

Implement radix sort in Java by repeatedly applying a stable counting sort on each digit place (ones, tens, hundreds, thousands) to sort the array based on place value.

Move zeros to the end while preserving the relative order of non-zero elements by scanning the array and swapping non-zeros left with a k index; Java solution runs in O(n).

Apply the dutch national flag approach to sort 0s, 1s, and 2s in place using a left-right pointer to move zeros left and twos right, with ones in the middle.

Apply the majority vote algorithm to identify the majority element in an array, achieving linear time and constant space when a majority exists.

Explore the drawbacks of arrays, including fixed size and the need to shift elements for middle insertions or deletions, and how linked lists can overcome these limits.

Learn how linked lists store data in nodes linked by references, making mid-list insertions and deletions easy, while offering slower random access compared to arrays.

Construct a static linked list in Java by creating nodes with data and a next reference, linking 10, 20, 30, 40, 50, and establishing head to the first node.

Learn to iterate a linked list in Java with a current pointer and a while loop, printing each node's data via getNext until null, and consider stopping at second-last node.

Insert at the front of a linked list by creating a new node, pointing it to the head, and updating head; handle empty lists and return the new head.

Master deleting the front node in a Java linked list by updating head to head.next, handling a null head, and illustrating the before and after effect with printouts.

Explore doubly linked lists, where each node links forward with next and backward with previous for bidirectional traversal, aiding middle deletions with similar memory use to singly linked lists.

Explore java's generic linked list class, including constructors for empty lists and from collections, and common operations such as add, get, remove, clear, contains, indexOf, getFirst, getLast, and conversions.

Explore creating and manipulating a generic Java linked list, using the add method to insert integers and add at a specific index, and print the list with an iterator.

Learn how to iterate over linked lists and collections with iterators in Java. Avoid using get for iteration; use hasNext and next to traverse elements efficiently.

Test element presence in a linked list using the contains method. Observe how L.contains(30) returns true and L.contains(40) returns false to guide membership checks.

Learn to iterate a linked list in reverse using a descending iterator, printing elements in reverse order with hasNext and next, and recognize that iterators exist for other collections.

Learn how to add elements to a linked list in Java using add, add at index, addAll, addAll at index, addFirst, and addLast, with a practical example.

Explore linked list removal methods, including remove, remove at index, and remove by object, then distinguish first and last occurrences and remove the last element with concrete examples.

Learn to find the intersection of two linked lists using a two-pointer method that handles unequal lengths by skipping nodes and equal lengths by alignment, in O(m+n) time and O(1) space.

Merge two sorted linked lists by splicing nodes using two pointers, comparing values, and appending the smaller node; use a tail pointer for O(1) insertions, achieving O(m+n) time.

Detect cycles in a linked list using the hare and tortoise algorithm with slow and fast pointers, handle nulls, and run in O(n) time.

Reverse a singly linked list from its head using a recursive approach, returning the new head and handling the empty list edge case with an O(n) time complexity.

Determine if a singly linked list is a palindrome in O(n) time and O(1) space by finding the reverse point, reversing the second half iteratively, and comparing halves.

Explore linked list cycle II: detect if a cycle exists using slow and fast pointers, then find the cycle's starting node; return null if no cycle.

Use two pointers, slow and fast, starting at head to find the middle of a singly linked list in one iteration; return the second middle node for even lengths.

Practice problem 8 demonstrates removing the nth node from the end of a singly linked list using a two-pointer, one-pass approach, handling edge cases like deleting the first node.

Iterate two reversed linked lists with two pointers to sum digits, manage carry, and build the resulting reversed list in linear time, even handling final carry with an extra node.

Split the linked list at the middle using slow and fast pointers, reverse the second half, and merge the two halves to reorder nodes in place.

Explore hash tables, also called hash maps or dictionaries, an associative data structure that stores key-value pairs. Use get and put with any hashable key for fast near-constant time access.

Explain how a hash table uses an array and a hash function to map keys like Toyota to index, using a pure, stateless hash and modulo for put and get.

Explore hash table collisions and resolution with chaining using a linked list, showing how insertions and lookups work and why worst-case searches become O(n) while amortized operations stay O(1).

Learn about unordered and ordered hash tables, their structures, and complexity trade-offs: unordered offers amortized O(1) while ordered uses a balanced tree with O(log n).

Learn to use Java hash maps and tree maps via the map interface, performing put, get, contains key, key set, values, size, and remove. Compare unordered and ordered maps.

Identify duplicates in an integer array using a hash table to track seen values and return true when a duplicate is found, otherwise false.

Explore the two sum problem with a hash table solution that yields the indices of two numbers summing to the target in O(n) time and O(n) space.

Practice problem 5 covers validating anagrams by sorting two strings s and t and comparing them, and notes the n log n time complexity.

Group anagrams by sorting each string to form a key, then collect strings in a hash map by that key and return the grouped lists.

Discover the longest consecutive sequence problem and implement an O(n) hash-table solution in Java, pre-processing numbers and starting sequences only from minimal elements to avoid sorting.

Learn to solve the three sum problem by finding all unique triplets that sum to zero; sort the array, fix one number, and use a two-pointer method for O(n^2) time.

practice the first missing positive problem with an in-place O(n) time algorithm that places x at index x-1, ignores negatives and numbers greater than n, and reveals the missing positive.

Explore the stack as a last-in, first-out abstract data type, with push, pop, and top operations; learn two common implementations (linked list and array) and when to use them.

Learn how to use the stack in Java, including push, peek, pop and size, with an example of top elements and how popping reveals the next item.

Learn to determine balanced brackets across round, curly, and square types using a stack in Java. Push openings, pop on matching closings, and verify the same type and correct order.

Explore the min stack design with two stacks: a main stack for all elements and an auxiliary stack for minimums, enabling push, pop, top, and get min in O(1).

Learn to solve the next greater element II problem on a circular array using a stack for delayed processing, tracking indices, and updating the answer array.

Learn to evaluate reverse Polish notation using a stack: push operands, pop two for each operator, and compute with +, -, *, /. Implement in Java with O(n) time.

Explore the queue as a FIFO abstract data type, learn enqueue and dequeue operations, and compare it with stacks, noting linked-list implementations and built-in language support in Java.

Learn how to implement a queue with a linked list, including standard queues and double-ended queues, plus front and back operations, tail pointers, and priority queues.

Explore implementing a Java queue with a linked list, preserving FIFO order, and using add, offer, peek, element, poll, and remove, noting contains inefficiency.

Explore the sliding window method to compute the sum of all k-sized subarrays, compare brute force two-loop solutions, and analyze time complexity O(nk) in this lesson.

Learn how the sliding window method optimizes subarray and substring problems by updating the window sum from the previous window, using removed and added elements to compute the next sum.

Learn to implement sliding window problems quickly by computing the first window sum and updating it efficiently as the window slides, achieving O(n) time.

Apply a sliding window with two pointers to find the longest substring without repeating characters. Use a hash map for counts, expand when valid, shrink when not, achieving O(n) time.

Apply the sliding window approach to the longest repeating character replacement problem, using at most k replacements to maximize a substring of identical characters.

Discover how to compute the sliding window maximum in Java with a double-ended queue, maintaining candidate indices and achieving O(n) time without brute force.

Use a two-pointer strategy in Java to solve the container with most water, calculating area as width times the minimum height and moving the shorter line inward to maximize area.

Use a two-pointer approach to compute trapped rainwater on an elevation map by tracking the left and right maxima and the bar height.

Use the two-sum II approach for a sorted array to find two numbers that sum to a target, implemented in Java with two pointers and O(n) time.

Practice problem 4 uses the two-pointer method in Java to check a palindrome by lowercasing and removing non-alphanumeric characters, moving left and right for an O(n) solution.