Data Structures & Algorithms in JS + 100 LEETCODE Problems

Explore the language of time and space complexity through big O notation. Compare linear, constant, quadratic, and logarithmic complexities, and relate runtime and memory usage to input size.

Learn how space complexity measures memory growth with input size, accounting for variables, external data structures, and recursion, and how to sum these contributions.

Explore how arrays are implemented as a contiguous memory range, storing homogeneous elements and enabling constant-time access through address plus index times element size, while noting the drawbacks of contiguity.

Analyze the amortized time complexity of inserts in a resizable array, showing bursts of copying during resizing and concluding that amortized cost is O(n), with practical language recommendations.

Master max consecutive ones in a binary array by scanning once, counting ones, updating the maximum, and resetting on zeros, a binary form of the maximum sum subarray problem.

Practice problem 5 explores the maximum product subarray by tracking max and min products at each index to handle negatives and zeros, using left-to-right and right-to-left passes.

Master the set matrix zeros problem by implementing an in-place, constant-space solution in JavaScript that marks rows and columns using the first row and column, with boolean flags.

Apply divide and conquer to merge sort by dividing the array into two parts, sorting each part, and merging the results into a fully sorted array.

Implement a two-way partitioning algorithm using the last element as pivot, moving smaller values to the left and larger values to the right, not sorting, for quicksort.

Explore the drawbacks of arrays, including their contiguous memory and the costly shifting required for middle insertions and deletions. Learn how linked lists address these efficiency issues.

Explore why arrays are contiguous and why linked lists use nodes with data and references; learn traversal from head, while insertions and deletions in the middle avoid shifting.

Implement insert at the front for a linked list by creating a new node with the given data, updating the head, and linking the old head.

Learn to iterate over a linked list by using a current pointer starting at head, printing the data of each node, and advancing with current = current.next until null.

Merge two sorted linked lists into a single sorted list by splicing nodes, using a two-pointer method, and return the head of the merged list in JavaScript.

Learn to reverse a singly linked list from its head and return the new head. Explore a recursive approach using next and last pointers to reverse from a node onward.

Explore the intersection of two linked lists by identifying the exact intersection node using a space-optimized two-pointer approach that aligns list lengths and avoids extra memory.

Explore the stack as a last-in, first-out abstract data type, learn its core operations push, pop, and top, and compare array and linked-list implementations.

Discover how to implement a stack in JavaScript using an array, with push and pop at the end and retrieving the top element from the last array item.

This lecture covers the next greater element II problem on a circular array, using a stack for delayed processing to find each element’s next greater, with wrap-around and -1.

Learn how to implement a queue with a linked list by maintaining head and tail pointers, inserting at the end and removing from the front for constant-time operations.

Implement an iterative binary search on a sorted array to locate a key, using start, end, and midpoint with floor, and return the found index with log n time.

Solve the search insert position problem in a rotated sorted array using binary search, locate the rotation point, and search the correct half for the target or insertion.