Data Structures & Algorithms

Analyse algorithm time and space efficiencies using Big O boundary notations.

Explore sequential element access, subsegment manipulations, insertion, deletion, and 2D grid matrix walks.

Learn the Last-In, First-Out (LIFO) stack data structure with pushing, popping, and structural queries.

Understand the First-In, First-Out (FIFO) queue buffers, enqueueing, and dequeueing animations.

Visualize ring buffer queues optimizing index array space via circular wrap pointers.

Interact with double-ended queue insertion and deletion flows at both head and rear points.

Interact with linear chain node arrays, traversal, head/tail adjustments, and index operations.

Visualize node linkages referencing both previous and next pointers supporting bidirectional walks.

Understand node loops where the tail pointer links back to the head node to form a closed circle.

Contrast contiguous index array memory slots vs scattered linked node chains.

Explore hierarchical parent-child nodes, traversal modes (in-order, pre-order, post-order), and search lookups.

Observe recursive visiting orders (Inorder, Preorder, Postorder) over node trees.

Understand min and max heap properties, tree structure balance, and heapify up/down actions.

Visualize key hashing functions, index mapping arrays, and hash collision resolution techniques.

Learn networks of vertex nodes connected by edges, tracing pathways and adjacency list structures.

Store and search character nodes for quick prefix-based autocomplete lookup maps.

Scan elements sequentially one-by-one, comparing each value with the search target.

Divide and conquer sorted datasets, converging left/right indices to isolate target values.

Trace step-by-step element sorting where adjacent values bubble to their correct positions.

Iteratively select the minimum value from the unsorted segment, swapping it to the front.

Build a sorted slice incrementally, inserting each unsorted value into its correct slot.

Recursively split arrays into single segments, merging them back in sorted sequence order.

Partition array segments around pivot points to sort items in logarithmic average time.

Construct a binary heap, extract the root element repeatedly, and restore heap properties.

Sort numbers digit-by-digit from least to most significant, distributing values into buckets.

Traverse complex graph networks using level-order queues and depth-first stacks.

Find path distances from a single source to all vertex nodes using weight matrix tables.

Build a minimum spanning tree from sorted graph edges utilizing Union-Find cycle checks.

Observe compiler stack frames tracking self-referencing operations and tree calculations.

Solve value optimization limits within size thresholds using dynamic programming caches.

Solve sequence alignment matching limits by dynamically constructing a 2D cache grid.

Trace converging indices from boundary endpoints inward to solve target value arrays.

Track contiguous subarrays of a larger array using start/end boundary pointers to avoid redundant recalculations.

Place N non-attacking queens on a chessboard grid using recursive backtracking constraints.

Find the minimum weight cyclic path visiting every node city exactly once and returning to source.