100 Days of Code: JavaScript Data Structures and Algorithms

Explore how big O describes algorithm efficiency by measuring time and space complexity as input size grows. Compare code based on operations and runtime to improve performance.

Explore how big O, omega, and eta describe algorithm runtimes, and compare best, worst, and average cases with real-world examples and industry usage of big O.

Explore common runtime complexities, start with constant time O(1) and understand how a simple function or deck of cards demonstrates a single time complexity, with real-life and graph explanations.

Explore linear time complexity (O(n)) in JavaScript by analyzing a for loop that runs n times, showing how operations grow directly with input size, including worst-case behavior.

Drop constants in big O to simplify asymptotic analysis and reveal that two identical loops yield O(n) time, while hardware factors remain ignored.

Explore the big O notation for O(n^2) by using nested loops and observing quadratic time complexity. The lecture shows how adding a third loop yields O(n^3) and discusses efficiency.

Understand dropping the non-dominant terms to simplify time complexity in nested and standalone loops. Conclude that the final complexity is n squared, with constants and n terms considered non-dominant.

Explore logarithmic time complexity with a divide-and-conquer approach on a sorted list. The lecture shows halving the search space each step to locate a target efficiently.

Explore big O time complexity with different input terms by comparing two separate loops and nested loops, using a and b to demonstrate O(a+b) and O(a*b).

Space complexity measures an algorithm’s memory needs as input grows, focusing on worst‑case working storage. Recursive sums use stack memory for O(n) space, while non‑nested calls stay O(1).

Analyze code with Big-O by applying five practical rules to identify O(1), O(n), O(n^2), and O(log n) complexities, and learn how to combine costs in real examples.

Explore how JavaScript arrays function as a versatile data structure that stores lists of elements, supports heterogeneous types, and uses zero-based indexing with automatic memory management.

Explore JavaScript arrays, including one dimensional arrays, multi-dimensional arrays, arrays of objects, arrays of functions, and typed arrays, with real-world examples like movies, students, chessboards, and images.

Discover how JavaScript stores arrays in memory with dynamic, contiguous blocks and zero-based indexing. Understand memory allocation for single and multidimensional arrays, inner arrays, and engine optimizations.

Learn how to create arrays in JavaScript using three methods: array literal syntax, predefined-length array constructor, and arrays with elements; compare their time and space complexity from constant to linear.

Learn how to insert elements into a JavaScript array with push, unshift, and splice, and compare their time and space complexities.

Access array elements by index in JavaScript using zero-based keys, and traverse arrays with for, for each, and for of.

Search for a value in an array using linear search in JavaScript, returning the index or a boolean, and learn indexOf and find with their time and space costs.

Learn how to delete elements from a JavaScript array using splice, pop, shift, delete, and filter, and compare end, middle, and beginning deletions with their time and space costs.

Learn what a linked list is, with head and tail, nodes containing data and next references, and why its non-contiguous memory and sequential access matter.

Compare the differences between linked lists and arrays, including independent nodes, dynamic sizing, and memory usage. Understand why linked lists may be preferred for insertion and deletion, despite random access.

Explore how linked lists are stored in memory, with noncontiguous nodes linked by next pointers, requiring traversal from head for access, unlike contiguous arrays.

Explore four linked list types: single, circular single, double, and circular double, detailing next and previous references and practical examples.

Define a node class in JavaScript with a value and a next pointer initialized to null, then create a linked list class to manage head and tail.

Create a singly linked list by implementing an empty list and a one-node version, initializing head and tail, and tracking length with O(1) time and space.

Append creates a new node, links it from the current tail, and updates the tail; it handles empty lists by initializing head and tail, with O(1) time and space.

Override the toString method inherited from Object.prototype in the linked list class to build a string of node values with arrows, starting at the head and returning the result.

Prepend in a singly linked list inserts at the head by creating a new node, linking it to the current head, and updating head (tail if empty) in constant time.

Implement insert method for singly linked list, handle edge cases like inserting at head, tail, or middle, and analyze O(n) time and O(1) space.

Traverse a singly linked list by visiting each node and printing its value in JavaScript, illustrating its use in search and get methods and analyzing O(n) time and O(1) space.

Implement a search method for a singly linked list, starting at the head, returning true or index when the target is found. It runs in O(n) time and O(1) space.

Implement the get method in a singly linked list to return the node at given index, handling negative and out-of-range indices by returning null, via a linear search from head.

Implement a set value method for a singly linked list to update a node at an index with a value, returning true on success or false if not found.

Remove the pop first node from a singly linked list by updating head, unlinking the node, and updating length; handle single-element and empty-list edge cases, with constant time and space.

Demonstrates the pop method on a singly linked list: remove the last node by moving the tail to the second-last node, breaking the link, and returning the popped node.

Remove a node by index in a singly linked list by rewiring links with a previous and popped node, handle edge cases, and achieve O(n) time, O(1) space.

Delete all nodes in a singly linked list by setting head and tail to null, resetting length to zero, and implementing a delete all method with O(1) time and space.

Explore the time and space complexity of a singly linked list, covering constructor, append, prepend, insert, search, traverse, get, set, pop first, pop, remove, and clear.

Explore circular singly linked lists and how the last node points to the first. Create nodes, manage head and tail, and support empty or single-node cases with standard list operations.

Learn how the append method adds a new node to a circular singly linked list by updating tail and next pointers, handling empty and nonempty cases, and updating length.

Implement the toString method for a circular singly linked list to produce a readable string representation in the console, iterating from head and appending values with arrows.

Prepend in a circular singly linked list by creating a node, linking to first node, and updating head and tail; handle empty case by pointing to itself in O(1).

Traverse a circular singly linked list by visiting each node from the head and printing its value. Use a current pointer starting at head, looping until it reaches head again to avoid infinite loops, with O(n) time and O(1) space.

Apply a linear search to locate a target in a circle single linked list by traversing nodes, returning true or false or an index, with O(n) time and O(1) space.

Understand the get method in a circular singly linked list, retrieving a node by index via linear search, with edge-case handling returning null and O(n) time, O(1) space.

Set the value of a node in a circular singly linked list by locating it with the get method using the index. Return true on success, false on invalid index.

Learn the pop first method for a circular singly linked list: remove the first node, update head and tail, handle single-element and empty cases, with O(1) time and space.

Learn how the pop method removes and returns the last node from a circular singly linked list by updating the second last node and tail, with edge-case handling.

Delete the node at a given index in a circular singly linked list by relinking the previous node to the next node and lowering length, handling zero or out-of-range indices.

Implement the delete all method for a circular singly linked list by nullifying the last node's next reference, resetting head, tail, and length to zero, ensuring memory is freed.

Explore the time and space complexity of operations on a circular singly linked list, including create, append, prepend, insert, search, traverse, get, set, pop, remove, and delete all.

Learn to implement a doubly linked list node class with value, next, and previous references, initialized to null, enabling forward and backward traversal.

Implement a doubly linked list constructor that creates a single node and assigns it to both head and tail, with null previous and next.

Learn how to implement a JavaScript toString method for a doubly linked list, iterating from head to end, building a string with node values and double-arrow separators.

Master the prepend method for a doubly linked list by updating the new node's next, the first node's previous, and head and tail for empty and non-empty cases.

Learn how to traverse a doubly linked list by visiting each node from the head, printing values, and moving to the next node, with time complexity O(n) and space O(1).

Demonstrate reverse traversal in a doubly linked list by starting at the tail, moving backward via the previous links, and printing node values, with O(n) time and O(1) space.

Explore the linear search for a value in a doubly linked list using a current pointer, returning true/false or the node index, with time O(n) and space O(1).

Implement the get method for a doubly linked list by starting from head or tail based on index, returning null for invalid indices and highlighting O(n) time and O(1) space.

Learn the set method for a doubly linked list: update a node’s value at a given index using head or tail traversal via get, with O(n) time and O(1) space.

Examine insert method for a doubly linked list, building on a single linked list approach, using get to locate the node before index, and handle prepend, append, and edge cases.

Learn how to implement the pop first method in a doubly linked list, removing the head and updating head, tail, and the node references to achieve O(1) time and space.

Learn the pop method for a doubly linked list: move tail, detach the last node, and return it, with cases for empty or single-element lists and O(1) time and space.

Master the remove method in a double linked list by deleting a node at a given index, updating adjacent pointers, and handling edge cases with pop first and pop method.

Implement delete all for a doubly linked list by setting head and tail to null and length to zero, enabling mark-and-sweep garbage collection to reclaim unreferenced nodes.

Analyze the time and space complexity of a doubly linked list, covering create, append, prepend, insert, get, set, search, traversal, reverse traversal, pop, and remove operations.