Algorithm VisionMaster Algorithms

The most basic sorting algorithm that repeatedly compares adjacent elements and swaps them if they are in wrong order. Like bubbles rising to the surface, larger values gradually move to the end of the array. Best suited for small datasets or educational purposes to understand sorting fundamentals.

Finds the smallest element and moves it to the front repeatedly. Each iteration "selects" the minimum from remaining elements and places it after the sorted portion. Simple to implement with minimal memory usage, but always takes O(n²) time regardless of input.

A highly efficient sorting algorithm that selects a pivot element and partitions the array with smaller values on the left and larger on the right. Averages O(n log n) and is the most widely used sorting method in practice. Forms the foundation of built-in sort functions in most programming languages.

Uses a binary heap data structure by first building a max heap, then repeatedly extracting the root element to sort. Guarantees O(n log n) time complexity in all cases without requiring extra memory. Also serves as the foundation for priority queue implementations.

A non-comparison sorting algorithm that counts occurrences of each element and uses arithmetic to determine positions. Achieves O(n+k) time complexity where k is the range of input values. Ideal for sorting integers within a known, limited range. Forms the basis for radix sort.

A non-comparison sorting algorithm that processes elements digit by digit from least significant to most significant. Uses counting sort as a subroutine for each digit position. Achieves O(d(n+k)) time where d is the number of digits. Excellent for sorting integers or fixed-length strings.

An optimization of insertion sort that allows exchange of elements that are far apart. Uses a gap sequence that decreases to 1, enabling the algorithm to move elements closer to their final positions faster. Named after Donald Shell who invented it in 1959.

A distribution-based sorting algorithm that distributes elements into a number of buckets. Each bucket is then sorted individually using another sorting algorithm. Works best when input is uniformly distributed over a range. Average time complexity is O(n+k).

A divide-and-conquer algorithm that splits the array in half, sorts each half recursively, then merges them back together. Guarantees O(n log n) time and is stable, but requires additional memory. Particularly effective for large datasets and linked list sorting.

Works like sorting playing cards in your hands - inserting each element one at a time into its proper position. Runs in O(n) time for already sorted data, making it highly efficient for small arrays or nearly sorted datasets. Simple yet adaptive algorithm.

Improvement over bubble sort that eliminates small values near the end of the list (turtles). Uses a shrinking gap sequence starting with array length, improving worst-case complexity. Practical for medium-sized datasets where simple implementation is valued over optimal performance.

Simple sorting algorithm similar to insertion sort, named after the way garden gnomes sort flower pots. Moves backward when elements are out of order, then forward again. While O(n²) like bubble sort, its simplicity makes it useful for teaching sorting concepts and handling small datasets.

Highly efficient search method that compares the target with the middle element and repeatedly halves the search space. With O(log n) time, it can find an item in 1 million elements in just 20 comparisons. Works like looking up words in a dictionary.

The most basic search method that checks each element sequentially from start to end. Used for unsorted data or small arrays where simplicity matters. Implementation is straightforward, but becomes slow with large datasets requiring O(n) time.

Explores a graph level by level, visiting all vertices at the current depth before moving deeper. Uses a queue and is ideal for finding shortest paths in unweighted graphs. Applications include maze solving, social network analysis, and finding connections between nodes.

Explores a graph by going as deep as possible along each path before backtracking. Implemented using a stack or recursion, making it natural for recursive problems. Used for pathfinding, cycle detection, topological sorting, and maze generation.

Finds the shortest paths from a single source vertex to all other vertices in a weighted graph. Powers GPS navigation systems and network routing protocols. Works efficiently with non-negative edge weights using a greedy approach with a priority queue.

A best-first search algorithm that finds the shortest path using heuristics. Combines Dijkstra's algorithm and greedy best-first search using f(n) = g(n) + h(n). Widely used in games, robotics, and GPS navigation for efficient pathfinding.

Finds the Minimum Spanning Tree (MST) of a weighted undirected graph. Uses a greedy approach by sorting edges by weight and adding them if they don't create a cycle. Employs Union-Find for efficient cycle detection. Essential for network design and clustering.

Finds the Minimum Spanning Tree (MST) by growing a tree from a starting vertex. Always adds the minimum weight edge connecting a vertex in the tree to one outside. Uses a priority queue for efficient edge selection. Ideal for dense graphs.

Orders vertices of a Directed Acyclic Graph (DAG) such that for every edge u→v, u comes before v. Uses DFS-based approach. Essential for dependency resolution, build systems, and course scheduling.

Google's algorithm for ranking web pages by link structure. Computes importance scores iteratively.

Also known as the 'tortoise and hare' algorithm, this elegant technique detects cycles in linked lists or sequences using O(1) space. Uses two pointers moving at different speeds—if there's a cycle, they will eventually meet. Essential for detecting infinite loops, analyzing graph structures, and validating data integrity.

Single-source shortest path algorithm that handles negative weights and detects negative cycles. Relaxes all edges V-1 times to guarantee correct distances even with negative weights. Essential for currency arbitrage detection, network routing with varied costs, and situations where Dijkstra's algorithm fails. Trades speed for flexibility.

All-pairs shortest path algorithm that computes distances between every pair of vertices in O(V³) time. Uses dynamic programming with elegant three-line core logic. Handles negative weights and provides transitive closure. Ideal for dense graphs, network analysis, and when all pairwise distances are needed.

Greedy algorithm that builds a minimum spanning tree by adding edges in order of increasing weight, using union-find to avoid cycles. Efficient for sparse graphs with time complexity O(E log E). Applications include network design, clustering, approximation algorithms, and understanding greedy correctness proofs.

Greedy algorithm that grows a minimum spanning tree by repeatedly adding the cheapest edge connecting the tree to a new vertex. Uses a priority queue for efficiency with O(E log V) time. Preferred for dense graphs and real-time applications like network broadcasting and circuit design.

Knuth-Morris-Pratt algorithm for efficient pattern matching in strings. Uses a failure function (LPS array) to skip unnecessary comparisons, achieving O(n+m) time complexity. Essential for text search, DNA sequence analysis, and plagiarism detection.

Efficient string searching algorithm using bad character and good suffix heuristics. Compares pattern from right to left, allowing large jumps on mismatch. Achieves sublinear time in practice, making it one of the fastest string matching algorithms.

Finds the optimal way to parenthesize a chain of matrices to minimize the number of scalar multiplications. Classic dynamic programming problem from CLRS Chapter 15.

Computes Fibonacci numbers efficiently using dynamic programming to avoid redundant calculations. Demonstrates the power of memoization in transforming an exponential-time recursive solution into a linear-time algorithm. A classic introduction to dynamic programming concepts.

Finds the longest subsequence present in two sequences in the same order. Uses dynamic programming to build a solution table. Applications include DNA sequence alignment, file difference tools (diff), and plagiarism detection.

Dynamic programming algorithm that calculates the minimum number of single-character edits (insertions, deletions, substitutions) required to transform one string into another. Fundamental in spell checking, DNA sequence alignment, and natural language processing.

Classic dynamic programming problem where you must select items with given weights and values to maximize total value while staying within a weight capacity. Each item can only be taken once (0/1). Applications include resource allocation, portfolio optimization, and cargo loading.

Find the longest subsequence where all elements are in increasing order. Classic DP problem.

Elegant dynamic programming algorithm that finds the contiguous subarray with maximum sum in O(n) time. Combines greedy and DP principles by deciding at each step whether to extend the current subarray or start a new one. Essential for stock profit optimization, signal processing, and understanding DP optimization techniques.

Classic dynamic programming problem that finds the minimum number of coins needed to make a target amount. Demonstrates optimal substructure where the solution depends on solutions to smaller amounts. Widely applied in financial systems, vending machines, and resource allocation optimization.

Dynamic programming problem that finds the minimum number of cuts needed to partition a string into palindromic substrings. Uses DP to precompute which substrings are palindromes, then finds optimal cuts. Applications include text segmentation, DNA sequence analysis, and string optimization problems.

Place N chess queens on an N×N chessboard so no two queens threaten each other. A classic backtracking algorithm.

Find all prime numbers up to n by iteratively marking composites. Named after Eratosthenes of Cyrene (c. 276-194 BC).

Triangular array of binomial coefficients where each number is the sum of the two numbers directly above it. Named after Blaise Pascal (1623-1662), though known to mathematicians centuries earlier. Demonstrates beautiful mathematical patterns including binomial expansion, combinatorics, and connections to Fibonacci numbers.

Ancient algorithm from around 300 BC that efficiently computes the greatest common divisor of two integers. Based on the principle that GCD(a, b) = GCD(b, a mod b). One of the oldest algorithms in continuous use, forming the foundation of number theory, cryptography, and fraction simplification.

Extends the Euclidean algorithm to find integers x and y satisfying Bézout's identity: ax + by = GCD(a, b). Not only computes GCD but also finds the coefficients of linear combinations. Fundamental to modular arithmetic, RSA cryptography, and solving linear Diophantine equations.

Fundamental unsupervised machine learning algorithm for partitioning data into k clusters. Iteratively assigns points to nearest centroids and updates centroid positions. Widely used in customer segmentation, image compression, and exploratory data analysis.

Tree-based data structure that stores strings efficiently by sharing common prefixes. Each path from root to leaf represents a word or key. Excels at autocomplete, spell checking, IP routing tables, and dictionary implementations with O(m) operations where m is key length.

Finds the deepest node that is an ancestor of two given nodes in a tree. Fundamental operation in tree queries with applications in computational biology (species evolution), network routing, and version control systems. Various algorithms offer different time-space tradeoffs.

First self-balancing binary search tree invented in 1962 by Adelson-Velsky and Landis. Maintains height balance through rotations, guaranteeing O(log n) operations. Stricter balancing than red-black trees makes it ideal for lookup-heavy applications like databases and file systems.

Select the maximum number of non-overlapping activities. Classic greedy algorithm that always picks the activity finishing earliest.