Coding Interview Jumpstart: Algorithms and Problem Solving

Learn to analyze algorithms by exploring asymptotic notation and Big-O, compare time and space complexity, and practice selecting the best algorithm for a problem.

Analyze algorithm efficiency by comparing naive prime checks with square-root optimization, recognizing how operation counts and data types influence running time and asymptotic performance.

Learn to estimate a program’s running time by identifying the dominant growth term and using asymptotic notation, especially big O, to compare algorithms.

Explore big-O notation and how to describe an algorithm's worst-case time and space using upper bounds, dropping lower-order terms, and comparing growth rates.

Analyze time complexity through multiple examples, identify bottlenecks in nested loops and while loops, and express running time in big-o notation using common patterns.

Learn to estimate space complexity by dropping constants and keeping the dominant term. This lecture shows constant space for simple variables, linear space for arrays, and O(n*m) for matrices.

Learn sorting fundamentals from bubble, selection, and insertion sort to merge sort, quicksort, and counting sort; compare time and space complexity and choose the best algorithm for data.

Explore bubble sort, a simple sorting algorithm that traverses an array, swaps adjacent out-of-order elements, and repeats until sorted, noting that the largest element moves to the end each pass.

Learn a bubble sort implementation in Java with swap and print helpers, a swap loop and adjacent comparisons, and time and space complexity analysis using 5 4 3 2 1.

Master selection sort by repeatedly selecting the smallest element from the unsorted suffix and swapping it into the sorted prefix, demonstrating iterative, in-place sorting and implementation steps.

Implement selection sort by swapping the minimum element in the unsorted group into place, using swap and print helpers, and analyze its quadratic time and one extra space.

Learn insertion sort by dividing the array into a sorted prefix and an unsorted suffix, then iteratively insert each unsorted element into its correct position within the sorted prefix.

Demonstrate the insertion sort implementation with swap and print helpers, inserting each element into the left prefix and analyzing its O(n^2) time and one space complexity.

Learn how merge sort divides an array in two halves, recursively sorts each half, and merges them into a sorted array, highlighting its efficiency over quadratic sorting.

Learn how to implement merge sort, using an auxilary array, recursion to split ranges, and a merge step with two pointers, plus time and space analysis.

Discover how quicksort uses a pivot to partition an array into left and right subarrays and recursively sort them, with step-by-step simulation.

Implement quicksort in java by shuffling the array and using a two-pointer partition to place the pivot. Recursively sort left and right parts.

Counting sort introduces a non-comparison based algorithm that counts occurrences in a count array, builds a prefix summary, then places elements into the output array and copies back.

Learn to implement counting sort in Java by building a count array, computing prefix sums, and outputting the sorted array, then copying back. Understand time complexity O(n+k) and space O(k).

Master binary search fundamentals and variations, from locating a target in arrays and dictionaries to counting occurrences, while understanding time and space complexity.

This lecture introduces binary search on sorted arrays, using low, high, and mid to compare a target with the middle element and halve the search range.

Explore a practical binary search implementation on a sorted array, using low, high, and mid to return the target index or -1 when not found.

Master how to modify binary search to return the first occurrence of a target value in a sorted array with duplicates, including -1 when the target does not appear.

Apply binary search to find the last occurrence of a target, contrasting with the first occurrence, and adjust mid calculation with plus one to avoid infinite loops in even ranges.

Use binary search variations to count a target in a sorted array with duplicates via first and last occurrence, yielding count as last minus first plus one for O(log n).

Explore solving the unique number problem where every element in an array appears twice except one, using brute force, counting, maps, sorting, and xor techniques.