Master Data Structures: Basics to Advanced

Explore the stack data structure, a last-in, first-out linear structure with push and pop, including overflow and underflow handling, illustrated using a Python list and runtime analysis.

Explore how stacks solve common interview problems, from balancing parentheses and brackets to converting infix to postfix. Learn how to evaluate expressions using operator precedence.

Use a stack-based approach to verify balanced parentheses by pushing open braces and popping to match closes, with O(N) runtime and O(N) space.

Explore queue concepts from fifo enqueues and dequeues to circular queues (ring buffers) and priority queues, including qfull and qempty handling and basic Python array implementations.

Reverse a queue by dequeuing all elements into a stack, then enqueuing them back into a new queue to obtain the reversed order.

Explore how to implement level-order traversal on a binary tree using a queue, including enqueuing the root, visiting nodes left to right, and printing node values.

Discover the linked list as a dynamic, noncontiguous alternative to arrays, with node and head structures, and core operations insert, delete, and search in a doubly linked list.

Explore linked lists as a collection of nodes with data and next pointers, and learn to build, link, and perform operations like add, print, insert at the first position.

learn to reverse a linked list with an algorithm using current, next, and previous pointers; explore iterative and recursive approaches.

Identify whether a given linked list contains a cycle. Demonstrate how a next pointer looping back prevents termination, causing the list to run indefinitely instead of ending at null.

Determine whether two singly linked lists intersect and locate the common node, using stack-based techniques and multiple implementation approaches across linked list variations.

Explore how hash tables achieve constant time lookups, handle collisions with chaining, and compare BST-based chaining to improve search efficiency.

Explore how to check if one array is a subset of another using a hash table, outlining a linear-time solution. Compare this to a nested loop approach with O(n^2) complexity.

Remove duplicates from a linked list by using a hash set to track seen values, returning the updated head and printing the list before and after.

illustrates a sliding window approach with a hash table to detect duplicates within k distance by keeping only k elements and removing out-of-window items, with a Python implementation.

Master tree data structures as nonlinear, hierarchical models and learn traversal methods—order, preorder, and postorder—to visit nodes from root through left and right subtrees.

Explore the variations of binary trees: full, perfect, complete, skewed, and balanced, and learn node structure with data, left and right pointers, and leaf behavior.

Execute a level-order traversal of a binary tree by enqueuing left and right children, printing nodes as you go to realize a breadth-first search from root to leaves.

Learn to find the n-th node in an inorder traversal by using an auxiliary array with O(n) space, then optimize to constant space with a global counter.

Learn to construct a binary tree from inorder and preorder traversals by identifying the root from preorder and partitioning inorder into left and right subtrees, then recursively building each side.

Explore the binary search tree (BST), its left-subtree less than root and right-subtree greater than root, and how search and insert run in O(log n), with database indexing applications.

Derive the in-order of a binary search tree by sorting its preorder, then reconstruct the original BST from preorder and inorder to obtain the postorder.

Learn the heap data structure as a complete binary tree with min and max variants, enabling efficient priority queues, heap sort, and O(log n) access via array representation.

Explore how heaps solve the k-th largest and k-th smallest element problems, using heapify and heap pop max to retrieve top k elements efficiently in arrays and strings.

Explore graph basics and representation by using an adjacency list to model a directed graph with nodes 0–4, showing dictionary-based neighbor lists and edge insertion.

Explore graph traversals: BFS and DFS, with DFS using a stack and BFS using a queue, plus Python implementations and applications in networks, roads, and crawlers.

Initialize dfs from a source node, push neighboring nodes onto a stack, and mark visited to avoid reverse connections, noting adjacency matrix vs list time implications.

Master graph representations with adjacency list and matrix, and use depth-first search to identify connected components. Tackle the island or largest region problem by detecting and measuring regions.

Count islands in a 2d grid using dfs with eight-direction connectivity, mark visited cells, track island sizes, and identify the largest region.

Apply dfs and bfs to traverse graph structures used by web crawlers, visiting every page linked by hrefs to gather data, enabling indexing and ranking by search engines.

Explore spanning trees and the minimum spanning tree (MST) in connected graphs, using MST to design reliable networks and handle traveling salesman and clustering via Prim's and Kruskal's.