Python Data Structures And Algorithms: Practical Course

Explore the theoretical foundations of array data structures, including zero-based indexing, contiguous memory, and random access for fast retrieval. Note Python's differences and arrays underpin stacks, queues, and numerical methods.

Explore how Python lists implement a one-dimensional array using references, storing object pointers of eight bytes, enabling mixed data types and affecting memory usage, with NumPy offering true contiguous arrays.

Explore advanced list operations in Python, from appending and indexing with negative indices to slicing, concatenation, and mutating lists with extend, copy, remove, pop, reverse, and sort.

Master Python list comprehension to build new lists from existing ones by filtering values, such as even numbers or names starting with A.

Reverse an integer in Python by iterating digits: use modulo 10 to get the last digit, apply integer division by 10, then accumulate with reverse = reverse * 10 + remainder.

Master the anagram problem by sorting the letters of two strings, checking their lengths, and comparing them to confirm anagrams, using an is_anagram function with linearithmic time.

Explore linked lists, a data structure of nodes with data and a next pointer. Starting at the head and ending at null, they support efficient insertion and removal without shifting.

Master linked list operations by inserting at the beginning and end, and removing items. Understand head and next pointers, and note linear time for arbitrary items.

Learn to traverse a linked list by visiting each node from head to tail, using the node class, and implement insert at the beginning and end with linear running time.

Learn how to remove items from a singly linked list, updating head, previous, and next pointers to skip deleted nodes, with linear time complexity and garbage collection in Python.

Explore how doubly linked lists use head and tail references with next and previous pointers to achieve constant-time insertions and removals at the ends and bidirectional traversal.

Define a node with data, next, and previous pointers, and a doubly linked list with head and tail. Implement end insertion and traverse forward from head and backward from tail.

Learn to find the middle node of a linked list with a one-pass two-pointer approach, using fast and slow pointers to achieve in-place, linear-time performance.

Understanding stacks as a leaf-structured abstract data type with top-access, push, pop, and peek, and how they power stack memory, function calls, recursion, and depth-first search.

Visualize how stack memory stores function calls and local variables, while heap memory holds objects; the lecture traces frames, parameters, and references and explains garbage collection.

Implement a stack as a one-dimensional array with push, pop, and peek operations, enforcing last-in, first-out behavior and handling empty stacks with -1.

Learn to implement a get maximum function in a stack with an auxiliary max stack, achieving constant time operations for push, pop, and get maximum while using linear memory.

Implement a queue with two stacks: an enqueue stack for inserts and a duke stack for removals, transferring items when needed to preserve fifo order.