Python Data Structures & Algorithms + LEETCODE Exercises

Explore how big O compares code by time and space complexity using operation counts. Prepare for coding interviews with practical examples of measuring performance and memory usage.

Explore how omega, theta, and Omicron (big O) describe best, average, and worst-case complexities for time and space, with a 7-item list example. Big O denotes worst-case performance.

Explore the first big O, o(n), by implementing a print items function with a for loop that runs n times and prints i, illustrating linear time complexity.

Drop non-dominant terms to simplify big O, showing that O(n^2 + n) reduces to O(n^2) as n grows large by dominance analysis.

Explore O(1) by examining a function that returns n plus n, demonstrating constant time operations. See why constant time is optimal, with a flat graph as input grows.

Demonstrate how binary search achieves O(log n) by halving a sorted list, and compare it with O(1), O(n), O(n^2), and O(n log n).

Learn how two input parameters affect time complexity, showing that with a and b you get O(a) plus O(b) and O(a × b) for nested loops.

Compare time complexities from O(1) to O(n^2), highlighting efficiency gains by rewriting to O(n). Introduce sorting algorithms and core time and space complexity concepts.

Explore how to define Python classes with a constructor and self, and use methods like get color and set color, illustrated by a cookie example and linked list concepts.

Explore how pointers reference memory addresses in Python, showing integers are immutable while dictionaries are mutable, and how assignments share or separate memory addresses, with garbage collection and linked lists.

Master linked lists and big O performance, covering append, remove, add to front, middle insertions, removals, and lookup by value or index.

Create a linked list constructor using a dedicated node class to build nodes, initialize head and tail, and set the length. Use this pattern for append, prepend, and insert.

Traverse a linked list with a custom print list method, using a temp pointer from head to print each node’s value until the end.

Implement an append method for a linked list by creating a new node, updating head and tail for empty lists, linking tail to the new node, and increasing length.

Learn how to pop the last item from a linked list, handling empty and one node edge cases, updating tail, and returning the popped node.

Implement the pop method for a linked list, handling zero, one, and multiple items by updating head, tail, and internal pointers, and returning the removed node.

Learn to pop the first node from a linked list by updating head, handling edge cases for zero, one, or multiple nodes, and returning the removed node.

Implement a get method for a linked list by index in Python. Validate the index, return None for invalid values, then move a temp pointer from head to the node.

Implement a set value method for a linked list, using the get method to locate a node, update its value, and return true on success or false for invalid indices.

Learn how to remove a node from a linked list by index, handling out-of-range checks, removing from the beginning or end, and updating pointers efficiently to return the removed node.

Learn to reverse a linked list by swapping head and tail, then iterating with before, after, and a temp variable to flip each arrow and produce a fully reversed list.

Learn to find the middle node of a linked list in a single pass using slow and fast pointers, without knowing length, handling odd and even cases.

Explore detecting a loop in linked lists using slow and fast pointers, distinguishing looping from non looping lists, and interpreting true or false outcomes in LeetCode style exercises.

Learn to convert a binary linked list to decimal by iteratively doubling the accumulated value and adding the current node’s bit, leveraging binary patterns from right to left.

Partition a linked list around a pivot using dummy nodes, collect nodes less than the pivot in one list and the rest in another, preserve relative order and connect lists.

Demonstrate how to reverse the nodes of a linked list between two indices using previous, current, a to_move variable, and a dummy node when the range includes the head.

Learn to swap pairs in a linked list using a dummy node and manipulating pointers to handle odd node counts.

Learn to implement a doubly linked list append method: handle empty list, link new node with previous tail, update tail, and return boolean, demonstrated by building 1 and 2.

Implement the pop method for a doubly linked list by moving tail to previous and breaking node connections. Handle edge cases for empty and single-item lists.

Implement the prepend method for a doubly linked list by inserting a node and updating head, tail for empty lists, and next and previous pointers; increment length and return true.

Implement the set value method for a Python doubly linked list by locating the target node with get and updating its value, and returning true or false.

Implement a remove method for a doubly linked list that validates the index, uses get to locate the node, unlinks neighbors, updates length, and returns the removed node.

Explore checking whether a doubly linked list is a palindrome by comparing forward and backward pointers. Handle odd and even node counts, single-node cases, and return true or false accordingly.

explains partition list with a doubly linked list, part of LeetCode challenges for doubly linked lists, and notes an edge case when the second list is empty requiring specific code.

Understand stacks through a tennis-ball analogy, learning push and pop in a last-in, first-out structure. Compare list and linked-list implementations, and explore top versus bottom with O(1) and O(n) operations.

Learn to implement a stack constructor using linked list nodes, track top and bottom and height, and print the stack with a print stack method.

Implement the stack pop method to remove and return the top node, update the top pointer to the next node, handle empty stacks, detach the popped node, and decrement length.

Build a queue constructor by creating a node, setting first and last to that node, and initializing length to one. Verify the queue using the print queue method.