Visualize Sequential & Parallel Computing Complexity.
Explore execution loops, processor communication topologies, and cost-complexity metrics in real-time. Learn the transition from linear RAM processing to complex PRAM networks, Ring, Mesh, and Hypercube hardware topologies.
Bubble Sort
A simple comparison-based sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order.
Selection Sort
An in-place comparison sort that divides the array into sorted and unsorted sections, repeatedly finding the smallest element from the unsorted section and placing it at the end of the sorted section.
Insertion Sort
Builds the final sorted array one item at a time by consuming one input element in each iteration and sliding it into its correct position.
Merge Sort
A divide-and-conquer algorithm that recursively splits the array into halves, sorts them, and merges the sorted halves back together.
Quick Sort
A divide-and-conquer algorithm that partitions an array around a pivot element, placing smaller items before it and larger items after, then recursively sorting the sub-arrays.
Heap Sort
An in-place comparison sort that uses a binary heap data structure to find the maximum element, swap it to the end of the array, and restore the heap property.
Radix Sort
A non-comparative sorting algorithm that sorts integers by grouping keys by individual digits that share the same significant position and value, typically starting from the least significant digit (LSD).
Bucket Sort
A non-comparative partition-based sort that distributes array elements into a number of buckets, sorts each bucket individually (e.g. using Insertion Sort), and then concatenates the sorted buckets.
Binary Search
An efficient algorithm for finding an item from a sorted list of items by repeatedly halving the search interval.
Breadth-First Search (BFS)
An algorithm for traversing or searching tree or graph data structures, exploring all nodes at the current depth before moving to nodes at the next depth level.
Depth-First Search (DFS)
An algorithm for traversing or searching tree or graph data structures, exploring as deep as possible along each branch before backtracking.
A* Search Algorithm
An informed pathfinding and graph traversal algorithm that uses heuristics to find the shortest path between nodes more efficiently than Dijkstra's algorithm.
Dijkstra's Algorithm
Finds the single-source shortest paths between nodes in a graph with non-negative edge weights.
Parallel Reduction (Sum)
An algorithm that combines a collection of values using an associative binary operator (like addition or maximum) in parallel, constructing a binary tree of evaluations in O(log N) time steps.
Parallel Prefix Sum (Scan)
Computes all prefix sums (cumulative running totals) of a sequence. Uses the Hillis-Steele algorithm to aggregate elements in O(log N) steps using N processors.
Bitonic Sort
A parallel comparison-based sorting network that constructs and sorts bitonic sequences (sequences that increase then decrease). Designed to run efficiently on Hypercubes or parallel GPUs.
Odd-Even Transposition Sort
A parallel version of Bubble Sort running on a Ring or 1D array of processors. Alternates between odd-even and even-odd index comparisons, sorting the array in O(N) parallel steps.
Pointer Jumping (List Ranking)
A parallel technique for finding the distance of every node in a linked list to the end of the list. By updating pointers to parent of parent, it shrinks path lengths logarithmically.
Parallel BFS
A parallelized version of graph exploration that processes all frontier nodes concurrently, writing newly visited nodes to the next frontier in parallel.