Easy to Advanced Data Structures

Explore static and dynamic arrays, their memory layout, indexing, and common operations; learn how dynamic arrays resize and why access is constant time while insertion and deletion may be linear.

Explore the dynamic array source code, including generics, capacity management, and a resize-by-doubling strategy. Implement add, remove, index, contains, and an iterator with toString, constructor options, and internal array handling.

Examine singly and doubly linked lists, their head and tail pointers, and how insertion and removal work, comparing memory use and time complexity.

Explore a doubly linked list implementation in Java, detailing head and tail management, node pointers, and core operations: add, remove, peek, clear, index queries, and iteration.

Explains what a stack is, its push and pop operations, and its LIFO behavior. Shows real-world uses and a preview of implementation, time complexity, and source code.

Learn stack implementations using singly and doubly linked lists, pushing before the head and popping by moving the head pointer. Examine memory management and deallocation in Java and C/C++.

Explore a concise Java stack implemented with a linked list, featuring push, pop, peek, empty-stack handling, two constructors, size, isEmpty, and an iterator with concurrent modification handling.

Explore queues as a linear data structure with front and back, enqueuing and dequeuing, and real-world uses like web servers and graph search, with constant-time peek.

Explore breadth-first search on graphs and learn practical queue implementation using a doubly linked list, including enqueuing, dequeuing, marking visited, and expanding frontiers node by node.

Explore a Java queue implementation with a doubly linked list, including constructors, size, isEmpty, peek, poll, and offer, and compare it to static array queues for performance.

Explore priority queues, their uses, and how heaps enable efficient implementations. Learn about binary heaps, sinking and swimming, poll and add operations, and their complexity implications.

Remove elements from a binary heap by polling root, swapping with last node, and bubbling down to maintain the heap invariant using a hash table to map values to indices.

Explore the source code of a priority queue implemented as a binary heap, with add, peek, poll, remove, and optional map-based containment; includes swim and sink and heapify operations.

Explore the union find data structure, its find and union operations, and path compression, illustrated with magnets, and see its role in minimum spanning trees, grid percolation, and connectivity.

Explore the union and find operations in the union-find (disjoint set) data structure, including mapping objects to integers, maintaining a parent array, and merging components by root nodes.

Explore path compression in union-find to achieve amortized constant time by compressing paths to the root and making lookups instantaneous.

Examine the union find source code, covering id and size arrays, root discovery with path compression, and union operations that merge smaller into larger components for efficiency.

Remove elements from a binary search tree in two phases: find node, replace it with its successor to preserve the binary search tree invariant, handling leaf, single-subtree, and two-subtree cases.

Explore preorder, inorder, and postorder traversals of binary trees and binary search trees, and implement level order traversal using a queue for breadth-first search.

Explore the binary search tree source code in Java, covering insertion, removal, contains checks, height, and interactive traversals (preorder, inorder, postorder) with iterators for easy to advanced data structures course.

Explore hash tables and separate chaining as a collision resolution method, using linked lists to store colliding entries, with lookups, insertions, and rehashing explained.

Explore separate chaining hash tables in Java by examining entry and hash table classes, hash code caching, bucket indexing, insert, get, remove, and dynamic resize.

Explore open addressing for hash tables and how probing sequences resolve collisions. Learn about load factor alpha, table size, and probing methods like linear, quadratic, and double hashing.

Explore hash tables with open addressing and quadratic probing. Learn how p(x) functions shape collisions, cycles, and table resizing, and apply prime or power-of-two table sizes to ensure progress.

Explore hash tables using double hashing with open addressing. Learn how the probing function combines x and h2(k), handles delta to avoid cycles, and resizes on threshold.

Analyze hash table open addressing with quadratic probing, tombstones, and resizing; examine source code using separate key and value arrays.

Discover how Fenwick trees enable fast range queries with prefix sums, while supporting point updates and linear-time construction in a one-based array, using least significant bits.

Explore Fenwick trees and point updates, using the least significant bit to update indices on the path (e.g., 6, 8, 16) and relate to prefix sums and range queries.