{"id":20432725,"url":"https://github.com/realabbas/list-of-algorithms","last_synced_at":"2026-02-25T12:43:10.557Z","repository":{"id":134776234,"uuid":"221649689","full_name":"realabbas/list-of-algorithms","owner":"realabbas","description":"A comprehensive curated list of  algorithms🤠 🏆","archived":false,"fork":false,"pushed_at":"2019-11-14T09:04:54.000Z","size":84,"stargazers_count":26,"open_issues_count":0,"forks_count":5,"subscribers_count":2,"default_branch":"master","last_synced_at":"2025-01-15T18:41:32.291Z","etag":null,"topics":["algorithms","coloring-algorithm","combinatorial-algorithms","computational-science","database-algorithms","distributed-algorithm","graph-algorithms","hopcroft-algorithm","information-theory","machine-learning-algorithm","search-algorithm"],"latest_commit_sha":null,"homepage":"","language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"cc0-1.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/realabbas.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"contributing.md","funding":null,"license":"LICENSE","code_of_conduct":"code-of-conduct.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2019-11-14T08:38:13.000Z","updated_at":"2024-11-22T21:46:57.000Z","dependencies_parsed_at":"2023-03-24T23:32:37.482Z","dependency_job_id":null,"html_url":"https://github.com/realabbas/list-of-algorithms","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/realabbas%2Flist-of-algorithms","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/realabbas%2Flist-of-algorithms/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/realabbas%2Flist-of-algorithms/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/realabbas%2Flist-of-algorithms/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/realabbas","download_url":"https://codeload.github.com/realabbas/list-of-algorithms/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":241975363,"owners_count":20051467,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["algorithms","coloring-algorithm","combinatorial-algorithms","computational-science","database-algorithms","distributed-algorithm","graph-algorithms","hopcroft-algorithm","information-theory","machine-learning-algorithm","search-algorithm"],"created_at":"2024-11-15T08:16:20.269Z","updated_at":"2026-02-25T12:43:05.524Z","avatar_url":"https://github.com/realabbas.png","language":null,"funding_links":[],"categories":[],"sub_categories":[],"readme":"List of algorithms 🏆\n=====================\n\nContents\n--------\n\n*   [1 Automated planning](#Automated_planning)\n*   [2 Combinatorial algorithms](#Combinatorial_algorithms)\n    *   [2.1 General combinatorial algorithms](#General_combinatorial_algorithms)\n    *   [2.2 Graph algorithms](#Graph_algorithms)\n        *   [2.2.1 Graph drawing](#Graph_drawing)\n        *   [2.2.2 Network theory](#Network_theory)\n        *   [2.2.3 Routing for graphs](#Routing_for_graphs)\n        *   [2.2.4 Graph search](#Graph_search)\n        *   [2.2.5 Subgraphs](#Subgraphs)\n    *   [2.3 Sequence algorithms](#Sequence_algorithms)\n        *   [2.3.1 Approximate sequence matching](#Approximate_sequence_matching)\n        *   [2.3.2 Selection algorithms](#Selection_algorithms)\n        *   [2.3.3 Sequence search](#Sequence_search)\n        *   [2.3.4 Sequence merging](#Sequence_merging)\n        *   [2.3.5 Sequence permutations](#Sequence_permutations)\n        *   [2.3.6 Sequence alignment](#Sequence_alignment)\n        *   [2.3.7 Sequence sorting](#Sequence_sorting)\n        *   [2.3.8 Subsequences](#Subsequences)\n        *   [2.3.9 Substrings](#Substrings)\n*   [3 Computational mathematics](#Computational_mathematics)\n    *   [3.1 Abstract algebra](#Abstract_algebra)\n    *   [3.2 Computer algebra](#Computer_algebra)\n    *   [3.3 Geometry](#Geometry)\n    *   [3.4 Number theoretic algorithms](#Number_theoretic_algorithms)\n    *   [3.5 Numerical algorithms](#Numerical_algorithms)\n        *   [3.5.1 Differential equation solving](#Differential_equation_solving)\n        *   [3.5.2 Elementary and special functions](#Elementary_and_special_functions)\n        *   [3.5.3 Geometric](#Geometric)\n        *   [3.5.4 Interpolation and extrapolation](#Interpolation_and_extrapolation)\n        *   [3.5.5 Linear algebra](#Linear_algebra)\n        *   [3.5.6 Monte Carlo](#Monte_Carlo)\n        *   [3.5.7 Numerical integration](#Numerical_integration)\n        *   [3.5.8 Root finding](#Root_finding)\n    *   [3.6 Optimization algorithms](#Optimization_algorithms)\n*   [4 Computational science](#Computational_science)\n    *   [4.1 Astronomy](#Astronomy)\n    *   [4.2 Bioinformatics](#Bioinformatics)\n    *   [4.3 Geoscience](#Geoscience)\n    *   [4.4 Linguistics](#Linguistics)\n    *   [4.5 Medicine](#Medicine)\n    *   [4.6 Physics](#Physics)\n    *   [4.7 Statistics](#Statistics)\n*   [5 Computer science](#Computer_science)\n    *   [5.1 Computer architecture](#Computer_architecture)\n    *   [5.2 Computer graphics](#Computer_graphics)\n    *   [5.3 Cryptography](#Cryptography)\n    *   [5.4 Digital logic](#Digital_logic)\n    *   [5.5 Machine learning and statistical classification](#Machine_learning_and_statistical_classification)\n    *   [5.6 Programming language theory](#Programming_language_theory)\n        *   [5.6.1 Parsing](#Parsing)\n    *   [5.7 Quantum algorithms](#Quantum_algorithms)\n    *   [5.8 Theory of computation and automata](#Theory_of_computation_and_automata)\n*   [6 Information theory and signal processing](#Information_theory_and_signal_processing)\n    *   [6.1 Coding theory](#Coding_theory)\n        *   [6.1.1 Error detection and correction](#Error_detection_and_correction)\n        *   [6.1.2 Lossless compression algorithms](#Lossless_compression_algorithms)\n        *   [6.1.3 Lossy compression algorithms](#Lossy_compression_algorithms)\n    *   [6.2 Digital signal processing](#Digital_signal_processing)\n        *   [6.2.1 Image processing](#Image_processing)\n*   [7 Software engineering](#Software_engineering)\n*   [8 Database algorithms](#Database_algorithms)\n*   [9 Distributed systems algorithms](#Distributed_systems_algorithms)\n    *   [9.1 Memory allocation and deallocation algorithms](#Memory_allocation_and_deallocation_algorithms)\n*   [10 Networking](#Networking)\n*   [11 Operating systems algorithms](#Operating_systems_algorithms)\n    *   [11.1 Process synchronization](#Process_synchronization)\n    *   [11.2 Scheduling](#Scheduling)\n    *   [11.3 I/O scheduling](#I/O_scheduling)\n        *   [11.3.1 Disk scheduling](#Disk_scheduling)\n*   [12 See also](#See_also)\n*   [13 References](#References)\n\nAutomated planning\\[[edit](/w/index.php?title=List_of_algorithms\u0026action=edit\u0026section=1 \"Edit section: Automated planning\")\\]\n----------------------------------------------------------------------------------------------------------------------------\n\nFurther information: [List of algorithms for automated planning](https://en.wikipedia.org/wiki/List_of_algorithms_for_automated_planning \"List of algorithms for automated planning\")\n\nCombinatorial algorithms\\[[edit](/w/index.php?title=List_of_algorithms\u0026action=edit\u0026section=2 \"Edit section: Combinatorial algorithms\")\\]\n----------------------------------------------------------------------------------------------------------------------------------------\n\nFurther information: [Combinatorics](https://en.wikipedia.org/wiki/Combinatorics \"Combinatorics\")\n\n### General combinatorial algorithms\n\n*   [Brent's algorithm](https://en.wikipedia.org/wiki/Cycle_detection#Brent's_algorithm \"Cycle detection\"): finds a cycle in function value iterations using only two iterators\n*   [Floyd's cycle-finding algorithm](https://en.wikipedia.org/wiki/Floyd%27s_cycle-finding_algorithm \"Floyd's cycle-finding algorithm\"): finds a cycle in function value iterations\n*   [Gale–Shapley algorithm](https://en.wikipedia.org/wiki/Stable_marriage_problem \"Stable marriage problem\"): solves the stable marriage problem\n*   [Pseudorandom number generators](https://en.wikipedia.org/wiki/Pseudorandom_number_generator \"Pseudorandom number generator\") (uniformly distributed—see also [List of pseudorandom number generators](https://en.wikipedia.org/wiki/List_of_random_number_generators#Pseudorandom_number_generators_(PRNGs) \"List of random number generators\") for other PRNGs with varying degrees of convergence and varying statistical quality):\n    *   [ACORN generator](https://en.wikipedia.org/wiki/ACORN_(PRNG) \"ACORN (PRNG)\")\n    *   [Blum Blum Shub](https://en.wikipedia.org/wiki/Blum_Blum_Shub \"Blum Blum Shub\")\n    *   [Lagged Fibonacci generator](https://en.wikipedia.org/wiki/Lagged_Fibonacci_generator \"Lagged Fibonacci generator\")\n    *   [Linear congruential generator](https://en.wikipedia.org/wiki/Linear_congruential_generator \"Linear congruential generator\")\n    *   [Mersenne Twister](https://en.wikipedia.org/wiki/Mersenne_Twister \"Mersenne Twister\")\n\n### Graph algorithms\n\nFurther information: [Graph theory](https://en.wikipedia.org/wiki/Graph_theory \"Graph theory\") and [Category:Graph algorithms](https://en.wikipedia.org/wiki/Category:Graph_algorithms \"Category:Graph algorithms\")\n\n*   [Coloring algorithm](https://en.wikipedia.org/wiki/Coloring_algorithm \"Coloring algorithm\"): Graph coloring algorithm.\n*   [Hopcroft–Karp algorithm](https://en.wikipedia.org/wiki/Hopcroft%E2%80%93Karp_algorithm \"Hopcroft–Karp algorithm\"): convert a bipartite graph to a [maximum cardinality matching](https://en.wikipedia.org/wiki/Maximum_cardinality_matching \"Maximum cardinality matching\")\n*   [Hungarian algorithm](https://en.wikipedia.org/wiki/Hungarian_algorithm \"Hungarian algorithm\"): algorithm for finding a [perfect matching](https://en.wikipedia.org/wiki/Perfect_matching \"Perfect matching\")\n*   [Prüfer coding](https://en.wikipedia.org/wiki/Pr%C3%BCfer_sequence \"Prüfer sequence\"): conversion between a labeled tree and its [Prüfer sequence](https://en.wikipedia.org/wiki/Pr%C3%BCfer_sequence \"Prüfer sequence\")\n*   [Tarjan's off-line lowest common ancestors algorithm](https://en.wikipedia.org/wiki/Tarjan%27s_off-line_lowest_common_ancestors_algorithm \"Tarjan's off-line lowest common ancestors algorithm\"): compute [lowest common ancestors](https://en.wikipedia.org/wiki/Lowest_common_ancestor \"Lowest common ancestor\") for pairs of nodes in a tree\n*   [Topological sort](https://en.wikipedia.org/wiki/Topological_sorting \"Topological sorting\"): finds linear order of nodes (e.g. jobs) based on their dependencies.\n\n#### Graph drawing\n\nFurther information: [Graph drawing](https://en.wikipedia.org/wiki/Graph_drawing \"Graph drawing\")\n\n*   [Force-based algorithms](https://en.wikipedia.org/wiki/Force-based_algorithms_(graph_drawing) \"Force-based algorithms (graph drawing)\") (also known as force-directed algorithms or spring-based algorithm)\n*   [Spectral layout](https://en.wikipedia.org/wiki/Spectral_layout \"Spectral layout\")\n\n#### Network theory\n\nFurther information: [Network theory](https://en.wikipedia.org/wiki/Network_theory \"Network theory\")\n\n*   Network analysis\n    *   Link analysis\n        *   [Girvan–Newman algorithm](https://en.wikipedia.org/wiki/Girvan%E2%80%93Newman_algorithm \"Girvan–Newman algorithm\"): detect communities in complex systems\n        *   Web link analysis\n            *   [Hyperlink-Induced Topic Search](https://en.wikipedia.org/wiki/Hyperlink-Induced_Topic_Search \"Hyperlink-Induced Topic Search\") (HITS) (also known as [Hubs and authorities](https://en.wikipedia.org/wiki/Hubs_and_authorities \"Hubs and authorities\"))\n            *   [PageRank](https://en.wikipedia.org/wiki/PageRank \"PageRank\")\n            *   [TrustRank](https://en.wikipedia.org/wiki/TrustRank \"TrustRank\")\n*   [Flow networks](https://en.wikipedia.org/wiki/Flow_network \"Flow network\")\n    *   [Dinic's algorithm](https://en.wikipedia.org/wiki/Dinic%27s_algorithm \"Dinic's algorithm\"): is a [strongly polynomial](https://en.wikipedia.org/wiki/Strongly_polynomial \"Strongly polynomial\") algorithm for computing the [maximum flow](https://en.wikipedia.org/wiki/Maximum_flow \"Maximum flow\") in a [flow network](https://en.wikipedia.org/wiki/Flow_network \"Flow network\").\n    *   [Edmonds–Karp algorithm](https://en.wikipedia.org/wiki/Edmonds%E2%80%93Karp_algorithm \"Edmonds–Karp algorithm\"): implementation of Ford–Fulkerson\n    *   [Ford–Fulkerson algorithm](https://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm \"Ford–Fulkerson algorithm\"): computes the [maximum flow](https://en.wikipedia.org/wiki/Maximum_flow_problem \"Maximum flow problem\") in a graph\n    *   [Karger's algorithm](https://en.wikipedia.org/wiki/Karger%27s_algorithm \"Karger's algorithm\"): a Monte Carlo method to compute the [minimum cut](https://en.wikipedia.org/wiki/Minimum_cut \"Minimum cut\") of a connected graph\n    *   [Push–relabel algorithm](https://en.wikipedia.org/wiki/Push%E2%80%93relabel_algorithm \"Push–relabel algorithm\"): computes a [maximum flow](https://en.wikipedia.org/wiki/Maximum_flow_problem \"Maximum flow problem\") in a graph\n\n#### Routing for graphs\n\n*   [Edmonds' algorithm](https://en.wikipedia.org/wiki/Edmonds%27_algorithm \"Edmonds' algorithm\") (also known as Chu–Liu/Edmonds' algorithm): find maximum or minimum branchings\n*   [Euclidean minimum spanning tree](https://en.wikipedia.org/wiki/Euclidean_minimum_spanning_tree \"Euclidean minimum spanning tree\"): algorithms for computing the minimum spanning tree of a set of points in the plane\n*   [Euclidean shortest path problem](https://en.wikipedia.org/wiki/Euclidean_shortest_path_problem \"Euclidean shortest path problem\"): find the shortest path between two points that does not intersect any obstacle\n*   [Longest path problem](https://en.wikipedia.org/wiki/Longest_path_problem \"Longest path problem\"): find a simple path of maximum length in a given graph\n*   [Minimum spanning tree](https://en.wikipedia.org/wiki/Minimum_spanning_tree \"Minimum spanning tree\")\n    *   [Borůvka's algorithm](https://en.wikipedia.org/wiki/Bor%C5%AFvka%27s_algorithm \"Borůvka's algorithm\")\n    *   [Kruskal's algorithm](https://en.wikipedia.org/wiki/Kruskal%27s_algorithm \"Kruskal's algorithm\")\n    *   [Prim's algorithm](https://en.wikipedia.org/wiki/Prim%27s_algorithm \"Prim's algorithm\")\n    *   [Reverse-delete algorithm](https://en.wikipedia.org/wiki/Reverse-delete_algorithm \"Reverse-delete algorithm\")\n*   [Nonblocking minimal spanning switch](https://en.wikipedia.org/wiki/Nonblocking_minimal_spanning_switch \"Nonblocking minimal spanning switch\") say, for a [telephone exchange](https://en.wikipedia.org/wiki/Telephone_exchange \"Telephone exchange\")\n*   [Shortest path problem](https://en.wikipedia.org/wiki/Shortest_path_problem \"Shortest path problem\")\n    *   [Bellman–Ford algorithm](https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm \"Bellman–Ford algorithm\"): computes [shortest paths](https://en.wikipedia.org/wiki/Shortest_path_problem \"Shortest path problem\") in a weighted graph (where some of the edge weights may be negative)\n    *   [Dijkstra's algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm \"Dijkstra's algorithm\"): computes [shortest paths](https://en.wikipedia.org/wiki/Shortest_path_problem \"Shortest path problem\") in a graph with non-negative edge weights\n    *   [Floyd–Warshall algorithm](https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm \"Floyd–Warshall algorithm\"): solves the [all pairs shortest path](https://en.wikipedia.org/wiki/All_pairs_shortest_path \"All pairs shortest path\") problem in a weighted, directed graph\n    *   [Johnson's algorithm](https://en.wikipedia.org/wiki/Johnson%27s_algorithm \"Johnson's algorithm\"): All pairs shortest path algorithm in sparse weighted directed graph\n*   [Transitive closure](https://en.wikipedia.org/wiki/Transitive_closure \"Transitive closure\") problem: find the [transitive closure](https://en.wikipedia.org/wiki/Transitive_closure \"Transitive closure\") of a given binary relation\n*   [Traveling salesman problem](https://en.wikipedia.org/wiki/Traveling_salesman_problem \"Traveling salesman problem\")\n    *   [Christofides algorithm](https://en.wikipedia.org/wiki/Christofides_algorithm \"Christofides algorithm\")\n    *   [Nearest neighbour algorithm](https://en.wikipedia.org/wiki/Nearest_neighbour_algorithm \"Nearest neighbour algorithm\")\n*   [Warnsdorff's rule](https://en.wikipedia.org/wiki/Warnsdorff%27s_rule \"Warnsdorff's rule\"): A heuristic method for solving the [Knight's tour](https://en.wikipedia.org/wiki/Knight%27s_tour \"Knight's tour\") problem.\n\n#### Graph search\n\nFurther information: [State space search](https://en.wikipedia.org/wiki/State_space_search \"State space search\") and [Graph search algorithm](https://en.wikipedia.org/wiki/Graph_search_algorithm \"Graph search algorithm\")\n\n*   [A\\*](https://en.wikipedia.org/wiki/A*_search_algorithm \"A* search algorithm\"): special case of best-first search that uses heuristics to improve speed\n*   [B\\*](https://en.wikipedia.org/wiki/B* \"B*\"): a best-first graph search algorithm that finds the least-cost path from a given initial node to any goal node (out of one or more possible goals)\n*   [Backtracking](https://en.wikipedia.org/wiki/Backtracking \"Backtracking\"): abandons partial solutions when they are found not to satisfy a complete solution\n*   [Beam search](https://en.wikipedia.org/wiki/Beam_search \"Beam search\"): is a heuristic search algorithm that is an optimization of [best-first search](https://en.wikipedia.org/wiki/Best-first_search \"Best-first search\") that reduces its memory requirement\n*   [Beam stack search](https://en.wikipedia.org/wiki/Beam_stack_search \"Beam stack search\"): integrates backtracking with [beam search](https://en.wikipedia.org/wiki/Beam_search \"Beam search\")\n*   [Best-first search](https://en.wikipedia.org/wiki/Best-first_search \"Best-first search\"): traverses a graph in the order of likely importance using a [priority queue](https://en.wikipedia.org/wiki/Priority_queue \"Priority queue\")\n*   [Bidirectional search](https://en.wikipedia.org/wiki/Bidirectional_search \"Bidirectional search\"): find the shortest path from an initial vertex to a goal vertex in a directed graph\n*   [Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search \"Breadth-first search\"): traverses a graph level by level\n*   [Brute-force search](https://en.wikipedia.org/wiki/Brute-force_search \"Brute-force search\"): An exhaustive and reliable search method, but computationally inefficient in many applications.\n*   [D\\*](https://en.wikipedia.org/wiki/D* \"D*\"): an [incremental heuristic search](https://en.wikipedia.org/wiki/Incremental_heuristic_search \"Incremental heuristic search\") algorithm\n*   [Depth-first search](https://en.wikipedia.org/wiki/Depth-first_search \"Depth-first search\"): traverses a graph branch by branch\n*   [Dijkstra's algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm \"Dijkstra's algorithm\"): A special case of A\\* for which no heuristic function is used\n*   [General Problem Solver](https://en.wikipedia.org/wiki/General_Problem_Solver \"General Problem Solver\"): a seminal theorem-proving algorithm intended to work as a universal problem solver machine.\n*   [Iterative deepening depth-first search](https://en.wikipedia.org/wiki/Iterative_deepening_depth-first_search \"Iterative deepening depth-first search\") (IDDFS): a state space search strategy\n*   [Jump point search](https://en.wikipedia.org/wiki/Jump_point_search \"Jump point search\"): An optimization to A\\* which may reduce computation time by an order of magnitude using further heuristics.\n*   [Lexicographic breadth-first search](https://en.wikipedia.org/wiki/Lexicographic_breadth-first_search \"Lexicographic breadth-first search\") (also known as Lex-BFS): a linear time algorithm for ordering the vertices of a graph\n*   [Uniform-cost search](https://en.wikipedia.org/wiki/Uniform-cost_search \"Uniform-cost search\"): a [tree search](https://en.wikipedia.org/wiki/Tree_traversal \"Tree traversal\") that finds the lowest-cost route where costs vary\n*   [SSS\\*](https://en.wikipedia.org/wiki/SSS* \"SSS*\"): state space search traversing a game tree in a best-first fashion similar to that of the A\\* search algorithm\n*   [F\\*](/w/index.php?title=F*_Merge_Algorithm\u0026action=edit\u0026redlink=1 \"F* Merge Algorithm (page does not exist)\"): Special algorithm to merge the two arrays\n\n#### Subgraphs\n\n*   [Cliques](https://en.wikipedia.org/wiki/Clique_(graph_theory) \"Clique (graph theory)\")\n    *   [Bron–Kerbosch algorithm](https://en.wikipedia.org/wiki/Bron%E2%80%93Kerbosch_algorithm \"Bron–Kerbosch algorithm\"): a technique for finding [maximal cliques](https://en.wikipedia.org/wiki/Maximal_clique \"Maximal clique\") in an undirected graph\n    *   [MaxCliqueDyn maximum clique algorithm](https://en.wikipedia.org/wiki/MaxCliqueDyn_maximum_clique_algorithm \"MaxCliqueDyn maximum clique algorithm\"): find a [maximum clique](https://en.wikipedia.org/wiki/Maximum_clique \"Maximum clique\") in an undirected graph\n*   [Strongly connected components](https://en.wikipedia.org/wiki/Strongly_connected_components \"Strongly connected components\")\n    *   [Path-based strong component algorithm](https://en.wikipedia.org/wiki/Path-based_strong_component_algorithm \"Path-based strong component algorithm\")\n    *   [Kosaraju's algorithm](https://en.wikipedia.org/wiki/Kosaraju%27s_algorithm \"Kosaraju's algorithm\")\n    *   [Tarjan's strongly connected components algorithm](https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm \"Tarjan's strongly connected components algorithm\")\n*   [Subgraph isomorphism problem](https://en.wikipedia.org/wiki/Subgraph_isomorphism_problem \"Subgraph isomorphism problem\")\n\n### Sequence algorithms\n\nFurther information: [Sequences](https://en.wikipedia.org/wiki/Sequences \"Sequences\")\n\n#### Approximate sequence matching\n\n*   [Bitap algorithm](https://en.wikipedia.org/wiki/Bitap_algorithm \"Bitap algorithm\"): fuzzy algorithm that determines if strings are approximately equal.\n*   [Phonetic algorithms](https://en.wikipedia.org/wiki/Phonetic_algorithm \"Phonetic algorithm\")\n    *   [Daitch–Mokotoff Soundex](https://en.wikipedia.org/wiki/Daitch%E2%80%93Mokotoff_Soundex \"Daitch–Mokotoff Soundex\"): a [Soundex](https://en.wikipedia.org/wiki/Soundex \"Soundex\") refinement which allows matching of Slavic and Germanic surnames\n    *   [Double Metaphone](https://en.wikipedia.org/wiki/Double_Metaphone \"Double Metaphone\"): an improvement on Metaphone\n    *   [Match rating approach](https://en.wikipedia.org/wiki/Match_rating_approach \"Match rating approach\"): a phonetic algorithm developed by Western Airlines\n    *   [Metaphone](https://en.wikipedia.org/wiki/Metaphone \"Metaphone\"): an algorithm for indexing words by their sound, when pronounced in English\n    *   [NYSIIS](https://en.wikipedia.org/wiki/New_York_State_Identification_and_Intelligence_System \"New York State Identification and Intelligence System\"): [phonetic algorithm](https://en.wikipedia.org/wiki/Phonetic_algorithm \"Phonetic algorithm\"), improves on [Soundex](https://en.wikipedia.org/wiki/Soundex \"Soundex\")\n    *   [Soundex](https://en.wikipedia.org/wiki/Soundex \"Soundex\"): a phonetic algorithm for indexing names by sound, as pronounced in English\n*   [String metrics](https://en.wikipedia.org/wiki/String_metric \"String metric\"): compute a similarity or dissimilarity (distance) score between two pairs of text strings\n    *   [Damerau–Levenshtein distance](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance \"Damerau–Levenshtein distance\") compute a distance measure between two strings, improves on [Levenshtein distance](https://en.wikipedia.org/wiki/Levenshtein_distance \"Levenshtein distance\")\n    *   [Dice's coefficient](https://en.wikipedia.org/wiki/Dice%27s_coefficient \"Dice's coefficient\") (also known as the Dice coefficient): a similarity measure related to the [Jaccard index](https://en.wikipedia.org/wiki/Jaccard_index \"Jaccard index\")\n    *   [Hamming distance](https://en.wikipedia.org/wiki/Hamming_distance \"Hamming distance\"): sum number of positions which are different\n    *   [Jaro–Winkler distance](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance \"Jaro–Winkler distance\"): is a measure of similarity between two strings\n    *   [Levenshtein edit distance](https://en.wikipedia.org/wiki/Levenshtein_distance \"Levenshtein distance\"): compute a metric for the amount of difference between two sequences\n*   [Trigram search](https://en.wikipedia.org/wiki/Trigram_search \"Trigram search\"): search for text when the exact syntax or spelling of the target object is not precisely known\n\n#### Selection algorithms\n\nMain article: [Selection algorithm](https://en.wikipedia.org/wiki/Selection_algorithm \"Selection algorithm\")\n\n*   [Quickselect](https://en.wikipedia.org/wiki/Quickselect \"Quickselect\")\n*   [Introselect](https://en.wikipedia.org/wiki/Introselect \"Introselect\")\n\n#### Sequence search\n\n*   [Linear search](https://en.wikipedia.org/wiki/Linear_search \"Linear search\"): finds an item in an unsorted sequence\n*   [Selection algorithm](https://en.wikipedia.org/wiki/Selection_algorithm \"Selection algorithm\"): finds the _k_th largest item in a sequence\n*   [Ternary search](https://en.wikipedia.org/wiki/Ternary_search \"Ternary search\"): a technique for finding the minimum or maximum of a function that is either strictly increasing and then strictly decreasing or vice versa\n*   [Sorted lists](https://en.wikipedia.org/wiki/Sorted_list \"Sorted list\")\n    *   [Binary search algorithm](https://en.wikipedia.org/wiki/Binary_search_algorithm \"Binary search algorithm\"): locates an item in a sorted sequence\n    *   [Fibonacci search technique](https://en.wikipedia.org/wiki/Fibonacci_search_technique \"Fibonacci search technique\"): search a sorted sequence using a divide and conquer algorithm that narrows down possible locations with the aid of [Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_numbers \"Fibonacci numbers\")\n    *   [Jump search](https://en.wikipedia.org/wiki/Jump_search \"Jump search\") (or block search): linear search on a smaller subset of the sequence\n    *   [Predictive search](https://en.wikipedia.org/wiki/Interpolation_search \"Interpolation search\"): binary-like search which factors in [magnitude](https://en.wikipedia.org/wiki/Magnitude_(mathematics) \"Magnitude (mathematics)\") of search term versus the high and low values in the search. Sometimes called dictionary search or interpolated search.\n    *   [Uniform binary search](https://en.wikipedia.org/wiki/Uniform_binary_search \"Uniform binary search\"): an optimization of the classic binary search algorithm\n\n#### Sequence merging\n\nMain article: [Merge algorithm](https://en.wikipedia.org/wiki/Merge_algorithm \"Merge algorithm\")\n\n*   Simple merge algorithm\n*   k-way merge algorithm\n*   Union (merge, with elements on the output not repeated)\n\n#### Sequence permutations\n\nFurther information: [Permutation](https://en.wikipedia.org/wiki/Permutation \"Permutation\")\n\n*   [Fisher–Yates shuffle](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle \"Fisher–Yates shuffle\") (also known as the Knuth shuffle): randomly shuffle a finite set\n*   [Schensted algorithm](https://en.wikipedia.org/wiki/Schensted_algorithm \"Schensted algorithm\"): constructs a pair of [Young tableaux](https://en.wikipedia.org/wiki/Young_tableau \"Young tableau\") from a permutation\n*   [Steinhaus–Johnson–Trotter algorithm](https://en.wikipedia.org/wiki/Steinhaus%E2%80%93Johnson%E2%80%93Trotter_algorithm \"Steinhaus–Johnson–Trotter algorithm\") (also known as the Johnson–Trotter algorithm): generate permutations by transposing elements\n*   [Heap's permutation generation algorithm](https://en.wikipedia.org/wiki/Heap%27s_algorithm \"Heap's algorithm\"): interchange elements to generate next permutation\n\n#### Sequence alignment\n\n*   [Dynamic time warping](https://en.wikipedia.org/wiki/Dynamic_time_warping \"Dynamic time warping\"): measure similarity between two sequences which may vary in time or speed\n*   [Hirschberg's algorithm](https://en.wikipedia.org/wiki/Hirschberg%27s_algorithm \"Hirschberg's algorithm\"): finds the least cost [sequence alignment](https://en.wikipedia.org/wiki/Sequence_alignment \"Sequence alignment\") between two sequences, as measured by their [Levenshtein distance](https://en.wikipedia.org/wiki/Levenshtein_distance \"Levenshtein distance\")\n*   [Needleman–Wunsch algorithm](https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm \"Needleman–Wunsch algorithm\"): find global alignment between two sequences\n*   [Smith–Waterman algorithm](https://en.wikipedia.org/wiki/Smith%E2%80%93Waterman_algorithm \"Smith–Waterman algorithm\"): find local sequence alignment\n\n#### Sequence sorting\n\nMain article: [Sorting algorithm](https://en.wikipedia.org/wiki/Sorting_algorithm \"Sorting algorithm\")\n\n![Accuracy dispute](//upload.wikimedia.org/wikipedia/commons/thumb/2/2e/Ambox_contradict.svg/40px-Ambox_contradict.svg.png \"Accuracy dispute\")\n\nThis article **appears to contradict the article [Sorting\\_algorithm#Comparison\\_of\\_algorithms](https://en.wikipedia.org/wiki/Sorting_algorithm#Comparison_of_algorithms \"Sorting algorithm\")**. Please see discussion on the linked [talk page](https://en.wikipedia.org/wiki/Talk:List_of_algorithms \"Talk:List of algorithms\"). _(March 2011)_ _([Learn how and when to remove this template message](https://en.wikipedia.org/wiki/Help:Maintenance_template_removal \"Help:Maintenance template removal\"))_\n\n*   Exchange sorts\n    *   [Bubble sort](https://en.wikipedia.org/wiki/Bubble_sort \"Bubble sort\"): for each pair of indices, swap the items if out of order\n    *   [Cocktail shaker sort](https://en.wikipedia.org/wiki/Cocktail_shaker_sort \"Cocktail shaker sort\") or bidirectional bubble sort, a bubble sort traversing the list alternately from front to back and back to front\n    *   [Comb sort](https://en.wikipedia.org/wiki/Comb_sort \"Comb sort\")\n    *   [Gnome sort](https://en.wikipedia.org/wiki/Gnome_sort \"Gnome sort\")\n    *   [Odd–even sort](https://en.wikipedia.org/wiki/Odd%E2%80%93even_sort \"Odd–even sort\")\n    *   [Quicksort](https://en.wikipedia.org/wiki/Quicksort \"Quicksort\"): divide list into two, with all items on the first list coming before all items on the second list.; then sort the two lists. Often the method of choice\n*   Humorous or ineffective\n    *   [Bogosort](https://en.wikipedia.org/wiki/Bogosort \"Bogosort\")\n    *   [Stooge sort](https://en.wikipedia.org/wiki/Stooge_sort \"Stooge sort\")\n*   Hybrid\n    *   [Flashsort](https://en.wikipedia.org/wiki/Flashsort \"Flashsort\")\n    *   [Introsort](https://en.wikipedia.org/wiki/Introsort \"Introsort\"): begin with quicksort and switch to heapsort when the recursion depth exceeds a certain level\n    *   [Timsort](https://en.wikipedia.org/wiki/Timsort \"Timsort\"): adaptative algorithm derived from merge sort and insertion sort. Used in Python 2.3 and up, and Java SE 7.\n*   Insertion sorts\n    *   [Insertion sort](https://en.wikipedia.org/wiki/Insertion_sort \"Insertion sort\"): determine where the current item belongs in the list of sorted ones, and insert it there\n    *   [Library sort](https://en.wikipedia.org/wiki/Library_sort \"Library sort\")\n    *   [Patience sorting](https://en.wikipedia.org/wiki/Patience_sorting \"Patience sorting\")\n    *   [Shell sort](https://en.wikipedia.org/wiki/Shellsort \"Shellsort\"): an attempt to improve insertion sort\n    *   [Tree sort](https://en.wikipedia.org/wiki/Tree_sort \"Tree sort\") (binary tree sort): build binary tree, then traverse it to create sorted list\n    *   [Cycle sort](https://en.wikipedia.org/wiki/Cycle_sort \"Cycle sort\"): in-place with theoretically optimal number of writes\n*   Merge sorts\n    *   [Merge sort](https://en.wikipedia.org/wiki/Merge_sort \"Merge sort\"): sort the first and second half of the list separately, then merge the sorted lists\n    *   [Strand sort](https://en.wikipedia.org/wiki/Strand_sort \"Strand sort\")\n*   Non-comparison sorts\n    *   [Bead sort](https://en.wikipedia.org/wiki/Bead_sort \"Bead sort\")\n    *   [Bucket sort](https://en.wikipedia.org/wiki/Bucket_sort \"Bucket sort\")\n    *   [Burstsort](https://en.wikipedia.org/wiki/Burstsort \"Burstsort\"): build a compact, cache efficient [burst trie](/w/index.php?title=Burst_trie\u0026action=edit\u0026redlink=1 \"Burst trie (page does not exist)\") and then traverse it to create sorted output\n    *   [Counting sort](https://en.wikipedia.org/wiki/Counting_sort \"Counting sort\")\n    *   [Pigeonhole sort](https://en.wikipedia.org/wiki/Pigeonhole_sort \"Pigeonhole sort\")\n    *   [Postman sort](https://en.wikipedia.org/wiki/Postman_sort \"Postman sort\"): variant of Bucket sort which takes advantage of hierarchical structure\n    *   [Radix sort](https://en.wikipedia.org/wiki/Radix_sort \"Radix sort\"): sorts strings letter by letter\n*   Selection sorts\n    *   [Heapsort](https://en.wikipedia.org/wiki/Heapsort \"Heapsort\"): convert the list into a heap, keep removing the largest element from the heap and adding it to the end of the list\n    *   [Selection sort](https://en.wikipedia.org/wiki/Selection_sort \"Selection sort\"): pick the smallest of the remaining elements, add it to the end of the sorted list\n    *   [Smoothsort](https://en.wikipedia.org/wiki/Smoothsort \"Smoothsort\")\n*   Other\n    *   [Bitonic sorter](https://en.wikipedia.org/wiki/Bitonic_sorter \"Bitonic sorter\")\n    *   [Pancake sorting](https://en.wikipedia.org/wiki/Pancake_sorting \"Pancake sorting\")\n    *   [Spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort \"Spaghetti sort\")\n    *   [Topological sort](https://en.wikipedia.org/wiki/Topological_sorting \"Topological sorting\")\n*   Unknown class\n    *   [Samplesort](https://en.wikipedia.org/wiki/Samplesort \"Samplesort\")\n\n#### Subsequences\n\nFurther information: [Subsequence](https://en.wikipedia.org/wiki/Subsequence \"Subsequence\")\n\n*   [Kadane's algorithm](https://en.wikipedia.org/wiki/Kadane%27s_algorithm \"Kadane's algorithm\"): finds maximum sub-array of any size\n*   [Longest common subsequence problem](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem \"Longest common subsequence problem\"): Find the longest subsequence common to all sequences in a set of sequences\n*   [Longest increasing subsequence problem](https://en.wikipedia.org/wiki/Longest_increasing_subsequence_problem \"Longest increasing subsequence problem\"): Find the longest increasing subsequence of a given sequence\n*   [Shortest common supersequence problem](https://en.wikipedia.org/wiki/Shortest_common_supersequence_problem \"Shortest common supersequence problem\"): Find the shortest supersequence that contains two or more sequences as subsequences\n\n#### Substrings\n\nFurther information: [Substring](https://en.wikipedia.org/wiki/Substring \"Substring\")\n\n*   [Longest common substring problem](https://en.wikipedia.org/wiki/Longest_common_substring_problem \"Longest common substring problem\"): find the longest string (or strings) that is a substring (or are substrings) of two or more strings\n*   [Substring search](https://en.wikipedia.org/wiki/Substring_search \"Substring search\")\n    *   [Aho–Corasick string matching algorithm](https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_string_matching_algorithm \"Aho–Corasick string matching algorithm\"): [trie](https://en.wikipedia.org/wiki/Trie \"Trie\") based algorithm for finding all substring matches to any of a finite set of strings\n    *   [Boyer–Moore string-search algorithm](https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string-search_algorithm \"Boyer–Moore string-search algorithm\"): amortized linear ([sublinear](https://en.wikipedia.org/wiki/Sublinear \"Sublinear\") in most times) algorithm for substring search\n    *   [Boyer–Moore–Horspool algorithm](https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore%E2%80%93Horspool_algorithm \"Boyer–Moore–Horspool algorithm\"): Simplification of Boyer–Moore\n    *   [Knuth–Morris–Pratt algorithm](https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm \"Knuth–Morris–Pratt algorithm\"): substring search which bypasses reexamination of matched characters\n    *   [Rabin–Karp string search algorithm](https://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_string_search_algorithm \"Rabin–Karp string search algorithm\"): searches multiple patterns efficiently\n    *   [Zhu–Takaoka string matching algorithm](https://en.wikipedia.org/wiki/Zhu%E2%80%93Takaoka_string_matching_algorithm \"Zhu–Takaoka string matching algorithm\"): a variant of Boyer–Moore\n*   [Ukkonen's algorithm](https://en.wikipedia.org/wiki/Ukkonen%27s_algorithm \"Ukkonen's algorithm\"): a [linear-time](https://en.wikipedia.org/wiki/Linear-time \"Linear-time\"), [online algorithm](https://en.wikipedia.org/wiki/Online_algorithm \"Online algorithm\") for constructing [suffix trees](https://en.wikipedia.org/wiki/Suffix_tree \"Suffix tree\")\n*   [Matching wildcards](https://en.wikipedia.org/wiki/Matching_wildcards \"Matching wildcards\")\n    *   [Rich Salz](https://en.wikipedia.org/wiki/InterNetNews \"InterNetNews\")' [wildmat](https://en.wikipedia.org/wiki/Wildmat \"Wildmat\"): a widely used [open-source](https://en.wikipedia.org/wiki/Open-source_software \"Open-source software\") [recursive](https://en.wikipedia.org/wiki/Recursion \"Recursion\") algorithm\n    *   [Krauss matching wildcards algorithm](https://en.wikipedia.org/wiki/Krauss_matching_wildcards_algorithm \"Krauss matching wildcards algorithm\"): an open-source non-recursive algorithm\n\nComputational mathematics\\[[edit](/w/index.php?title=List_of_algorithms\u0026action=edit\u0026section=20 \"Edit section: Computational mathematics\")\\]\n-------------------------------------------------------------------------------------------------------------------------------------------\n\nFurther information: [Computational mathematics](https://en.wikipedia.org/wiki/Computational_mathematics \"Computational mathematics\")\n\nSee also: [Combinatorial algorithms](https://en.wikipedia.org/wiki/List_of_algorithms#Combinatorial_algorithms \"List of algorithms\") and [Computational science](https://en.wikipedia.org/wiki/List_of_algorithms#Computational_science \"List of algorithms\")\n\n### Abstract algebra\n\nFurther information: [Abstract algebra](https://en.wikipedia.org/wiki/Abstract_algebra \"Abstract algebra\")\n\n*   [Chien search](https://en.wikipedia.org/wiki/Chien_search \"Chien search\"): a recursive algorithm for determining roots of polynomials defined over a finite field\n*   [Schreier–Sims algorithm](https://en.wikipedia.org/wiki/Schreier%E2%80%93Sims_algorithm \"Schreier–Sims algorithm\"): computing a base and [strong generating set](https://en.wikipedia.org/wiki/Strong_generating_set \"Strong generating set\") (BSGS) of a [permutation group](https://en.wikipedia.org/wiki/Permutation_group \"Permutation group\")\n*   [Todd–Coxeter algorithm](https://en.wikipedia.org/wiki/Todd%E2%80%93Coxeter_algorithm \"Todd–Coxeter algorithm\"): Procedure for generating [cosets](https://en.wikipedia.org/wiki/Coset \"Coset\").\n\n### Computer algebra\n\nFurther information: [Computer algebra](https://en.wikipedia.org/wiki/Computer_algebra \"Computer algebra\")\n\n*   [Buchberger's algorithm](https://en.wikipedia.org/wiki/Buchberger%27s_algorithm \"Buchberger's algorithm\"): finds a [Gröbner basis](https://en.wikipedia.org/wiki/Gr%C3%B6bner_basis \"Gröbner basis\")\n*   [Cantor–Zassenhaus algorithm](https://en.wikipedia.org/wiki/Cantor%E2%80%93Zassenhaus_algorithm \"Cantor–Zassenhaus algorithm\"): factor polynomials over finite fields\n*   [Faugère F4 algorithm](https://en.wikipedia.org/wiki/Faug%C3%A8re_F4_algorithm \"Faugère F4 algorithm\"): finds a Gröbner basis (also mentions the F5 algorithm)\n*   [Gosper's algorithm](https://en.wikipedia.org/wiki/Gosper%27s_algorithm \"Gosper's algorithm\"): find sums of hypergeometric terms that are themselves hypergeometric terms\n*   [Knuth–Bendix completion algorithm](https://en.wikipedia.org/wiki/Knuth%E2%80%93Bendix_completion_algorithm \"Knuth–Bendix completion algorithm\"): for [rewriting](https://en.wikipedia.org/wiki/Rewriting \"Rewriting\") rule systems\n*   [Multivariate division algorithm](https://en.wikipedia.org/wiki/Multivariate_division_algorithm \"Multivariate division algorithm\"): for [polynomials](https://en.wikipedia.org/wiki/Polynomial \"Polynomial\") in several indeterminates\n*   [Pollard's kangaroo algorithm](https://en.wikipedia.org/wiki/Pollard%27s_kangaroo_algorithm \"Pollard's kangaroo algorithm\") (also known as Pollard's lambda algorithm ): an algorithm for solving the discrete logarithm problem\n*   [Polynomial long division](https://en.wikipedia.org/wiki/Polynomial_long_division \"Polynomial long division\"): an algorithm for dividing a polynomial by another polynomial of the same or lower degree\n*   [Risch algorithm](https://en.wikipedia.org/wiki/Risch_algorithm \"Risch algorithm\"): an algorithm for the calculus operation of indefinite integration (i.e. finding [antiderivatives](https://en.wikipedia.org/wiki/Antiderivatives \"Antiderivatives\"))\n\n### Geometry\n\nMain category: [Geometric algorithms](https://en.wikipedia.org/wiki/Category:Geometric_algorithms \"Category:Geometric algorithms\")\n\nFurther information: [Computational geometry](https://en.wikipedia.org/wiki/Computational_geometry \"Computational geometry\")\n\n*   [Closest pair problem](https://en.wikipedia.org/wiki/Closest_pair_problem \"Closest pair problem\"): find the pair of points (from a set of points) with the smallest distance between them\n*   [Collision detection](https://en.wikipedia.org/wiki/Collision_detection \"Collision detection\") algorithms: check for the collision or intersection of two given solids\n*   [Cone algorithm](https://en.wikipedia.org/wiki/Cone_algorithm \"Cone algorithm\"): identify surface points\n*   [Convex hull algorithms](https://en.wikipedia.org/wiki/Convex_hull_algorithms \"Convex hull algorithms\"): determining the [convex hull](https://en.wikipedia.org/wiki/Convex_hull \"Convex hull\") of a [set](https://en.wikipedia.org/wiki/Set_(mathematics) \"Set (mathematics)\") of points\n    *   [Graham scan](https://en.wikipedia.org/wiki/Graham_scan \"Graham scan\")\n    *   [Quickhull](https://en.wikipedia.org/wiki/Quickhull \"Quickhull\")\n    *   [Gift wrapping algorithm](https://en.wikipedia.org/wiki/Gift_wrapping_algorithm \"Gift wrapping algorithm\") or Jarvis march\n    *   [Chan's algorithm](https://en.wikipedia.org/wiki/Chan%27s_algorithm \"Chan's algorithm\")\n    *   [Kirkpatrick–Seidel algorithm](https://en.wikipedia.org/wiki/Kirkpatrick%E2%80%93Seidel_algorithm \"Kirkpatrick–Seidel algorithm\")\n*   [Euclidean distance transform](https://en.wikipedia.org/wiki/Euclidean_distance_map \"Euclidean distance map\"): computes the distance between every point in a grid and a discrete collection of points.\n*   [Geometric hashing](https://en.wikipedia.org/wiki/Geometric_hashing \"Geometric hashing\"): a method for efficiently finding two-dimensional objects represented by discrete points that have undergone an [affine transformation](https://en.wikipedia.org/wiki/Affine_transformation \"Affine transformation\")\n*   [Gilbert–Johnson–Keerthi distance algorithm](https://en.wikipedia.org/wiki/Gilbert%E2%80%93Johnson%E2%80%93Keerthi_distance_algorithm \"Gilbert–Johnson–Keerthi distance algorithm\"): determining the smallest distance between two [convex](https://en.wikipedia.org/wiki/Convex_set \"Convex set\") shapes.\n*   [Jump-and-Walk algorithm](https://en.wikipedia.org/wiki/Jump-and-Walk_algorithm \"Jump-and-Walk algorithm\"): an algorithm for point location in triangulations\n*   [Laplacian smoothing](https://en.wikipedia.org/wiki/Laplacian_smoothing \"Laplacian smoothing\"): an algorithm to smooth a polygonal mesh\n*   [Line segment intersection](https://en.wikipedia.org/wiki/Line_segment_intersection \"Line segment intersection\"): finding whether lines intersect, usually with a [sweep line algorithm](https://en.wikipedia.org/wiki/Sweep_line_algorithm \"Sweep line algorithm\")\n    *   [Bentley–Ottmann algorithm](https://en.wikipedia.org/wiki/Bentley%E2%80%93Ottmann_algorithm \"Bentley–Ottmann algorithm\")\n    *   [Shamos–Hoey algorithm](/w/index.php?title=Shamos%E2%80%93Hoey_algorithm\u0026action=edit\u0026redlink=1 \"Shamos–Hoey algorithm (page does not exist)\")\n*   [Minimum bounding box algorithms](https://en.wikipedia.org/wiki/Minimum_bounding_box_algorithms \"Minimum bounding box algorithms\"): find the [oriented minimum bounding box](https://en.wikipedia.org/wiki/Minimum_bounding_box#Arbitrarily_oriented_minimum_bounding_box \"Minimum bounding box\") enclosing a set of points\n*   [Nearest neighbor search](https://en.wikipedia.org/wiki/Nearest_neighbor_search \"Nearest neighbor search\"): find the nearest point or points to a query point\n*   [Point in polygon](https://en.wikipedia.org/wiki/Point_in_polygon \"Point in polygon\") algorithms: tests whether a given point lies within a given polygon\n*   [Point set registration](https://en.wikipedia.org/wiki/Point_set_registration \"Point set registration\") algorithms: finds the transformation between two [point sets](https://en.wikipedia.org/wiki/Point_cloud \"Point cloud\") to optimally align them.\n*   [Rotating calipers](https://en.wikipedia.org/wiki/Rotating_calipers \"Rotating calipers\"): determine all [antipodal](https://en.wikipedia.org/wiki/Antipodal_point \"Antipodal point\") pairs of points and vertices on a [convex polygon](https://en.wikipedia.org/wiki/Convex_polygon \"Convex polygon\") or [convex hull](https://en.wikipedia.org/wiki/Convex_hull \"Convex hull\").\n*   [Shoelace algorithm](https://en.wikipedia.org/wiki/Shoelace_algorithm \"Shoelace algorithm\"): determine the area of a polygon whose vertices are described by ordered pairs in the plane\n*   [Triangulation](https://en.wikipedia.org/wiki/Triangulation_(geometry) \"Triangulation (geometry)\")\n    *   [Delaunay triangulation](https://en.wikipedia.org/wiki/Delaunay_triangulation \"Delaunay triangulation\")\n        *   [Ruppert's algorithm](https://en.wikipedia.org/wiki/Ruppert%27s_algorithm \"Ruppert's algorithm\") (also known as Delaunay refinement): create quality Delaunay triangulations\n        *   [Chew's second algorithm](https://en.wikipedia.org/wiki/Chew%27s_second_algorithm \"Chew's second algorithm\"): create quality [constrained Delaunay triangulations](https://en.wikipedia.org/wiki/Constrained_Delaunay_triangulation \"Constrained Delaunay triangulation\")\n    *   [Marching triangles](https://en.wikipedia.org/wiki/Marching_triangles \"Marching triangles\"): reconstruct two-dimensional surface geometry from an unstructured [point cloud](https://en.wikipedia.org/wiki/Point_cloud \"Point cloud\")\n    *   [Polygon triangulation](https://en.wikipedia.org/wiki/Polygon_triangulation \"Polygon triangulation\") algorithms: decompose a polygon into a set of triangles\n    *   [Voronoi diagrams](https://en.wikipedia.org/wiki/Voronoi_diagram \"Voronoi diagram\"), geometric [dual](https://en.wikipedia.org/wiki/Duality_(mathematics) \"Duality (mathematics)\") of [Delaunay triangulation](https://en.wikipedia.org/wiki/Delaunay_triangulation \"Delaunay triangulation\")\n        *   [Bowyer–Watson algorithm](https://en.wikipedia.org/wiki/Bowyer%E2%80%93Watson_algorithm \"Bowyer–Watson algorithm\"): create voronoi diagram in any number of dimensions\n        *   [Fortune's Algorithm](https://en.wikipedia.org/wiki/Fortune%27s_Algorithm \"Fortune's Algorithm\"): create voronoi diagram\n    *   [Quasitriangulation](https://en.wikipedia.org/wiki/Quasitriangulation \"Quasitriangulation\")\n\n### Number theoretic algorithms\n\nFurther information: [Number theory](https://en.wikipedia.org/wiki/Number_theory \"Number theory\")\n\n*   [Binary GCD algorithm](https://en.wikipedia.org/wiki/Binary_GCD_algorithm \"Binary GCD algorithm\"): Efficient way of calculating GCD.\n*   [Booth's multiplication algorithm](https://en.wikipedia.org/wiki/Booth%27s_multiplication_algorithm \"Booth's multiplication algorithm\")\n*   [Chakravala method](https://en.wikipedia.org/wiki/Chakravala_method \"Chakravala method\"): a cyclic algorithm to solve indeterminate quadratic equations, including [Pell's equation](https://en.wikipedia.org/wiki/Pell%27s_equation \"Pell's equation\")\n*   [Discrete logarithm](https://en.wikipedia.org/wiki/Discrete_logarithm \"Discrete logarithm\"):\n    *   [Baby-step giant-step](https://en.wikipedia.org/wiki/Baby-step_giant-step \"Baby-step giant-step\")\n    *   [Index calculus algorithm](https://en.wikipedia.org/wiki/Index_calculus_algorithm \"Index calculus algorithm\")\n    *   [Pollard's rho algorithm for logarithms](https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm_for_logarithms \"Pollard's rho algorithm for logarithms\")\n    *   [Pohlig–Hellman algorithm](https://en.wikipedia.org/wiki/Pohlig%E2%80%93Hellman_algorithm \"Pohlig–Hellman algorithm\")\n*   [Euclidean algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm \"Euclidean algorithm\"): computes the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor \"Greatest common divisor\")\n*   [Extended Euclidean algorithm](https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm \"Extended Euclidean algorithm\"): Also solves the equation _ax_ + _by_ = _c_.\n*   [Integer factorization](https://en.wikipedia.org/wiki/Integer_factorization \"Integer factorization\"): breaking an integer into its [prime](https://en.wikipedia.org/wiki/Prime_number \"Prime number\") factors\n    *   [Congruence of squares](https://en.wikipedia.org/wiki/Congruence_of_squares \"Congruence of squares\")\n    *   [Dixon's algorithm](https://en.wikipedia.org/wiki/Dixon%27s_algorithm \"Dixon's algorithm\")\n    *   [Fermat's factorization method](https://en.wikipedia.org/wiki/Fermat%27s_factorization_method \"Fermat's factorization method\")\n    *   [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve \"General number field sieve\")\n    *   [Lenstra elliptic curve factorization](https://en.wikipedia.org/wiki/Lenstra_elliptic_curve_factorization \"Lenstra elliptic curve factorization\")\n    *   [Pollard's _p_ − 1 algorithm](https://en.wikipedia.org/wiki/Pollard%27s_p_%E2%88%92_1_algorithm \"Pollard's p − 1 algorithm\")\n    *   [Pollard's rho algorithm](https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm \"Pollard's rho algorithm\")\n    *   [prime factorization algorithm](https://en.wikipedia.org/wiki/Prime_factorization_algorithm \"Prime factorization algorithm\")\n    *   [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve \"Quadratic sieve\")\n    *   [Shor's algorithm](https://en.wikipedia.org/wiki/Shor%27s_algorithm \"Shor's algorithm\")\n    *   [Special number field sieve](https://en.wikipedia.org/wiki/Special_number_field_sieve \"Special number field sieve\")\n    *   [Trial division](https://en.wikipedia.org/wiki/Trial_division \"Trial division\")\n*   [Multiplication algorithms](https://en.wikipedia.org/wiki/Multiplication_algorithm \"Multiplication algorithm\"): fast multiplication of two numbers\n    *   [Karatsuba algorithm](https://en.wikipedia.org/wiki/Karatsuba_algorithm \"Karatsuba algorithm\")\n    *   [Schönhage–Strassen algorithm](https://en.wikipedia.org/wiki/Sch%C3%B6nhage%E2%80%93Strassen_algorithm \"Schönhage–Strassen algorithm\")\n    *   [Toom–Cook multiplication](https://en.wikipedia.org/wiki/Toom%E2%80%93Cook_multiplication \"Toom–Cook multiplication\")\n*   [Modular square root](https://en.wikipedia.org/wiki/Modular_square_root \"Modular square root\"): computing square roots modulo a prime number\n    *   [Tonelli–Shanks algorithm](https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm \"Tonelli–Shanks algorithm\")\n    *   [Cipolla's algorithm](https://en.wikipedia.org/wiki/Cipolla%27s_algorithm \"Cipolla's algorithm\")\n    *   [Berlekamp's root finding algorithm](https://en.wikipedia.org/wiki/Berlekamp%27s_root_finding_algorithm \"Berlekamp's root finding algorithm\")\n*   [Odlyzko–Schönhage algorithm](https://en.wikipedia.org/wiki/Odlyzko%E2%80%93Sch%C3%B6nhage_algorithm \"Odlyzko–Schönhage algorithm\"): calculates nontrivial zeroes of the [Riemann zeta function](https://en.wikipedia.org/wiki/Riemann_zeta_function \"Riemann zeta function\")\n*   [Lenstra–Lenstra–Lovász algorithm](https://en.wikipedia.org/wiki/Lenstra%E2%80%93Lenstra%E2%80%93Lov%C3%A1sz_lattice_basis_reduction_algorithm \"Lenstra–Lenstra–Lovász lattice basis reduction algorithm\") (also known as LLL algorithm): find a short, nearly orthogonal [lattice](https://en.wikipedia.org/wiki/Lattice_(group) \"Lattice (group)\") [basis](https://en.wikipedia.org/wiki/Basis_(linear_algebra) \"Basis (linear algebra)\") in polynomial time\n*   [Primality tests](https://en.wikipedia.org/wiki/Primality_test \"Primality test\"): determining whether a given number is [prime](https://en.wikipedia.org/wiki/Prime_number \"Prime number\")\n    *   [AKS primality test](https://en.wikipedia.org/wiki/AKS_primality_test \"AKS primality test\")\n    *   [Baillie-PSW primality test](https://en.wikipedia.org/wiki/Baillie-PSW_primality_test \"Baillie-PSW primality test\")\n    *   [Fermat primality test](https://en.wikipedia.org/wiki/Fermat_primality_test \"Fermat primality test\")\n    *   [Lucas primality test](https://en.wikipedia.org/wiki/Lucas_primality_test \"Lucas primality test\")\n    *   [Miller–Rabin primality test](https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test \"Miller–Rabin primality test\")\n    *   [Sieve of Atkin](https://en.wikipedia.org/wiki/Sieve_of_Atkin \"Sieve of Atkin\")\n    *   [Sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes \"Sieve of Eratosthenes\")\n    *   [Sieve of Sundaram](https://en.wikipedia.org/wiki/Sieve_of_Sundaram \"Sieve of Sundaram\")\n\n### Numerical algorithms\n\nFurther information: [Numerical analysis](https://en.wikipedia.org/wiki/Numerical_analysis \"Numerical analysis\") and [List of numerical analysis topics](https://en.wikipedia.org/wiki/List_of_numerical_analysis_topics \"List of numerical analysis topics\")\n\n#### Differential equation solving\n\nFurther information: [Differential equation](https://en.wikipedia.org/wiki/Differential_equation \"Differential equation\")\n\n*   [Euler method](https://en.wikipedia.org/wiki/Euler_method \"Euler method\")\n*   [Backward Euler method](https://en.wikipedia.org/wiki/Backward_Euler_method \"Backward Euler method\")\n*   [Trapezoidal rule (differential equations)](https://en.wikipedia.org/wiki/Trapezoidal_rule_(differential_equations) \"Trapezoidal rule (differential equations)\")\n*   [Linear multistep methods](https://en.wikipedia.org/wiki/Linear_multistep_method \"Linear multistep method\")\n*   [Runge–Kutta methods](https://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods \"Runge–Kutta methods\")\n    *   [Euler integration](https://en.wikipedia.org/wiki/Euler_integration \"Euler integration\")\n*   [Multigrid methods](https://en.wikipedia.org/wiki/Multigrid_method \"Multigrid method\") (MG methods), a group of algorithms for solving differential equations using a hierarchy of discretizations\n*   [Partial differential equation](https://en.wikipedia.org/wiki/Partial_differential_equation \"Partial differential equation\"):\n    *   [Finite difference method](https://en.wikipedia.org/wiki/Finite_difference_method \"Finite difference method\")\n    *   [Crank–Nicolson method](https://en.wikipedia.org/wiki/Crank%E2%80%93Nicolson_method \"Crank–Nicolson method\") for diffusion equations\n    *   [Lax-Wendroff](https://en.wikipedia.org/wiki/Lax%E2%80%93Wendroff_method \"Lax–Wendroff method\") for wave equations\n*   [Verlet integration](https://en.wikipedia.org/wiki/Verlet_integration \"Verlet integration\") (French pronunciation: ​[\\[vɛʁˈlɛ\\]](https://en.wikipedia.org/wiki/Help:IPA/French \"Help:IPA/French\")): integrate Newton's equations of motion\n\n#### Elementary and special functions\n\nFurther information: [Special functions](https://en.wikipedia.org/wiki/Special_functions \"Special functions\")\n\n*   [Computation of π](https://en.wikipedia.org/wiki/Computing_%CF%80 \"Computing π\"):\n    *   [Borwein's algorithm](https://en.wikipedia.org/wiki/Borwein%27s_algorithm \"Borwein's algorithm\"): an algorithm to calculate the value of 1/π\n    *   [Gauss–Legendre algorithm](https://en.wikipedia.org/wiki/Gauss%E2%80%93Legendre_algorithm \"Gauss–Legendre algorithm\"): computes the digits of [pi](https://en.wikipedia.org/wiki/Pi \"Pi\")\n    *   [Chudnovsky algorithm](https://en.wikipedia.org/wiki/Chudnovsky_algorithm \"Chudnovsky algorithm\"): A fast method for calculating the digits of π\n    *   [Bailey–Borwein–Plouffe formula](https://en.wikipedia.org/wiki/Bailey%E2%80%93Borwein%E2%80%93Plouffe_formula \"Bailey–Borwein–Plouffe formula\"): (BBP formula) a spigot algorithm for the computation of the nth binary digit of π\n*   [Division algorithms](https://en.wikipedia.org/wiki/Division_algorithm \"Division algorithm\"): for computing quotient and/or remainder of two numbers\n    *   [Long division](https://en.wikipedia.org/wiki/Long_division \"Long division\")\n    *   [Restoring division](https://en.wikipedia.org/wiki/Restoring_division \"Restoring division\")\n    *   [Non-restoring division](https://en.wikipedia.org/wiki/Non-restoring_division \"Non-restoring division\")\n    *   [SRT division](https://en.wikipedia.org/wiki/SRT_division \"SRT division\")\n    *   [Newton–Raphson division](https://en.wikipedia.org/wiki/Newton%E2%80%93Raphson_division \"Newton–Raphson division\"): uses [Newton's method](https://en.wikipedia.org/wiki/Newton%27s_method \"Newton's method\") to find the [reciprocal](https://en.wikipedia.org/wiki/Multiplicative_inverse \"Multiplicative inverse\") of D, and multiply that reciprocal by N to find the final quotient Q.\n    *   [Goldschmidt division](https://en.wikipedia.org/wiki/Goldschmidt_division \"Goldschmidt division\")\n*   Hyperbolic and Trigonometric Functions:\n    *   [BKM algorithm](https://en.wikipedia.org/wiki/BKM_algorithm \"BKM algorithm\"): compute [elementary functions](https://en.wikipedia.org/wiki/Elementary_function_(differential_algebra) \"Elementary function (differential algebra)\") using a table of logarithms\n    *   [CORDIC](https://en.wikipedia.org/wiki/CORDIC \"CORDIC\"): compute hyperbolic and trigonometric functions using a table of arctangents\n*   Exponentiation:\n    *   [Addition-chain exponentiation](https://en.wikipedia.org/wiki/Addition-chain_exponentiation \"Addition-chain exponentiation\"): exponentiation by positive integer powers that requires a minimal number of multiplications\n    *   [Exponentiating by squaring](https://en.wikipedia.org/wiki/Exponentiating_by_squaring \"Exponentiating by squaring\"): an algorithm used for the fast computation of [large integer](https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic \"Arbitrary-precision arithmetic\") powers of a number\n*   [Montgomery reduction](https://en.wikipedia.org/wiki/Montgomery_reduction \"Montgomery reduction\"): an algorithm that allows [modular arithmetic](https://en.wikipedia.org/wiki/Modular_arithmetic \"Modular arithmetic\") to be performed efficiently when the modulus is large\n*   [Multiplication algorithms](https://en.wikipedia.org/wiki/Multiplication_algorithm \"Multiplication algorithm\"): fast multiplication of two numbers\n    *   [Booth's multiplication algorithm](https://en.wikipedia.org/wiki/Booth%27s_multiplication_algorithm \"Booth's multiplication algorithm\"): a multiplication algorithm that multiplies two signed binary numbers in two's complement notation\n    *   [Fürer's algorithm](https://en.wikipedia.org/wiki/F%C3%BCrer%27s_algorithm \"Fürer's algorithm\"): an integer multiplication algorithm for very large numbers possessing a very low [asymptotic complexity](https://en.wikipedia.org/wiki/Computational_complexity_theory \"Computational complexity theory\")\n    *   [Karatsuba algorithm](https://en.wikipedia.org/wiki/Karatsuba_algorithm \"Karatsuba algorithm\"): an efficient procedure for multiplying large numbers\n    *   [Schönhage–Strassen algorithm](https://en.wikipedia.org/wiki/Sch%C3%B6nhage%E2%80%93Strassen_algorithm \"Schönhage–Strassen algorithm\"): an asymptotically fast multiplication algorithm for large integers\n    *   [Toom–Cook multiplication](https://en.wikipedia.org/wiki/Toom%E2%80%93Cook_multiplication \"Toom–Cook multiplication\"): (Toom3) a multiplication algorithm for large integers\n*   [Multiplicative inverse Algorithms](https://en.wikipedia.org/wiki/Multiplicative_inverse#Algorithms \"Multiplicative inverse\"): for computing a number's multiplicative inverse (reciprocal).\n    *   [Newton's method](https://en.wikipedia.org/wiki/Newton%27s_method#Multiplicative_inverses_of_numbers_and_power_series \"Newton's method\")\n*   [Rounding functions](https://en.wikipedia.org/wiki/Rounding_functions \"Rounding functions\"): the classic ways to round numbers\n*   [Spigot algorithm](https://en.wikipedia.org/wiki/Spigot_algorithm \"Spigot algorithm\"): A way to compute the value of a [mathematical constant](https://en.wikipedia.org/wiki/Mathematical_constant \"Mathematical constant\") without knowing preceding digits\n*   Square and Nth root of a number:\n    *   [Alpha max plus beta min algorithm](https://en.wikipedia.org/wiki/Alpha_max_plus_beta_min_algorithm \"Alpha max plus beta min algorithm\"): an approximation of the square-root of the sum of two squares\n    *   [Methods of computing square roots](https://en.wikipedia.org/wiki/Methods_of_computing_square_roots \"Methods of computing square roots\")\n    *   [_n_th root algorithm](https://en.wikipedia.org/wiki/Nth_root_algorithm \"Nth root algorithm\")\n    *   [Shifting nth-root algorithm](https://en.wikipedia.org/wiki/Shifting_nth-root_algorithm \"Shifting nth-root algorithm\"): digit by digit root extraction\n*   Summation:\n    *   [Binary splitting](https://en.wikipedia.org/wiki/Binary_splitting \"Binary splitting\"): a [divide and conquer](https://en.wikipedia.org/wiki/Divide_and_conquer_algorithm \"Divide and conquer algorithm\") technique which speeds up the numerical evaluation of many types of series with rational terms\n    *   [Kahan summation algorithm](https://en.wikipedia.org/wiki/Kahan_summation_algorithm \"Kahan summation algorithm\"): a more accurate method of summing floating-point numbers\n*   [Unrestricted algorithm](https://en.wikipedia.org/wiki/Unrestricted_algorithm \"Unrestricted algorithm\")\n\n#### Geometric\n\n*   [Filtered back-projection](https://en.wikipedia.org/wiki/Radon_transform#Filtered_back-projection \"Radon transform\"): efficiently compute the inverse 2-dimensional [Radon transform](https://en.wikipedia.org/wiki/Radon_transform \"Radon transform\").\n*   [Level set method](https://en.wikipedia.org/wiki/Level_set_method \"Level set method\") (LSM): a numerical technique for tracking interfaces and shapes\n\n#### Interpolation and extrapolation\n\nFurther information: [Interpolation](https://en.wikipedia.org/wiki/Interpolation \"Interpolation\") and [Extrapolation](https://en.wikipedia.org/wiki/Extrapolation \"Extrapolation\")\n\n*   [Birkhoff interpolation](https://en.wikipedia.org/wiki/Birkhoff_interpolation \"Birkhoff interpolation\"): an extension of polynomial interpolation\n*   [Cubic interpolation](https://en.wikipedia.org/wiki/Cubic_interpolation \"Cubic interpolation\")\n*   [Hermite interpolation](https://en.wikipedia.org/wiki/Hermite_interpolation \"Hermite interpolation\")\n*   [Lagrange interpolation](https://en.wikipedia.org/wiki/Lagrange_interpolation \"Lagrange interpolation\"): interpolation using [Lagrange polynomials](https://en.wikipedia.org/wiki/Lagrange_polynomial \"Lagrange polynomial\")\n*   [Linear interpolation](https://en.wikipedia.org/wiki/Linear_interpolation \"Linear interpolation\"): a method of curve fitting using linear polynomials\n*   [Monotone cubic interpolation](https://en.wikipedia.org/wiki/Monotone_cubic_interpolation \"Monotone cubic interpolation\"): a variant of cubic interpolation that preserves monotonicity of the data set being interpolated.\n*   [Multivariate interpolation](https://en.wikipedia.org/wiki/Multivariate_interpolation \"Multivariate interpolation\")\n    *   [Bicubic interpolation](https://en.wikipedia.org/wiki/Bicubic_interpolation \"Bicubic interpolation\"), a generalization of [cubic interpolation](https://en.wikipedia.org/wiki/Cubic_interpolation \"Cubic interpolation\") to two dimensions\n    *   [Bilinear interpolation](https://en.wikipedia.org/wiki/Bilinear_interpolation \"Bilinear interpolation\"): an extension of [linear interpolation](https://en.wikipedia.org/wiki/Linear_interpolation \"Linear interpolation\") for interpolating functions of two variables on a regular grid\n    *   [Lanczos resampling](https://en.wikipedia.org/wiki/Lanczos_resampling \"Lanczos resampling\") (\"Lanzosh\"): a multivariate interpolation method used to compute new values for any digitally sampled data\n    *   [Nearest-neighbor interpolation](https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation \"Nearest-neighbor interpolation\")\n    *   [Tricubic interpolation](https://en.wikipedia.org/wiki/Tricubic_interpolation \"Tricubic interpolation\"), a generalization of [cubic interpolation](https://en.wikipedia.org/wiki/Cubic_interpolation \"Cubic interpolation\") to three dimensions\n*   [Pareto interpolation](https://en.wikipedia.org/wiki/Pareto_interpolation \"Pareto interpolation\"): a method of estimating the median and other properties of a population that follows a [Pareto distribution](https://en.wikipedia.org/wiki/Pareto_distribution \"Pareto distribution\").\n*   [Polynomial interpolation](https://en.wikipedia.org/wiki/Polynomial_interpolation \"Polynomial interpolation\")\n    *   [Neville's algorithm](https://en.wikipedia.org/wiki/Neville%27s_algorithm \"Neville's algorithm\")\n*   [Spline interpolation](https://en.wikipedia.org/wiki/Spline_interpolation \"Spline interpolation\"): Reduces error with [Runge's phenomenon](https://en.wikipedia.org/wiki/Runge%27s_phenomenon \"Runge's phenomenon\").\n    *   [De Boor algorithm](https://en.wikipedia.org/wiki/De_Boor_algorithm \"De Boor algorithm\"): [B-splines](https://en.wikipedia.org/wiki/B-spline \"B-spline\")\n    *   [De Casteljau's algorithm](https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm \"De Casteljau's algorithm\"): [Bézier curves](https://en.wikipedia.org/wiki/B%C3%A9zier_curve \"Bézier curve\")\n*   [Trigonometric interpolation](https://en.wikipedia.org/wiki/Trigonometric_interpolation \"Trigonometric interpolation\")\n\n#### Linear algebra\n\nFurther information: [Numerical linear algebra](https://en.wikipedia.org/wiki/Numerical_linear_algebra \"Numerical linear algebra\")\n\n*   [Eigenvalue algorithms](https://en.wikipedia.org/wiki/Eigenvalue_algorithm \"Eigenvalue algorithm\")\n    *   [Arnoldi iteration](https://en.wikipedia.org/wiki/Arnoldi_iteration \"Arnoldi iteration\")\n    *   [Inverse iteration](https://en.wikipedia.org/wiki/Inverse_iteration \"Inverse iteration\")\n    *   [Jacobi method](https://en.wikipedia.org/wiki/Jacobi_eigenvalue_algorithm \"Jacobi eigenvalue algorithm\")\n    *   [Lanczos iteration](https://en.wikipedia.org/wiki/Lanczos_iteration \"Lanczos iteration\")\n    *   [Power iteration](https://en.wikipedia.org/wiki/Power_iteration \"Power iteration\")\n    *   [QR algorithm](https://en.wikipedia.org/wiki/QR_algorithm \"QR algorithm\")\n    *   [Rayleigh quotient iteration](https://en.wikipedia.org/wiki/Rayleigh_quotient_iteration \"Rayleigh quotient iteration\")\n*   [Gram–Schmidt process](https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process \"Gram–Schmidt process\"): orthogonalizes a set of vectors\n*   [Matrix multiplication algorithms](https://en.wikipedia.org/wiki/Matrix_multiplication_algorithm \"Matrix multiplication algorithm\")\n    *   [Cannon's algorithm](https://en.wikipedia.org/wiki/Cannon%27s_algorithm \"Cannon's algorithm\"): a [distributed algorithm](https://en.wikipedia.org/wiki/Distributed_algorithm \"Distributed algorithm\") for [matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication \"Matrix multiplication\") especially suitable for computers laid out in an N × N mesh\n    *   [Coppersmith–Winograd algorithm](https://en.wikipedia.org/wiki/Coppersmith%E2%80%93Winograd_algorithm \"Coppersmith–Winograd algorithm\"): square [matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication \"Matrix multiplication\")\n    *   [Freivalds' algorithm](https://en.wikipedia.org/wiki/Freivalds%27_algorithm \"Freivalds' algorithm\"): a randomized algorithm used to verify matrix multiplication\n    *   [Strassen algorithm](https://en.wikipedia.org/wiki/Strassen_algorithm \"Strassen algorithm\"): faster [matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication \"Matrix multiplication\")\n\n*   Solving [systems of linear equations](https://en.wikipedia.org/wiki/System_of_linear_equations \"System of linear equations\")\n    *   [Biconjugate gradient method](https://en.wikipedia.org/wiki/Biconjugate_gradient_method \"Biconjugate gradient method\"): solves systems of linear equations\n    *   [Conjugate gradient](https://en.wikipedia.org/wiki/Conjugate_gradient \"Conjugate gradient\"): an algorithm for the numerical solution of particular systems of linear equations\n    *   [Gaussian elimination](https://en.wikipedia.org/wiki/Gaussian_elimination \"Gaussian elimination\")\n    *   [Gauss–Jordan elimination](https://en.wikipedia.org/wiki/Gauss%E2%80%93Jordan_elimination \"Gauss–Jordan elimination\"): solves systems of linear equations\n    *   [Gauss–Seidel method](https://en.wikipedia.org/wiki/Gauss%E2%80%93Seidel_method \"Gauss–Seidel method\"): solves systems of linear equations iteratively\n    *   [Levinson recursion](https://en.wikipedia.org/wiki/Levinson_recursion \"Levinson recursion\"): solves equation involving a [Toeplitz matrix](https://en.wikipedia.org/wiki/Toeplitz_matrix \"Toeplitz matrix\")\n    *   [Stone's method](https://en.wikipedia.org/wiki/Stone%27s_method \"Stone's method\"): also known as the strongly implicit procedure or SIP, is an algorithm for solving a sparse linear system of equations\n    *   [Successive over-relaxation](https://en.wikipedia.org/wiki/Successive_over-relaxation \"Successive over-relaxation\") (SOR): method used to speed up convergence of the [Gauss–Seidel method](https://en.wikipedia.org/wiki/Gauss%E2%80%93Seidel_method \"Gauss–Seidel method\")\n    *   [Tridiagonal matrix algorithm](https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm \"Tridiagonal matrix algorithm\") (Thomas algorithm): solves systems of tridiagonal equations\n*   [Sparse matrix](https://en.wikipedia.org/wiki/Sparse_matrix \"Sparse matrix\") algorithms\n    *   [Cuthill–McKee algorithm](https://en.wikipedia.org/wiki/Cuthill%E2%80%93McKee_algorithm \"Cuthill–McKee algorithm\"): reduce the [bandwidth](https://en.wikipedia.org/wiki/Bandwidth_(matrix_theory) \"Bandwidth (matrix theory)\") of a [symmetric sparse matrix](https://en.wikipedia.org/wiki/Symmetric_sparse_matrix \"Symmetric sparse matrix\")\n    *   [Minimum degree algorithm](https://en.wikipedia.org/wiki/Minimum_degree_algorithm \"Minimum degree algorithm\"): permute the rows and columns of a [symmetric sparse matrix](https://en.wikipedia.org/wiki/Symmetric_sparse_matrix \"Symmetric sparse matrix\") before applying the [Cholesky decomposition](https://en.wikipedia.org/wiki/Cholesky_decomposition \"Cholesky decomposition\")\n    *   [Symbolic Cholesky decomposition](https://en.wikipedia.org/wiki/Symbolic_Cholesky_decomposition \"Symbolic Cholesky decomposition\"): Efficient way of storing [sparse matrix](https://en.wikipedia.org/wiki/Sparse_matrix \"Sparse matrix\")\n\n#### Monte Carlo\n\nFurther information: [Monte Carlo method](https://en.wikipedia.org/wiki/Monte_Carlo_method \"Monte Carlo method\")\n\n*   [Gibbs sampling](https://en.wikipedia.org/wiki/Gibbs_sampling \"Gibbs sampling\"): generate a sequence of samples from the joint probability distribution of two or more random variables\n*   [Hybrid Monte Carlo](https://en.wikipedia.org/wiki/Hybrid_Monte_Carlo \"Hybrid Monte Carlo\"): generate a sequence of samples using [Hamiltonian](https://en.wikipedia.org/wiki/Hamiltonian_dynamics \"Hamiltonian dynamics\") weighted [Markov chain Monte Carlo](https://en.wikipedia.org/wiki/Markov_chain_Monte_Carlo \"Markov chain Monte Carlo\"), from a probability distribution which is difficult to sample directly.\n*   [Metropolis–Hastings algorithm](https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm \"Metropolis–Hastings algorithm\"): used to generate a sequence of samples from the [probability distribution](https://en.wikipedia.org/wiki/Probability_distribution \"Probability distribution\") of one or more variables\n*   [Wang and Landau algorithm](https://en.wikipedia.org/wiki/Wang_and_Landau_algorithm \"Wang and Landau algorithm\"): an extension of [Metropolis–Hastings algorithm](https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm \"Metropolis–Hastings algorithm\") sampling\n\n#### Numerical integration\n\nFurther information: [Numerical integration](https://en.wikipedia.org/wiki/Numerical_integration \"Numerical integration\")\n\n*   [MISER algorithm](https://en.wikipedia.org/wiki/MISER_algorithm \"MISER algorithm\"): Monte Carlo simulation, [numerical integration](https://en.wikipedia.org/wiki/Numerical_integration \"Numerical integration\")\n\n#### Root finding\n\nMain article: [Root-finding algorithm](https://en.wikipedia.org/wiki/Root-finding_algorithm \"Root-finding algorithm\")\n\n*   [Bisection method](https://en.wikipedia.org/wiki/Bisection_method \"Bisection method\")\n*   [False position method](https://en.wikipedia.org/wiki/False_position_method \"False position method\"): approximates roots of a function\n*   [Newton's method](https://en.wikipedia.org/wiki/Newton%27s_method \"Newton's method\"): finds zeros of functions with [calculus](https://en.wikipedia.org/wiki/Calculus \"Calculus\")\n*   [Halley's method](https://en.wikipedia.org/wiki/Halley%27s_method \"Halley's method\"): uses first and second derivatives\n*   [Secant method](https://en.wikipedia.org/wiki/Secant_method \"Secant method\"): 2-point, 1-sided\n*   [False position method](https://en.wikipedia.org/wiki/False_position_method \"False position method\") and Illinois method: 2-point, bracketing\n*   [Ridder's method](https://en.wikipedia.org/wiki/Ridder%27s_method \"Ridder's method\"): 3-point, exponential scaling\n*   [Muller's method](https://en.wikipedia.org/wiki/Muller%27s_method \"Muller's method\"): 3-point, quadratic interpolation\n\n### Optimization algorithms\n\nMain article: [Mathematical optimization](https://en.wikipedia.org/wiki/Mathematical_optimization \"Mathematical optimization\")\n\n*   [Alpha–beta pruning](https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning \"Alpha–beta pruning\"): search to reduce number of nodes in minimax algorithm\n*   [Branch and bound](https://en.wikipedia.org/wiki/Branch_and_bound \"Branch and bound\")\n*   [Bruss algorithm](https://en.wikipedia.org/wiki/Bruss_algorithm \"Bruss algorithm\"): see [odds algorithm](https://en.wikipedia.org/wiki/Odds_algorithm \"Odds algorithm\")\n*   [Chain matrix multiplication](https://en.wikipedia.org/wiki/Chain_matrix_multiplication \"Chain matrix multiplication\")\n*   [Combinatorial optimization](https://en.wikipedia.org/wiki/Combinatorial_optimization \"Combinatorial optimization\"): optimization problems where the set of feasible solutions is discrete\n    *   [Greedy randomized adaptive search procedure](https://en.wikipedia.org/wiki/Greedy_randomized_adaptive_search_procedure \"Greedy randomized adaptive search procedure\") (GRASP): successive constructions of a greedy randomized solution and subsequent iterative improvements of it through a local search\n    *   [Hungarian method](https://en.wikipedia.org/wiki/Hungarian_method \"Hungarian method\"): a combinatorial optimization algorithm which solves the [assignment problem](https://en.wikipedia.org/wiki/Assignment_problem \"Assignment problem\") in polynomial time\n*   [Constraint satisfaction](https://en.wikipedia.org/wiki/Constraint_satisfaction \"Constraint satisfaction\")\n    *   General algorithms for the constraint satisfaction\n        *   [AC-3 algorithm](https://en.wikipedia.org/wiki/AC-3_algorithm \"AC-3 algorithm\")\n        *   [Difference map algorithm](https://en.wikipedia.org/wiki/Difference_map_algorithm \"Difference map algorithm\")\n        *   [Min conflicts algorithm](https://en.wikipedia.org/wiki/Min_conflicts_algorithm \"Min conflicts algorithm\")\n    *   [Chaff algorithm](https://en.wikipedia.org/wiki/Chaff_algorithm \"Chaff algorithm\"): an algorithm for solving instances of the boolean satisfiability problem\n    *   [Davis–Putnam algorithm](https://en.wikipedia.org/wiki/Davis%E2%80%93Putnam_algorithm \"Davis–Putnam algorithm\"): check the validity of a first-order logic formula\n    *   [Davis–Putnam–Logemann–Loveland algorithm](https://en.wikipedia.org/wiki/DPLL_algorithm \"DPLL algorithm\") (DPLL): an algorithm for deciding the satisfiability of propositional logic formula in [conjunctive normal form](https://en.wikipedia.org/wiki/Conjunctive_normal_form \"Conjunctive normal form\"), i.e. for solving the [CNF-SAT](https://en.wikipedia.org/wiki/CNF-SAT \"CNF-SAT\") problem\n    *   [Exact cover](https://en.wikipedia.org/wiki/Exact_cover \"Exact cover\") problem\n        *   [Algorithm X](https://en.wikipedia.org/wiki/Algorithm_X \"Algorithm X\"): a [nondeterministic algorithm](https://en.wikipedia.org/wiki/Nondeterministic_algorithm \"Nondeterministic algorithm\")\n        *   [Dancing Links](https://en.wikipedia.org/wiki/Dancing_Links \"Dancing Links\"): an efficient implementation of Algorithm X\n*   [Cross-entropy method](https://en.wikipedia.org/wiki/Cross-entropy_method \"Cross-entropy method\"): a general Monte Carlo approach to combinatorial and continuous multi-extremal optimization and [importance sampling](https://en.wikipedia.org/wiki/Importance_sampling \"Importance sampling\")\n*   [Differential evolution](https://en.wikipedia.org/wiki/Differential_evolution \"Differential evolution\")\n*   [Dynamic Programming](https://en.wikipedia.org/wiki/Dynamic_Programming \"Dynamic Programming\"): problems exhibiting the properties of [overlapping subproblems](https://en.wikipedia.org/wiki/Overlapping_subproblem \"Overlapping subproblem\") and [optimal substructure](https://en.wikipedia.org/wiki/Optimal_substructure \"Optimal substructure\")\n*   [Ellipsoid method](https://en.wikipedia.org/wiki/Ellipsoid_method \"Ellipsoid method\"): is an algorithm for solving convex optimization problems\n*   [Evolutionary computation](https://en.wikipedia.org/wiki/Evolutionary_computation \"Evolutionary computation\"): optimization inspired by biological mechanisms of evolution\n    *   [Evolution strategy](https://en.wikipedia.org/wiki/Evolution_strategy \"Evolution strategy\")\n    *   [Gene expression programming](https://en.wikipedia.org/wiki/Gene_expression_programming \"Gene expression programming\")\n    *   [Genetic algorithms](https://en.wikipedia.org/wiki/Genetic_algorithms \"Genetic algorithms\")\n        *   [Fitness proportionate selection](https://en.wikipedia.org/wiki/Fitness_proportionate_selection \"Fitness proportionate selection\") - also known as roulette-wheel selection\n        *   [Stochastic universal sampling](https://en.wikipedia.org/wiki/Stochastic_universal_sampling \"Stochastic universal sampling\")\n        *   [Truncation selection](https://en.wikipedia.org/wiki/Truncation_selection \"Truncation selection\")\n        *   [Tournament selection](https://en.wikipedia.org/wiki/Tournament_selection \"Tournament selection\")\n    *   [Memetic algorithm](https://en.wikipedia.org/wiki/Memetic_algorithm \"Memetic algorithm\")\n    *   [Swarm intelligence](https://en.wikipedia.org/wiki/Swarm_intelligence \"Swarm intelligence\")\n        *   [Ant colony optimization](https://en.wikipedia.org/wiki/Ant_colony_optimization \"Ant colony optimization\")\n        *   [Bees algorithm](https://en.wikipedia.org/wiki/Bees_algorithm \"Bees algorithm\"): a search algorithm which mimics the food foraging behavior of swarms of honey bees\n        *   [Particle swarm](https://en.wikipedia.org/wiki/Particle_swarm_optimization \"Particle swarm optimization\")\n*   [golden section search](https://en.wikipedia.org/wiki/Golden_section_search \"Golden section search\"): an algorithm for finding the maximum of a real function\n*   [Gradient descent](https://en.wikipedia.org/wiki/Gradient_descent \"Gradient descent\")\n*   [Harmony search](https://en.wikipedia.org/wiki/Harmony_search \"Harmony search\") (HS): a [metaheuristic](https://en.wikipedia.org/wiki/Metaheuristic \"Metaheuristic\") algorithm mimicking the improvisation process of musicians\n*   [Interior point method](https://en.wikipedia.org/wiki/Interior_point_method \"Interior point method\")\n*   [Linear programming](https://en.wikipedia.org/wiki/Linear_programming \"Linear programming\")\n    *   [Benson's algorithm](https://en.wikipedia.org/wiki/Benson%27s_algorithm \"Benson's algorithm\"): an algorithm for solving linear [vector optimization](https://en.wikipedia.org/wiki/Vector_optimization \"Vector optimization\") problems\n    *   [Dantzig–Wolfe decomposition](https://en.wikipedia.org/wiki/Dantzig%E2%80%93Wolfe_decomposition \"Dantzig–Wolfe decomposition\"): an algorithm for solving linear programming problems with special structure\n    *   [Delayed column generation](https://en.wikipedia.org/wiki/Delayed_column_generation \"Delayed column generation\")\n    *   [Integer linear programming](https://en.wikipedia.org/wiki/Integer_linear_programming \"Integer linear programming\"): solve linear programming problems where some or all the unknowns are restricted to integer values\n        *   [Branch and cut](https://en.wikipedia.org/wiki/Branch_and_cut \"Branch and cut\")\n        *   [Cutting-plane method](https://en.wikipedia.org/wiki/Cutting-plane_method \"Cutting-plane method\")\n    *   [Karmarkar's algorithm](https://en.wikipedia.org/wiki/Karmarkar%27s_algorithm \"Karmarkar's algorithm\"): The first reasonably efficient algorithm that solves the [linear programming](https://en.wikipedia.org/wiki/Linear_programming \"Linear programming\") problem in [polynomial time](https://en.wikipedia.org/wiki/Polynomial_time \"Polynomial time\").\n    *   [Simplex algorithm](https://en.wikipedia.org/wiki/Simplex_algorithm \"Simplex algorithm\"): An algorithm for solving [linear programming](https://en.wikipedia.org/wiki/Linear_programming \"Linear programming\") problems\n*   [Line search](https://en.wikipedia.org/wiki/Line_search \"Line search\")\n*   [Local search](https://en.wikipedia.org/wiki/Local_search_(optimization) \"Local search (optimization)\"): a metaheuristic for solving computationally hard optimization problems\n    *   [Random-restart hill climbing](https://en.wikipedia.org/wiki/Random-restart_hill_climbing \"Random-restart hill climbing\")\n    *   [Tabu search](https://en.wikipedia.org/wiki/Tabu_search \"Tabu search\")\n*   [Minimax](https://en.wikipedia.org/wiki/Minimax#Minimax_algorithm_with_alternate_moves \"Minimax\") used in game programming\n*   [Nearest neighbor search](https://en.wikipedia.org/wiki/Nearest_neighbor_search \"Nearest neighbor search\") (NNS): find closest points in a [metric space](https://en.wikipedia.org/wiki/Metric_space \"Metric space\")\n    *   [Best Bin First](https://en.wikipedia.org/wiki/Best_Bin_First \"Best Bin First\"): find an approximate solution to the [Nearest neighbor search](https://en.wikipedia.org/wiki/Nearest_neighbor_search \"Nearest neighbor search\") problem in very-high-dimensional spaces\n*   [Newton's method in optimization](https://en.wikipedia.org/wiki/Newton%27s_method_in_optimization \"Newton's method in optimization\")\n*   [Nonlinear optimization](https://en.wikipedia.org/wiki/Nonlinear_optimization \"Nonlinear optimization\")\n    *   [BFGS method](https://en.wikipedia.org/wiki/BFGS_method \"BFGS method\"): A [nonlinear optimization](https://en.wikipedia.org/wiki/Nonlinear_optimization \"Nonlinear optimization\") algorithm\n    *   [Gauss–Newton algorithm](https://en.wikipedia.org/wiki/Gauss%E2%80%93Newton_algorithm \"Gauss–Newton algorithm\"): An algorithm for solving nonlinear [least squares](https://en.wikipedia.org/wiki/Least_squares \"Least squares\") problems.\n    *   [Levenberg–Marquardt algorithm](https://en.wikipedia.org/wiki/Levenberg%E2%80%93Marquardt_algorithm \"Levenberg–Marquardt algorithm\"): An algorithm for solving nonlinear [least squares](https://en.wikipedia.org/wiki/Least_squares \"Least squares\") problems.\n    *   [Nelder–Mead method](https://en.wikipedia.org/wiki/Nelder%E2%80%93Mead_method \"Nelder–Mead method\") (downhill simplex method): A [nonlinear optimization](https://en.wikipedia.org/wiki/Nonlinear_optimization \"Nonlinear optimization\") algorithm\n*   [Odds algorithm](https://en.wikipedia.org/wiki/Odds_algorithm \"Odds algorithm\") (Bruss algorithm) : Finds the optimal strategy to predict a last specific event in a random sequence event\n*   [Simulated annealing](https://en.wikipedia.org/wiki/Simulated_annealing \"Simulated annealing\")\n*   [Stochastic tunneling](https://en.wikipedia.org/wiki/Stochastic_tunneling \"Stochastic tunneling\")\n*   [Subset sum](https://en.wikipedia.org/wiki/Subset_sum_problem \"Subset sum problem\") algorithm\n\nComputational science\\[[edit](/w/index.php?title=List_of_algorithms\u0026action=edit\u0026section=35 \"Edit section: Computational science\")\\]\n-----------------------------------------------------------------------------------------------------------------------------------\n\nFurther information: [Computational science](https://en.wikipedia.org/wiki/Computational_science \"Computational science\")\n\n### Astronomy\n\nMain article: [Astronomical algorithms](https://en.wikipedia.org/wiki/Astronomical_algorithms \"Astronomical algorithms\")\n\n*   [Doomsday algorithm](https://en.wikipedia.org/wiki/Doomsday_algorithm \"Doomsday algorithm\"): day of the week\n*   [Zeller's congruence](https://en.wikipedia.org/wiki/Zeller%27s_congruence \"Zeller's congruence\") is an algorithm to calculate the day of the week for any Julian or Gregorian calendar date\n*   various [Easter algorithms](https://en.wikipedia.org/wiki/Computus \"Computus\") are used to calculate the day of Easter\n\n### Bioinformatics\n\nFurther information: [Bioinformatics](https://en.wikipedia.org/wiki/Bioinformatics \"Bioinformatics\")\n\nSee also: [Sequence alignment algorithms](https://en.wikipedia.org/wiki/List_of_algorithms#Sequence_alignment \"List of algorithms\")\n\n*   [Basic Local Alignment Search Tool](https://en.wikipedia.org/wiki/Basic_Local_Alignment_Search_Tool \"Basic Local Alignment Search Tool\") also known as BLAST: an algorithm for comparing primary biological sequence information\n*   [Kabsch algorithm](https://en.wikipedia.org/wiki/Kabsch_algorithm \"Kabsch algorithm\"): calculate the optimal alignment of two sets of points in order to compute the [root mean squared deviation](https://en.wikipedia.org/wiki/RMSD \"RMSD\") between two protein structures.\n*   [Velvet](https://en.wikipedia.org/wiki/Velvet_(algorithm) \"Velvet (algorithm)\"): a set of algorithms manipulating [de Bruijn graphs](https://en.wikipedia.org/wiki/De_Bruijn_graph \"De Bruijn graph\") for genomic [sequence assembly](https://en.wikipedia.org/wiki/Sequence_assembly \"Sequence assembly\")\n*   [Sorting by signed reversals](/w/index.php?title=Sorting_by_signed_reversals\u0026action=edit\u0026redlink=1 \"Sorting by signed reversals (page does not exist)\"): an algorithm for understanding genomic evolution.\n*   [Maximum parsimony (phylogenetics)](https://en.wikipedia.org/wiki/Maximum_parsimony_(phylogenetics) \"Maximum parsimony (phylogenetics)\"): an algorithm for finding the simplest phylogenetic tree to explain a given character matrix.\n*   [UPGMA](https://en.wikipedia.org/wiki/UPGMA \"UPGMA\"): a distance-based phylogenetic tree construction algorithm.\n\n### Geoscience\n\nFurther information: [Geoscience](https://en.wikipedia.org/wiki/Geoscience \"Geoscience\")\n\n*   [Vincenty's formulae](https://en.wikipedia.org/wiki/Vincenty%27s_formulae \"Vincenty's formulae\"): a fast algorithm to calculate the distance between two latitude/longitude points on an ellipsoid\n*   [Geohash](https://en.wikipedia.org/wiki/Geohash \"Geohash\"): a public domain algorithm that encodes a decimal latitude/longitude pair as a hash string\n\n### Linguistics\n\nFurther information: [Computational linguistics](https://en.wikipedia.org/wiki/Computational_linguistics \"Computational linguistics\") and [Natural language processing](https://en.wikipedia.org/wiki/Natural_language_processing \"Natural language processing\")\n\n*   [Lesk algorithm](https://en.wikipedia.org/wiki/Lesk_algorithm \"Lesk algorithm\"): word sense disambiguation\n*   [Stemming algorithm](https://en.wikipedia.org/wiki/Stemming \"Stemming\"): a method of reducing words to their stem, base, or root form\n*   [Sukhotin's algorithm](https://en.wikipedia.org/wiki/Sukhotin%27s_algorithm \"Sukhotin's algorithm\"): a statistical classification algorithm for classifying characters in a text as vowels or consonants\n\n### Medicine\n\nFurther information: [Medical algorithms](https://en.wikipedia.org/wiki/Medical_algorithms \"Medical algorithms\")\n\n*   [ESC algorithm](https://en.wikipedia.org/wiki/ESC_algorithm \"ESC algorithm\") for the diagnosis of heart failure\n*   [Manning Criteria](https://en.wikipedia.org/wiki/Manning_Criteria \"Manning Criteria\") for irritable bowel syndrome\n*   [Pulmonary embolism](https://en.wikipedia.org/wiki/Pulmonary_embolism#Algorithms \"Pulmonary embolism\") diagnostic algorithms\n*   [Texas Medication Algorithm Project](https://en.wikipedia.org/wiki/Texas_Medication_Algorithm_Project \"Texas Medication Algorithm Project\")\n\n### Physics\n\nFurther information: [Computational physics](https://en.wikipedia.org/wiki/Computational_physics \"Computational physics\")\n\n*   [Constraint algorithm](https://en.wikipedia.org/wiki/Constraint_algorithm \"Constraint algorithm\"): a class of algorithms for satisfying constraints for bodies that obey Newton's equations of motion\n*   [Demon algorithm](https://en.wikipedia.org/wiki/Demon_algorithm \"Demon algorithm\"): a [Monte Carlo method](https://en.wikipedia.org/wiki/Monte_Carlo_method \"Monte Carlo method\") for efficiently sampling members of a [microcanonical ensemble](https://en.wikipedia.org/wiki/Microcanonical_ensemble \"Microcanonical ensemble\") with a given energy\n*   [Featherstone's algorithm](https://en.wikipedia.org/wiki/Featherstone%27s_algorithm \"Featherstone's algorithm\"): compute the effects of forces applied to a structure of joints and links\n*   [Ground state](https://en.wikipedia.org/wiki/Ground_state \"Ground state\") approximation\n    *   [Variational method](https://en.wikipedia.org/wiki/Variational_method \"Variational method\")\n        *   [Ritz method](https://en.wikipedia.org/wiki/Ritz_method \"Ritz method\")\n*   [N-body problems](https://en.wikipedia.org/wiki/N-body_problem \"N-body problem\")\n    *   [Barnes–Hut simulation](https://en.wikipedia.org/wiki/Barnes%E2%80%93Hut_simulation \"Barnes–Hut simulation\"): Solves the n-body problem in an approximate way that has the order O(n log n) instead of O(n2) as in a direct-sum simulation.\n    *   [Fast multipole method](https://en.wikipedia.org/wiki/Fast_multipole_method \"Fast multipole method\") (FMM): speeds up the calculation of long-ranged forces\n*   [Rainflow-counting algorithm](https://en.wikipedia.org/wiki/Rainflow-counting_algorithm \"Rainflow-counting algorithm\"): Reduces a complex [stress](https://en.wikipedia.org/wiki/Stress_(physics) \"Stress (physics)\") history to a count of elementary stress-reversals for use in [fatigue](https://en.wikipedia.org/wiki/Fatigue_(material) \"Fatigue (material)\") analysis\n*   [Sweep and prune](https://en.wikipedia.org/wiki/Sweep_and_prune \"Sweep and prune\"): a broad phase algorithm used during [collision detection](https://en.wikipedia.org/wiki/Collision_detection \"Collision detection\") to limit the number of pairs of solids that need to be checked for collision\n*   [VEGAS algorithm](https://en.wikipedia.org/wiki/VEGAS_algorithm \"VEGAS algorithm\"): a method for reducing error in [Monte Carlo simulations](https://en.wikipedia.org/wiki/Monte_Carlo_simulation \"Monte Carlo simulation\")\n\n### Statistics\n\nFurther information: [Computational statistics](https://en.wikipedia.org/wiki/Computational_statistics \"Computational statistics\")\n\n*   [Algorithms for calculating variance](https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance \"Algorithms for calculating variance\"): avoiding instability and numerical overflow\n*   [Approximate counting algorithm](https://en.wikipedia.org/wiki/Approximate_counting_algorithm \"Approximate counting algorithm\"): Allows counting large number of events in a small register\n*   [Bayesian statistics](https://en.wikipedia.org/wiki/Bayesian_statistics \"Bayesian statistics\")\n    *   [Nested sampling algorithm](https://en.wikipedia.org/wiki/Nested_sampling_algorithm \"Nested sampling algorithm\"): a computational approach to the problem of comparing models in Bayesian statistics\n*   [Clustering Algorithms](https://en.wikipedia.org/wiki/Data_clustering \"Data clustering\")\n    *   [Average-linkage clustering](https://en.wikipedia.org/wiki/UPGMA \"UPGMA\"): a simple agglomerative clustering algorithm\n    *   [Canopy clustering algorithm](https://en.wikipedia.org/wiki/Canopy_clustering_algorithm \"Canopy clustering algorithm\"): an unsupervised pre-clustering algorithm related to the K-means algorithm\n    *   [Complete-linkage clustering](https://en.wikipedia.org/wiki/Complete-linkage_clustering \"Complete-linkage clustering\"): a simple agglomerative clustering algorithm\n    *   [DBSCAN](https://en.wikipedia.org/wiki/DBSCAN \"DBSCAN\"): a density based clustering algorithm\n    *   [Expectation-maximization algorithm](https://en.wikipedia.org/wiki/Expectation-maximization_algorithm \"Expectation-maximization algorithm\")\n    *   [Fuzzy clustering](https://en.wikipedia.org/wiki/Fuzzy_clustering \"Fuzzy clustering\"): a class of clustering algorithms where each point has a degree of belonging to clusters\n        *   [Fuzzy c-means](https://en.wikipedia.org/wiki/Fuzzy_clustering#Fuzzy_c-means_clustering \"Fuzzy clustering\")\n        *   [FLAME clustering](https://en.wikipedia.org/wiki/FLAME_clustering \"FLAME clustering\") (Fuzzy clustering by Local Approximation of MEmberships): define clusters in the dense parts of a dataset and perform cluster assignment solely based on the neighborhood relationships among objects\n    *   [KHOPCA clustering algorithm](https://en.wikipedia.org/wiki/KHOPCA_clustering_algorithm \"KHOPCA clustering algorithm\"): a local clustering algorithm, which produces hierarchical multi-hop clusters in static and mobile environments.\n    *   [k-means clustering](https://en.wikipedia.org/wiki/K-means_clustering \"K-means clustering\"): cluster objects based on attributes into partitions\n    *   [k-means++](https://en.wikipedia.org/wiki/K-means%2B%2B \"K-means++\"): a variation of this, using modified random seeds\n    *   [k-medoids](https://en.wikipedia.org/wiki/K-medoids \"K-medoids\"): similar to k-means, but chooses datapoints or [medoids](https://en.wikipedia.org/wiki/Medoid \"Medoid\") as centers\n    *   [Linde–Buzo–Gray algorithm](https://en.wikipedia.org/wiki/Linde%E2%80%93Buzo%E2%80%93Gray_algorithm \"Linde–Buzo–Gray algorithm\"): a vector quantization algorithm to derive a good codebook\n    *   [Lloyd's algorithm](https://en.wikipedia.org/wiki/Lloyd%27s_algorithm \"Lloyd's algorithm\") (Voronoi iteration or relaxation): group data points into a given number of categories, a popular algorithm for [k-means clustering](https://en.wikipedia.org/wiki/K-means_clustering \"K-means clustering\")\n    *   [OPTICS](https://en.wikipedia.org/wiki/OPTICS_algorithm \"OPTICS algorithm\"): a density based clustering algorithm with a visual evaluation method\n    *   [Single-linkage clustering](https://en.wikipedia.org/wiki/Single-linkage_clustering \"Single-linkage clustering\"): a simple agglomerative clustering algorithm\n    *   [SUBCLU](https://en.wikipedia.org/wiki/SUBCLU \"SUBCLU\"): a subspace clustering algorithm\n    *   [Ward's method](https://en.wikipedia.org/wiki/Ward%27s_method \"Ward's method\") : an agglomerative clustering algorithm, extended to more general Lance–Williams algorithms\n    *   [WACA clustering algorithm](https://en.wikipedia.org/wiki/WACA_clustering_algorithm \"WACA clustering algorithm\"): a local clustering algorithm with potentially multi-hop structures; for dynamic networks\n*   [Estimation Theory](https://en.wikipedia.org/wiki/Estimation_theory \"Estimation theory\")\n    *   [Expectation-maximization algorithm](https://en.wikipedia.org/wiki/Expectation-maximization_algorithm \"Expectation-maximization algorithm\") A class of related algorithms for finding maximum likelihood estimates of parameters in probabilistic models\n        *   [Ordered subset expectation maximization](https://en.wikipedia.org/wiki/Ordered_subset_expectation_maximization \"Ordered subset expectation maximization\") (OSEM): used in [medical imaging](https://en.wikipedia.org/wiki/Medical_imaging \"Medical imaging\") for [positron emission tomography](https://en.wikipedia.org/wiki/Positron_emission_tomography \"Positron emission tomography\"), [single photon emission computed tomography](https://en.wikipedia.org/wiki/Single_photon_emission_computed_tomography \"Single photon emission computed tomography\") and [X-ray](https://en.wikipedia.org/wiki/X-ray \"X-ray\") computed tomography.\n    *   [Odds algorithm](https://en.wikipedia.org/wiki/Odds_algorithm \"Odds algorithm\") (Bruss algorithm) Optimal online search for distinguished value in sequential random input\n    *   [Kalman filter](https://en.wikipedia.org/wiki/Kalman_filter \"Kalman filter\"): estimate the state of a linear [dynamic system](https://en.wikipedia.org/wiki/Dynamical_system \"Dynamical system\") from a series of noisy measurements\n*   [False nearest neighbor algorithm](https://en.wikipedia.org/wiki/False_nearest_neighbor_algorithm \"False nearest neighbor algorithm\") (FNN) estimates [fractal dimension](https://en.wikipedia.org/wiki/Fractal_dimension \"Fractal dimension\")\n*   [Hidden Markov model](https://en.wikipedia.org/wiki/Hidden_Markov_model \"Hidden Markov model\")\n    *   [Baum–Welch algorithm](https://en.wikipedia.org/wiki/Baum%E2%80%93Welch_algorithm \"Baum–Welch algorithm\"): compute maximum likelihood estimates and [posterior mode](https://en.wikipedia.org/wiki/Maximum_a_posteriori \"Maximum a posteriori\") estimates for the parameters of a [hidden markov model](https://en.wikipedia.org/wiki/Hidden_markov_model \"Hidden markov model\")\n    *   [Forward-backward algorithm](https://en.wikipedia.org/wiki/Forward-backward_algorithm \"Forward-backward algorithm\") a dynamic programming algorithm for computing the probability of a particular observation sequence\n    *   [Viterbi algorithm](https://en.wikipedia.org/wiki/Viterbi_algorithm \"Viterbi algorithm\"): find the most likely sequence of hidden states in a [hidden markov model](https://en.wikipedia.org/wiki/Hidden_markov_model \"Hidden markov model\")\n*   [Partial least squares regression](https://en.wikipedia.org/wiki/Partial_least_squares_regression \"Partial least squares regression\"): finds a linear model describing some predicted variables in terms of other observable variables\n*   [Queuing theory](https://en.wikipedia.org/wiki/Queuing_theory \"Queuing theory\")\n    *   [Buzen's algorithm](https://en.wikipedia.org/wiki/Buzen%27s_algorithm \"Buzen's algorithm\"): an algorithm for calculating the normalization constant G(K) in the [Gordon–Newell theorem](https://en.wikipedia.org/wiki/Gordon%E2%80%93Newell_theorem \"Gordon–Newell theorem\")\n*   [RANSAC](https://en.wikipedia.org/wiki/RANSAC \"RANSAC\") (an abbreviation for \"RANdom SAmple Consensus\"): an iterative method to estimate parameters of a mathematical model from a set of observed data which contains outliers\n*   [Scoring algorithm](https://en.wikipedia.org/wiki/Scoring_algorithm \"Scoring algorithm\"): is a form of [Newton's method](https://en.wikipedia.org/wiki/Newton%27s_method \"Newton's method\") used to solve [maximum likelihood](https://en.wikipedia.org/wiki/Maximum_likelihood \"Maximum likelihood\") equations numerically\n*   [Yamartino method](https://en.wikipedia.org/wiki/Yamartino_method \"Yamartino method\"): calculate an approximation to the standard deviation σθ of wind direction θ during a single pass through the incoming data\n*   [Ziggurat algorithm](https://en.wikipedia.org/wiki/Ziggurat_algorithm \"Ziggurat algorithm\"): generate random numbers from a non-uniform distribution\n\nComputer science\\[[edit](/w/index.php?title=List_of_algorithms\u0026action=edit\u0026section=43 \"Edit section: Computer science\")\\]\n-------------------------------------------------------------------------------------------------------------------------\n\nFurther information: [Computer science](https://en.wikipedia.org/wiki/Computer_science \"Computer science\")\n\n### Computer architecture\n\nFurther information: [Computer architecture](https://en.wikipedia.org/wiki/Computer_architecture \"Computer architecture\")\n\n*   [Tomasulo algorithm](https://en.wikipedia.org/wiki/Tomasulo_algorithm \"Tomasulo algorithm\"): allows sequential instructions that would normally be stalled due to certain dependencies to execute non-sequentially\n\n### Computer graphics\n\nFurther information: [Computer graphics](https://en.wikipedia.org/wiki/Computer_graphics \"Computer graphics\")\n\n*   [Clipping](https://en.wikipedia.org/wiki/Clipping_(computer_graphics) \"Clipping (computer graphics)\")\n    *   [Line clipping](https://en.wikipedia.org/wiki/Line_clipping \"Line clipping\")\n        *   [Cohen–Sutherland](https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland \"Cohen–Sutherland\")\n        *   [Cyrus–Beck](https://en.wikipedia.org/wiki/Cyrus%E2%80%93Beck \"Cyrus–Beck\")\n        *   [Fast-clipping](https://en.wikipedia.org/wiki/Fast_clipping \"Fast clipping\")\n        *   [Liang–Barsky](https://en.wikipedia.org/wiki/Liang%E2%80%93Barsky \"Liang–Barsky\")\n        *   [Nicholl–Lee–Nicholl](https://en.wikipedia.org/wiki/Nicholl%E2%80%93Lee%E2%80%93Nicholl \"Nicholl–Lee–Nicholl\")\n    *   Polygon clipping\n        *   [Sutherland–Hodgman](https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman \"Sutherland–Hodgman\")\n        *   [Vatti](https://en.wikipedia.org/wiki/Vatti_clipping_algorithm \"Vatti clipping algorithm\")\n        *   [Weiler–Atherton](https://en.wikipedia.org/wiki/Weiler%E2%80%93Atherton \"Weiler–Atherton\")\n*   [Contour lines](https://en.wikipedia.org/wiki/Contour_line \"Contour line\") and [Isosurfaces](https://en.wikipedia.org/wiki/Isosurface \"Isosurface\")\n    *   [Marching cubes](","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frealabbas%2Flist-of-algorithms","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Frealabbas%2Flist-of-algorithms","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frealabbas%2Flist-of-algorithms/lists"}