Data Structures And Algorithms In Practice: Learn by Coding

Explore the linked list data structure, its node-based design and next pointers, and implement append, prepend, and display in Python while noting dynamic memory, fast insertion, and slower index access.

Discover the doubly linked list: each node holds data, next and previous pointers, enabling bidirectional navigation, appending to the end, and insert/delete operations with pointers for browser back and undo/redo.

Explore the circular linked list, a variation where the last node points to the head to enable continuous iteration, with append, display, and insertion at the beginning.

Explore the stack data structure, a last in, first out concept, and implement it in Python with a stack class featuring push, pop, and top operations.

Learn how computers parse and evaluate arithmetic expressions by converting infix to postfix using a stack, applying operator precedence, and evaluating the postfix result.

Build a Python queue data structure that follows first-in, first-out, implementing enqueue, dequeue, peek, is_empty, and size; compare with built-in collections deque for efficient operations.

Explore the circular queue data structure with a Python implementation, showing how a fixed-size array wraps around using front and rear pointers, enabling efficient enqueue and dequeue operations.

Implement a simple priority queue in Python using a list of (priority, value) tuples, enqueue and dequeue highest-priority items (lowest number) first, with a pick method.

Explore how linear and binary search work on lists, compare performance for unsorted versus sorted data, and learn when to choose each method for efficient searching.

Explore how the linear search algorithm in Python scans a list from the start to the end to locate a target, returning its index or -1 when not found.

Explore interpolation search, a variant of binary search that estimates a target's position from data distribution, implemented in Python for sorted, evenly distributed data.

Explore exponential search in Python for sorted arrays, doubling the search range until the target is likely within, then perform a binary search in that range.

Explore the Fibonacci search algorithm in Python and learn how Fibonacci numbers guide the search space, instead of a midpoint, improving performance on large arrays with non-uniform memory hierarchies.

Explore the sublist search problem in Python by checking if a sublist appears as a continuous sequence in a main list using a sliding window.

Explore how a hash table in Python stores key-value pairs by hashing keys into bucketed indices, handles collisions, and supports insert and get operations.

Learn how bubble sort in Python compares adjacent elements and swaps them to place the largest at the end, and optimize with a swapped flag for early exit.

Learn how insertion sort builds a sorted list by inserting each element into its correct position in Python, highlighting shifting, key, and best-case efficiency for small, near-sorted data.

Learn how the selection sort algorithm works in Python by repeatedly finding the smallest element in the unsorted part and moving it to the beginning.

Learn the merge sort algorithm with a Python implementation, splitting a list in half and merging two sorted lists for reliable, elegant, divide-and-conquer sorting.

Explore the shell sort algorithm, an in-place, gap-based refinement of insertion sort in Python. See how shrinking gaps boost performance and understand its average time complexity omega n log n.

Explore bucket sort in Python by dividing data into five buckets, sorting each bucket, then merging results; it works best when inputs are uniformly distributed across a range.

Explore the counting sort algorithm in python, a non-comparison sort that counts occurrences to build a sorted list for integers within a known range, achieving linear time for small ranges.

Learn how radix sort sorts numbers digit by digit with stable counting sort at each digit, from least to most significant, achieving linear time with fixed digit counts.

Learn how quick sort uses a pivot to partition the array into left and right sides. Recursively sort each side in Python and note the last-element pivot and performance.

Explore the matrix data structure in Python as a 2d list-based array for image processing, graph theory, and machine learning; access elements with two indexes, print matrices, and add matrices.

Learn how LU decomposition breaks a square matrix into a lower triangular L and an upper triangular U, with a permutation matrix P, to solve linear systems efficiently using SciPy.

Explore the graph data structure in Python, modeling with an adjacency list, distinguishing directed, undirected, and weighted graphs, and using depth-first search for traversal.

Master depth-first traversal in Python graphs using recursion and backtracking. See dfs explore a directed graph with an adjacency list and backtrack to reveal all paths and cycles.

Explore breadth first traversal on graphs using Python, visiting nodes level by level with a queue and a visited set to find shortest paths in unweighted graphs.

Explore topological sorting in directed acyclic graphs, deriving a linear order that respects dependencies using depth first search, with possible multiple valid sorts.

Discover strongly connected components in directed graphs using Kosaraju's algorithm: perform a dfs to record finishing times, reverse the graph, then dfs again guided by the stack.

Explore the trip data structure, a hybrid of a binary search tree and heap that uses random priorities to balance the tree and support insertions in expected logarithmic time.

Learn how preorder, inorder, and postorder traversals visit every node in a binary tree using Python, with concrete examples for copying trees, evaluating expressions, and memory cleanup.

Explore how a binary search tree (bst) stores data with two children, left subtrees hold smaller values, right subtrees hold greater values, enabling efficient search, insert, delete, and in-order traversal.

Learn how AVL trees keep a binary search tree balanced by automatic rotations after inserts or deletes, maintaining height difference at most 1 and ensuring fast search and insert.

Discover recursion algorithms in Python by exploring factorial, fibonacci, and recursive sum, mastering base and recursive cases, and noting improvements such as memorization and iteration.

Learn how divide and conquer splits problems into smaller subproblems, solves them recursively, and combines results, illustrated by finding a maximum and by merge sort.