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 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.

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.

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.

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.

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.

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 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.

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.

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.