Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/realabbas/list-of-algorithms

A comprehensive curated list of algorithmsđŸ€  🏆
https://github.com/realabbas/list-of-algorithms

algorithms coloring-algorithm combinatorial-algorithms computational-science database-algorithms distributed-algorithm graph-algorithms hopcroft-algorithm information-theory machine-learning-algorithm search-algorithm

Last synced: 3 months ago
JSON representation

A comprehensive curated list of algorithmsđŸ€  🏆

Awesome Lists containing this project

README 

          
List of algorithms 🏆

=====================



Contents

--------



*   [1 Automated planning](#Automated_planning)

*   [2 Combinatorial algorithms](#Combinatorial_algorithms)

    *   [2.1 General combinatorial algorithms](#General_combinatorial_algorithms)

    *   [2.2 Graph algorithms](#Graph_algorithms)

        *   [2.2.1 Graph drawing](#Graph_drawing)

        *   [2.2.2 Network theory](#Network_theory)

        *   [2.2.3 Routing for graphs](#Routing_for_graphs)

        *   [2.2.4 Graph search](#Graph_search)

        *   [2.2.5 Subgraphs](#Subgraphs)

    *   [2.3 Sequence algorithms](#Sequence_algorithms)

        *   [2.3.1 Approximate sequence matching](#Approximate_sequence_matching)

        *   [2.3.2 Selection algorithms](#Selection_algorithms)

        *   [2.3.3 Sequence search](#Sequence_search)

        *   [2.3.4 Sequence merging](#Sequence_merging)

        *   [2.3.5 Sequence permutations](#Sequence_permutations)

        *   [2.3.6 Sequence alignment](#Sequence_alignment)

        *   [2.3.7 Sequence sorting](#Sequence_sorting)

        *   [2.3.8 Subsequences](#Subsequences)

        *   [2.3.9 Substrings](#Substrings)

*   [3 Computational mathematics](#Computational_mathematics)

    *   [3.1 Abstract algebra](#Abstract_algebra)

    *   [3.2 Computer algebra](#Computer_algebra)

    *   [3.3 Geometry](#Geometry)

    *   [3.4 Number theoretic algorithms](#Number_theoretic_algorithms)

    *   [3.5 Numerical algorithms](#Numerical_algorithms)

        *   [3.5.1 Differential equation solving](#Differential_equation_solving)

        *   [3.5.2 Elementary and special functions](#Elementary_and_special_functions)

        *   [3.5.3 Geometric](#Geometric)

        *   [3.5.4 Interpolation and extrapolation](#Interpolation_and_extrapolation)

        *   [3.5.5 Linear algebra](#Linear_algebra)

        *   [3.5.6 Monte Carlo](#Monte_Carlo)

        *   [3.5.7 Numerical integration](#Numerical_integration)

        *   [3.5.8 Root finding](#Root_finding)

    *   [3.6 Optimization algorithms](#Optimization_algorithms)

*   [4 Computational science](#Computational_science)

    *   [4.1 Astronomy](#Astronomy)

    *   [4.2 Bioinformatics](#Bioinformatics)

    *   [4.3 Geoscience](#Geoscience)

    *   [4.4 Linguistics](#Linguistics)

    *   [4.5 Medicine](#Medicine)

    *   [4.6 Physics](#Physics)

    *   [4.7 Statistics](#Statistics)

*   [5 Computer science](#Computer_science)

    *   [5.1 Computer architecture](#Computer_architecture)

    *   [5.2 Computer graphics](#Computer_graphics)

    *   [5.3 Cryptography](#Cryptography)

    *   [5.4 Digital logic](#Digital_logic)

    *   [5.5 Machine learning and statistical classification](#Machine_learning_and_statistical_classification)

    *   [5.6 Programming language theory](#Programming_language_theory)

        *   [5.6.1 Parsing](#Parsing)

    *   [5.7 Quantum algorithms](#Quantum_algorithms)

    *   [5.8 Theory of computation and automata](#Theory_of_computation_and_automata)

*   [6 Information theory and signal processing](#Information_theory_and_signal_processing)

    *   [6.1 Coding theory](#Coding_theory)

        *   [6.1.1 Error detection and correction](#Error_detection_and_correction)

        *   [6.1.2 Lossless compression algorithms](#Lossless_compression_algorithms)

        *   [6.1.3 Lossy compression algorithms](#Lossy_compression_algorithms)

    *   [6.2 Digital signal processing](#Digital_signal_processing)

        *   [6.2.1 Image processing](#Image_processing)

*   [7 Software engineering](#Software_engineering)

*   [8 Database algorithms](#Database_algorithms)

*   [9 Distributed systems algorithms](#Distributed_systems_algorithms)

    *   [9.1 Memory allocation and deallocation algorithms](#Memory_allocation_and_deallocation_algorithms)

*   [10 Networking](#Networking)

*   [11 Operating systems algorithms](#Operating_systems_algorithms)

    *   [11.1 Process synchronization](#Process_synchronization)

    *   [11.2 Scheduling](#Scheduling)

    *   [11.3 I/O scheduling](#I/O_scheduling)

        *   [11.3.1 Disk scheduling](#Disk_scheduling)

*   [12 See also](#See_also)

*   [13 References](#References)



Automated planning\[[edit](/w/index.php?title=List_of_algorithms&action=edit&section=1 "Edit section: Automated planning")\]

----------------------------------------------------------------------------------------------------------------------------



Further information: [List of algorithms for automated planning](https://en.wikipedia.org/wiki/List_of_algorithms_for_automated_planning "List of algorithms for automated planning")



Combinatorial algorithms\[[edit](/w/index.php?title=List_of_algorithms&action=edit&section=2 "Edit section: Combinatorial algorithms")\]

----------------------------------------------------------------------------------------------------------------------------------------



Further information: [Combinatorics](https://en.wikipedia.org/wiki/Combinatorics "Combinatorics")



### General combinatorial algorithms



*   [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

*   [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

*   [Gale–Shapley algorithm](https://en.wikipedia.org/wiki/Stable_marriage_problem "Stable marriage problem"): solves the stable marriage problem

*   [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):

    *   [ACORN generator](https://en.wikipedia.org/wiki/ACORN_(PRNG) "ACORN (PRNG)")

    *   [Blum Blum Shub](https://en.wikipedia.org/wiki/Blum_Blum_Shub "Blum Blum Shub")

    *   [Lagged Fibonacci generator](https://en.wikipedia.org/wiki/Lagged_Fibonacci_generator "Lagged Fibonacci generator")

    *   [Linear congruential generator](https://en.wikipedia.org/wiki/Linear_congruential_generator "Linear congruential generator")

    *   [Mersenne Twister](https://en.wikipedia.org/wiki/Mersenne_Twister "Mersenne Twister")



### Graph algorithms



Further 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")



*   [Coloring algorithm](https://en.wikipedia.org/wiki/Coloring_algorithm "Coloring algorithm"): Graph coloring algorithm.

*   [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")

*   [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")

*   [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")

*   [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

*   [Topological sort](https://en.wikipedia.org/wiki/Topological_sorting "Topological sorting"): finds linear order of nodes (e.g. jobs) based on their dependencies.



#### Graph drawing



Further information: [Graph drawing](https://en.wikipedia.org/wiki/Graph_drawing "Graph drawing")



*   [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)

*   [Spectral layout](https://en.wikipedia.org/wiki/Spectral_layout "Spectral layout")



#### Network theory



Further information: [Network theory](https://en.wikipedia.org/wiki/Network_theory "Network theory")



*   Network analysis

    *   Link analysis

        *   [Girvan–Newman algorithm](https://en.wikipedia.org/wiki/Girvan%E2%80%93Newman_algorithm "Girvan–Newman algorithm"): detect communities in complex systems

        *   Web link analysis

            *   [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"))

            *   [PageRank](https://en.wikipedia.org/wiki/PageRank "PageRank")

            *   [TrustRank](https://en.wikipedia.org/wiki/TrustRank "TrustRank")

*   [Flow networks](https://en.wikipedia.org/wiki/Flow_network "Flow network")

    *   [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").

    *   [Edmonds–Karp algorithm](https://en.wikipedia.org/wiki/Edmonds%E2%80%93Karp_algorithm "Edmonds–Karp algorithm"): implementation of Ford–Fulkerson

    *   [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

    *   [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

    *   [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



#### Routing for graphs



*   [Edmonds' algorithm](https://en.wikipedia.org/wiki/Edmonds%27_algorithm "Edmonds' algorithm") (also known as Chu–Liu/Edmonds' algorithm): find maximum or minimum branchings

*   [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

*   [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

*   [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

*   [Minimum spanning tree](https://en.wikipedia.org/wiki/Minimum_spanning_tree "Minimum spanning tree")

    *   [BorĆŻvka's algorithm](https://en.wikipedia.org/wiki/Bor%C5%AFvka%27s_algorithm "BorĆŻvka's algorithm")

    *   [Kruskal's algorithm](https://en.wikipedia.org/wiki/Kruskal%27s_algorithm "Kruskal's algorithm")

    *   [Prim's algorithm](https://en.wikipedia.org/wiki/Prim%27s_algorithm "Prim's algorithm")

    *   [Reverse-delete algorithm](https://en.wikipedia.org/wiki/Reverse-delete_algorithm "Reverse-delete algorithm")

*   [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")

*   [Shortest path problem](https://en.wikipedia.org/wiki/Shortest_path_problem "Shortest path problem")

    *   [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)

    *   [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

    *   [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

    *   [Johnson's algorithm](https://en.wikipedia.org/wiki/Johnson%27s_algorithm "Johnson's algorithm"): All pairs shortest path algorithm in sparse weighted directed graph

*   [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

*   [Traveling salesman problem](https://en.wikipedia.org/wiki/Traveling_salesman_problem "Traveling salesman problem")

    *   [Christofides algorithm](https://en.wikipedia.org/wiki/Christofides_algorithm "Christofides algorithm")

    *   [Nearest neighbour algorithm](https://en.wikipedia.org/wiki/Nearest_neighbour_algorithm "Nearest neighbour algorithm")

*   [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.



#### Graph search



Further 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")



*   [A\*](https://en.wikipedia.org/wiki/A*_search_algorithm "A* search algorithm"): special case of best-first search that uses heuristics to improve speed

*   [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)

*   [Backtracking](https://en.wikipedia.org/wiki/Backtracking "Backtracking"): abandons partial solutions when they are found not to satisfy a complete solution

*   [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

*   [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")

*   [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")

*   [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

*   [Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search "Breadth-first search"): traverses a graph level by level

*   [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.

*   [D\*](https://en.wikipedia.org/wiki/D* "D*"): an [incremental heuristic search](https://en.wikipedia.org/wiki/Incremental_heuristic_search "Incremental heuristic search") algorithm

*   [Depth-first search](https://en.wikipedia.org/wiki/Depth-first_search "Depth-first search"): traverses a graph branch by branch

*   [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

*   [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.

*   [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

*   [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.

*   [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

*   [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

*   [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

*   [F\*](/w/index.php?title=F*_Merge_Algorithm&action=edit&redlink=1 "F* Merge Algorithm (page does not exist)"): Special algorithm to merge the two arrays



#### Subgraphs



*   [Cliques](https://en.wikipedia.org/wiki/Clique_(graph_theory) "Clique (graph theory)")

    *   [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

    *   [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

*   [Strongly connected components](https://en.wikipedia.org/wiki/Strongly_connected_components "Strongly connected components")

    *   [Path-based strong component algorithm](https://en.wikipedia.org/wiki/Path-based_strong_component_algorithm "Path-based strong component algorithm")

    *   [Kosaraju's algorithm](https://en.wikipedia.org/wiki/Kosaraju%27s_algorithm "Kosaraju's algorithm")

    *   [Tarjan's strongly connected components algorithm](https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm "Tarjan's strongly connected components algorithm")

*   [Subgraph isomorphism problem](https://en.wikipedia.org/wiki/Subgraph_isomorphism_problem "Subgraph isomorphism problem")



### Sequence algorithms



Further information: [Sequences](https://en.wikipedia.org/wiki/Sequences "Sequences")



#### Approximate sequence matching



*   [Bitap algorithm](https://en.wikipedia.org/wiki/Bitap_algorithm "Bitap algorithm"): fuzzy algorithm that determines if strings are approximately equal.

*   [Phonetic algorithms](https://en.wikipedia.org/wiki/Phonetic_algorithm "Phonetic algorithm")

    *   [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

    *   [Double Metaphone](https://en.wikipedia.org/wiki/Double_Metaphone "Double Metaphone"): an improvement on Metaphone

    *   [Match rating approach](https://en.wikipedia.org/wiki/Match_rating_approach "Match rating approach"): a phonetic algorithm developed by Western Airlines

    *   [Metaphone](https://en.wikipedia.org/wiki/Metaphone "Metaphone"): an algorithm for indexing words by their sound, when pronounced in English

    *   [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")

    *   [Soundex](https://en.wikipedia.org/wiki/Soundex "Soundex"): a phonetic algorithm for indexing names by sound, as pronounced in English

*   [String metrics](https://en.wikipedia.org/wiki/String_metric "String metric"): compute a similarity or dissimilarity (distance) score between two pairs of text strings

    *   [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")

    *   [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")

    *   [Hamming distance](https://en.wikipedia.org/wiki/Hamming_distance "Hamming distance"): sum number of positions which are different

    *   [Jaro–Winkler distance](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance "Jaro–Winkler distance"): is a measure of similarity between two strings

    *   [Levenshtein edit distance](https://en.wikipedia.org/wiki/Levenshtein_distance "Levenshtein distance"): compute a metric for the amount of difference between two sequences

*   [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



#### Selection algorithms



Main article: [Selection algorithm](https://en.wikipedia.org/wiki/Selection_algorithm "Selection algorithm")



*   [Quickselect](https://en.wikipedia.org/wiki/Quickselect "Quickselect")

*   [Introselect](https://en.wikipedia.org/wiki/Introselect "Introselect")



#### Sequence search



*   [Linear search](https://en.wikipedia.org/wiki/Linear_search "Linear search"): finds an item in an unsorted sequence

*   [Selection algorithm](https://en.wikipedia.org/wiki/Selection_algorithm "Selection algorithm"): finds the _k_th largest item in a sequence

*   [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

*   [Sorted lists](https://en.wikipedia.org/wiki/Sorted_list "Sorted list")

    *   [Binary search algorithm](https://en.wikipedia.org/wiki/Binary_search_algorithm "Binary search algorithm"): locates an item in a sorted sequence

    *   [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")

    *   [Jump search](https://en.wikipedia.org/wiki/Jump_search "Jump search") (or block search): linear search on a smaller subset of the sequence

    *   [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.

    *   [Uniform binary search](https://en.wikipedia.org/wiki/Uniform_binary_search "Uniform binary search"): an optimization of the classic binary search algorithm



#### Sequence merging



Main article: [Merge algorithm](https://en.wikipedia.org/wiki/Merge_algorithm "Merge algorithm")



*   Simple merge algorithm

*   k-way merge algorithm

*   Union (merge, with elements on the output not repeated)



#### Sequence permutations



Further information: [Permutation](https://en.wikipedia.org/wiki/Permutation "Permutation")



*   [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

*   [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

*   [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

*   [Heap's permutation generation algorithm](https://en.wikipedia.org/wiki/Heap%27s_algorithm "Heap's algorithm"): interchange elements to generate next permutation



#### Sequence alignment



*   [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

*   [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")

*   [Needleman–Wunsch algorithm](https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm "Needleman–Wunsch algorithm"): find global alignment between two sequences

*   [Smith–Waterman algorithm](https://en.wikipedia.org/wiki/Smith%E2%80%93Waterman_algorithm "Smith–Waterman algorithm"): find local sequence alignment



#### Sequence sorting



Main article: [Sorting algorithm](https://en.wikipedia.org/wiki/Sorting_algorithm "Sorting algorithm")



![Accuracy dispute](//upload.wikimedia.org/wikipedia/commons/thumb/2/2e/Ambox_contradict.svg/40px-Ambox_contradict.svg.png "Accuracy dispute")



This 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"))_



*   Exchange sorts

    *   [Bubble sort](https://en.wikipedia.org/wiki/Bubble_sort "Bubble sort"): for each pair of indices, swap the items if out of order

    *   [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

    *   [Comb sort](https://en.wikipedia.org/wiki/Comb_sort "Comb sort")

    *   [Gnome sort](https://en.wikipedia.org/wiki/Gnome_sort "Gnome sort")

    *   [Odd–even sort](https://en.wikipedia.org/wiki/Odd%E2%80%93even_sort "Odd–even sort")

    *   [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

*   Humorous or ineffective

    *   [Bogosort](https://en.wikipedia.org/wiki/Bogosort "Bogosort")

    *   [Stooge sort](https://en.wikipedia.org/wiki/Stooge_sort "Stooge sort")

*   Hybrid

    *   [Flashsort](https://en.wikipedia.org/wiki/Flashsort "Flashsort")

    *   [Introsort](https://en.wikipedia.org/wiki/Introsort "Introsort"): begin with quicksort and switch to heapsort when the recursion depth exceeds a certain level

    *   [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.

*   Insertion sorts

    *   [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

    *   [Library sort](https://en.wikipedia.org/wiki/Library_sort "Library sort")

    *   [Patience sorting](https://en.wikipedia.org/wiki/Patience_sorting "Patience sorting")

    *   [Shell sort](https://en.wikipedia.org/wiki/Shellsort "Shellsort"): an attempt to improve insertion sort

    *   [Tree sort](https://en.wikipedia.org/wiki/Tree_sort "Tree sort") (binary tree sort): build binary tree, then traverse it to create sorted list

    *   [Cycle sort](https://en.wikipedia.org/wiki/Cycle_sort "Cycle sort"): in-place with theoretically optimal number of writes

*   Merge sorts

    *   [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

    *   [Strand sort](https://en.wikipedia.org/wiki/Strand_sort "Strand sort")

*   Non-comparison sorts

    *   [Bead sort](https://en.wikipedia.org/wiki/Bead_sort "Bead sort")

    *   [Bucket sort](https://en.wikipedia.org/wiki/Bucket_sort "Bucket sort")

    *   [Burstsort](https://en.wikipedia.org/wiki/Burstsort "Burstsort"): build a compact, cache efficient [burst trie](/w/index.php?title=Burst_trie&action=edit&redlink=1 "Burst trie (page does not exist)") and then traverse it to create sorted output

    *   [Counting sort](https://en.wikipedia.org/wiki/Counting_sort "Counting sort")

    *   [Pigeonhole sort](https://en.wikipedia.org/wiki/Pigeonhole_sort "Pigeonhole sort")

    *   [Postman sort](https://en.wikipedia.org/wiki/Postman_sort "Postman sort"): variant of Bucket sort which takes advantage of hierarchical structure

    *   [Radix sort](https://en.wikipedia.org/wiki/Radix_sort "Radix sort"): sorts strings letter by letter

*   Selection sorts

    *   [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

    *   [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

    *   [Smoothsort](https://en.wikipedia.org/wiki/Smoothsort "Smoothsort")

*   Other

    *   [Bitonic sorter](https://en.wikipedia.org/wiki/Bitonic_sorter "Bitonic sorter")

    *   [Pancake sorting](https://en.wikipedia.org/wiki/Pancake_sorting "Pancake sorting")

    *   [Spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort "Spaghetti sort")

    *   [Topological sort](https://en.wikipedia.org/wiki/Topological_sorting "Topological sorting")

*   Unknown class

    *   [Samplesort](https://en.wikipedia.org/wiki/Samplesort "Samplesort")



#### Subsequences



Further information: [Subsequence](https://en.wikipedia.org/wiki/Subsequence "Subsequence")



*   [Kadane's algorithm](https://en.wikipedia.org/wiki/Kadane%27s_algorithm "Kadane's algorithm"): finds maximum sub-array of any size

*   [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

*   [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

*   [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



#### Substrings



Further information: [Substring](https://en.wikipedia.org/wiki/Substring "Substring")



*   [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

*   [Substring search](https://en.wikipedia.org/wiki/Substring_search "Substring search")

    *   [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

    *   [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

    *   [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

    *   [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

    *   [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

    *   [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

*   [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")

*   [Matching wildcards](https://en.wikipedia.org/wiki/Matching_wildcards "Matching wildcards")

    *   [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

    *   [Krauss matching wildcards algorithm](https://en.wikipedia.org/wiki/Krauss_matching_wildcards_algorithm "Krauss matching wildcards algorithm"): an open-source non-recursive algorithm



Computational mathematics\[[edit](/w/index.php?title=List_of_algorithms&action=edit&section=20 "Edit section: Computational mathematics")\]

-------------------------------------------------------------------------------------------------------------------------------------------



Further information: [Computational mathematics](https://en.wikipedia.org/wiki/Computational_mathematics "Computational mathematics")



See 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")



### Abstract algebra



Further information: [Abstract algebra](https://en.wikipedia.org/wiki/Abstract_algebra "Abstract algebra")



*   [Chien search](https://en.wikipedia.org/wiki/Chien_search "Chien search"): a recursive algorithm for determining roots of polynomials defined over a finite field

*   [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")

*   [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").



### Computer algebra



Further information: [Computer algebra](https://en.wikipedia.org/wiki/Computer_algebra "Computer algebra")



*   [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")

*   [Cantor–Zassenhaus algorithm](https://en.wikipedia.org/wiki/Cantor%E2%80%93Zassenhaus_algorithm "Cantor–Zassenhaus algorithm"): factor polynomials over finite fields

*   [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)

*   [Gosper's algorithm](https://en.wikipedia.org/wiki/Gosper%27s_algorithm "Gosper's algorithm"): find sums of hypergeometric terms that are themselves hypergeometric terms

*   [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

*   [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

*   [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

*   [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

*   [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"))



### Geometry



Main category: [Geometric algorithms](https://en.wikipedia.org/wiki/Category:Geometric_algorithms "Category:Geometric algorithms")



Further information: [Computational geometry](https://en.wikipedia.org/wiki/Computational_geometry "Computational geometry")



*   [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

*   [Collision detection](https://en.wikipedia.org/wiki/Collision_detection "Collision detection") algorithms: check for the collision or intersection of two given solids

*   [Cone algorithm](https://en.wikipedia.org/wiki/Cone_algorithm "Cone algorithm"): identify surface points

*   [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

    *   [Graham scan](https://en.wikipedia.org/wiki/Graham_scan "Graham scan")

    *   [Quickhull](https://en.wikipedia.org/wiki/Quickhull "Quickhull")

    *   [Gift wrapping algorithm](https://en.wikipedia.org/wiki/Gift_wrapping_algorithm "Gift wrapping algorithm") or Jarvis march

    *   [Chan's algorithm](https://en.wikipedia.org/wiki/Chan%27s_algorithm "Chan's algorithm")

    *   [Kirkpatrick–Seidel algorithm](https://en.wikipedia.org/wiki/Kirkpatrick%E2%80%93Seidel_algorithm "Kirkpatrick–Seidel algorithm")

*   [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.

*   [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")

*   [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.

*   [Jump-and-Walk algorithm](https://en.wikipedia.org/wiki/Jump-and-Walk_algorithm "Jump-and-Walk algorithm"): an algorithm for point location in triangulations

*   [Laplacian smoothing](https://en.wikipedia.org/wiki/Laplacian_smoothing "Laplacian smoothing"): an algorithm to smooth a polygonal mesh

*   [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")

    *   [Bentley–Ottmann algorithm](https://en.wikipedia.org/wiki/Bentley%E2%80%93Ottmann_algorithm "Bentley–Ottmann algorithm")

    *   [Shamos–Hoey algorithm](/w/index.php?title=Shamos%E2%80%93Hoey_algorithm&action=edit&redlink=1 "Shamos–Hoey algorithm (page does not exist)")

*   [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

*   [Nearest neighbor search](https://en.wikipedia.org/wiki/Nearest_neighbor_search "Nearest neighbor search"): find the nearest point or points to a query point

*   [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

*   [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.

*   [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").

*   [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

*   [Triangulation](https://en.wikipedia.org/wiki/Triangulation_(geometry) "Triangulation (geometry)")

    *   [Delaunay triangulation](https://en.wikipedia.org/wiki/Delaunay_triangulation "Delaunay triangulation")

        *   [Ruppert's algorithm](https://en.wikipedia.org/wiki/Ruppert%27s_algorithm "Ruppert's algorithm") (also known as Delaunay refinement): create quality Delaunay triangulations

        *   [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")

    *   [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")

    *   [Polygon triangulation](https://en.wikipedia.org/wiki/Polygon_triangulation "Polygon triangulation") algorithms: decompose a polygon into a set of triangles

    *   [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")

        *   [Bowyer–Watson algorithm](https://en.wikipedia.org/wiki/Bowyer%E2%80%93Watson_algorithm "Bowyer–Watson algorithm"): create voronoi diagram in any number of dimensions

        *   [Fortune's Algorithm](https://en.wikipedia.org/wiki/Fortune%27s_Algorithm "Fortune's Algorithm"): create voronoi diagram

    *   [Quasitriangulation](https://en.wikipedia.org/wiki/Quasitriangulation "Quasitriangulation")



### Number theoretic algorithms



Further information: [Number theory](https://en.wikipedia.org/wiki/Number_theory "Number theory")



*   [Binary GCD algorithm](https://en.wikipedia.org/wiki/Binary_GCD_algorithm "Binary GCD algorithm"): Efficient way of calculating GCD.

*   [Booth's multiplication algorithm](https://en.wikipedia.org/wiki/Booth%27s_multiplication_algorithm "Booth's multiplication algorithm")

*   [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")

*   [Discrete logarithm](https://en.wikipedia.org/wiki/Discrete_logarithm "Discrete logarithm"):

    *   [Baby-step giant-step](https://en.wikipedia.org/wiki/Baby-step_giant-step "Baby-step giant-step")

    *   [Index calculus algorithm](https://en.wikipedia.org/wiki/Index_calculus_algorithm "Index calculus algorithm")

    *   [Pollard's rho algorithm for logarithms](https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm_for_logarithms "Pollard's rho algorithm for logarithms")

    *   [Pohlig–Hellman algorithm](https://en.wikipedia.org/wiki/Pohlig%E2%80%93Hellman_algorithm "Pohlig–Hellman algorithm")

*   [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")

*   [Extended Euclidean algorithm](https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm "Extended Euclidean algorithm"): Also solves the equation _ax_ + _by_ = _c_.

*   [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

    *   [Congruence of squares](https://en.wikipedia.org/wiki/Congruence_of_squares "Congruence of squares")

    *   [Dixon's algorithm](https://en.wikipedia.org/wiki/Dixon%27s_algorithm "Dixon's algorithm")

    *   [Fermat's factorization method](https://en.wikipedia.org/wiki/Fermat%27s_factorization_method "Fermat's factorization method")

    *   [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve "General number field sieve")

    *   [Lenstra elliptic curve factorization](https://en.wikipedia.org/wiki/Lenstra_elliptic_curve_factorization "Lenstra elliptic curve factorization")

    *   [Pollard's _p_ − 1 algorithm](https://en.wikipedia.org/wiki/Pollard%27s_p_%E2%88%92_1_algorithm "Pollard's p − 1 algorithm")

    *   [Pollard's rho algorithm](https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm "Pollard's rho algorithm")

    *   [prime factorization algorithm](https://en.wikipedia.org/wiki/Prime_factorization_algorithm "Prime factorization algorithm")

    *   [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve "Quadratic sieve")

    *   [Shor's algorithm](https://en.wikipedia.org/wiki/Shor%27s_algorithm "Shor's algorithm")

    *   [Special number field sieve](https://en.wikipedia.org/wiki/Special_number_field_sieve "Special number field sieve")

    *   [Trial division](https://en.wikipedia.org/wiki/Trial_division "Trial division")

*   [Multiplication algorithms](https://en.wikipedia.org/wiki/Multiplication_algorithm "Multiplication algorithm"): fast multiplication of two numbers

    *   [Karatsuba algorithm](https://en.wikipedia.org/wiki/Karatsuba_algorithm "Karatsuba algorithm")

    *   [Schönhage–Strassen algorithm](https://en.wikipedia.org/wiki/Sch%C3%B6nhage%E2%80%93Strassen_algorithm "Schönhage–Strassen algorithm")

    *   [Toom–Cook multiplication](https://en.wikipedia.org/wiki/Toom%E2%80%93Cook_multiplication "Toom–Cook multiplication")

*   [Modular square root](https://en.wikipedia.org/wiki/Modular_square_root "Modular square root"): computing square roots modulo a prime number

    *   [Tonelli–Shanks algorithm](https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm "Tonelli–Shanks algorithm")

    *   [Cipolla's algorithm](https://en.wikipedia.org/wiki/Cipolla%27s_algorithm "Cipolla's algorithm")

    *   [Berlekamp's root finding algorithm](https://en.wikipedia.org/wiki/Berlekamp%27s_root_finding_algorithm "Berlekamp's root finding algorithm")

*   [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")

*   [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

*   [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")

    *   [AKS primality test](https://en.wikipedia.org/wiki/AKS_primality_test "AKS primality test")

    *   [Baillie-PSW primality test](https://en.wikipedia.org/wiki/Baillie-PSW_primality_test "Baillie-PSW primality test")

    *   [Fermat primality test](https://en.wikipedia.org/wiki/Fermat_primality_test "Fermat primality test")

    *   [Lucas primality test](https://en.wikipedia.org/wiki/Lucas_primality_test "Lucas primality test")

    *   [Miller–Rabin primality test](https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test "Miller–Rabin primality test")

    *   [Sieve of Atkin](https://en.wikipedia.org/wiki/Sieve_of_Atkin "Sieve of Atkin")

    *   [Sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes "Sieve of Eratosthenes")

    *   [Sieve of Sundaram](https://en.wikipedia.org/wiki/Sieve_of_Sundaram "Sieve of Sundaram")



### Numerical algorithms



Further 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")



#### Differential equation solving



Further information: [Differential equation](https://en.wikipedia.org/wiki/Differential_equation "Differential equation")



*   [Euler method](https://en.wikipedia.org/wiki/Euler_method "Euler method")

*   [Backward Euler method](https://en.wikipedia.org/wiki/Backward_Euler_method "Backward Euler method")

*   [Trapezoidal rule (differential equations)](https://en.wikipedia.org/wiki/Trapezoidal_rule_(differential_equations) "Trapezoidal rule (differential equations)")

*   [Linear multistep methods](https://en.wikipedia.org/wiki/Linear_multistep_method "Linear multistep method")

*   [Runge–Kutta methods](https://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods "Runge–Kutta methods")

    *   [Euler integration](https://en.wikipedia.org/wiki/Euler_integration "Euler integration")

*   [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

*   [Partial differential equation](https://en.wikipedia.org/wiki/Partial_differential_equation "Partial differential equation"):

    *   [Finite difference method](https://en.wikipedia.org/wiki/Finite_difference_method "Finite difference method")

    *   [Crank–Nicolson method](https://en.wikipedia.org/wiki/Crank%E2%80%93Nicolson_method "Crank–Nicolson method") for diffusion equations

    *   [Lax-Wendroff](https://en.wikipedia.org/wiki/Lax%E2%80%93Wendroff_method "Lax–Wendroff method") for wave equations

*   [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



#### Elementary and special functions



Further information: [Special functions](https://en.wikipedia.org/wiki/Special_functions "Special functions")



*   [Computation of π](https://en.wikipedia.org/wiki/Computing_%CF%80 "Computing π"):

    *   [Borwein's algorithm](https://en.wikipedia.org/wiki/Borwein%27s_algorithm "Borwein's algorithm"): an algorithm to calculate the value of 1/π

    *   [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")

    *   [Chudnovsky algorithm](https://en.wikipedia.org/wiki/Chudnovsky_algorithm "Chudnovsky algorithm"): A fast method for calculating the digits of π

    *   [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 π

*   [Division algorithms](https://en.wikipedia.org/wiki/Division_algorithm "Division algorithm"): for computing quotient and/or remainder of two numbers

    *   [Long division](https://en.wikipedia.org/wiki/Long_division "Long division")

    *   [Restoring division](https://en.wikipedia.org/wiki/Restoring_division "Restoring division")

    *   [Non-restoring division](https://en.wikipedia.org/wiki/Non-restoring_division "Non-restoring division")

    *   [SRT division](https://en.wikipedia.org/wiki/SRT_division "SRT division")

    *   [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.

    *   [Goldschmidt division](https://en.wikipedia.org/wiki/Goldschmidt_division "Goldschmidt division")

*   Hyperbolic and Trigonometric Functions:

    *   [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

    *   [CORDIC](https://en.wikipedia.org/wiki/CORDIC "CORDIC"): compute hyperbolic and trigonometric functions using a table of arctangents

*   Exponentiation:

    *   [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

    *   [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

*   [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

*   [Multiplication algorithms](https://en.wikipedia.org/wiki/Multiplication_algorithm "Multiplication algorithm"): fast multiplication of two numbers

    *   [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

    *   [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")

    *   [Karatsuba algorithm](https://en.wikipedia.org/wiki/Karatsuba_algorithm "Karatsuba algorithm"): an efficient procedure for multiplying large numbers

    *   [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

    *   [Toom–Cook multiplication](https://en.wikipedia.org/wiki/Toom%E2%80%93Cook_multiplication "Toom–Cook multiplication"): (Toom3) a multiplication algorithm for large integers

*   [Multiplicative inverse Algorithms](https://en.wikipedia.org/wiki/Multiplicative_inverse#Algorithms "Multiplicative inverse"): for computing a number's multiplicative inverse (reciprocal).

    *   [Newton's method](https://en.wikipedia.org/wiki/Newton%27s_method#Multiplicative_inverses_of_numbers_and_power_series "Newton's method")

*   [Rounding functions](https://en.wikipedia.org/wiki/Rounding_functions "Rounding functions"): the classic ways to round numbers

*   [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

*   Square and Nth root of a number:

    *   [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

    *   [Methods of computing square roots](https://en.wikipedia.org/wiki/Methods_of_computing_square_roots "Methods of computing square roots")

    *   [_n_th root algorithm](https://en.wikipedia.org/wiki/Nth_root_algorithm "Nth root algorithm")

    *   [Shifting nth-root algorithm](https://en.wikipedia.org/wiki/Shifting_nth-root_algorithm "Shifting nth-root algorithm"): digit by digit root extraction

*   Summation:

    *   [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

    *   [Kahan summation algorithm](https://en.wikipedia.org/wiki/Kahan_summation_algorithm "Kahan summation algorithm"): a more accurate method of summing floating-point numbers

*   [Unrestricted algorithm](https://en.wikipedia.org/wiki/Unrestricted_algorithm "Unrestricted algorithm")



#### Geometric



*   [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").

*   [Level set method](https://en.wikipedia.org/wiki/Level_set_method "Level set method") (LSM): a numerical technique for tracking interfaces and shapes



#### Interpolation and extrapolation



Further information: [Interpolation](https://en.wikipedia.org/wiki/Interpolation "Interpolation") and [Extrapolation](https://en.wikipedia.org/wiki/Extrapolation "Extrapolation")



*   [Birkhoff interpolation](https://en.wikipedia.org/wiki/Birkhoff_interpolation "Birkhoff interpolation"): an extension of polynomial interpolation

*   [Cubic interpolation](https://en.wikipedia.org/wiki/Cubic_interpolation "Cubic interpolation")

*   [Hermite interpolation](https://en.wikipedia.org/wiki/Hermite_interpolation "Hermite interpolation")

*   [Lagrange interpolation](https://en.wikipedia.org/wiki/Lagrange_interpolation "Lagrange interpolation"): interpolation using [Lagrange polynomials](https://en.wikipedia.org/wiki/Lagrange_polynomial "Lagrange polynomial")

*   [Linear interpolation](https://en.wikipedia.org/wiki/Linear_interpolation "Linear interpolation"): a method of curve fitting using linear polynomials

*   [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.

*   [Multivariate interpolation](https://en.wikipedia.org/wiki/Multivariate_interpolation "Multivariate interpolation")

    *   [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

    *   [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

    *   [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

    *   [Nearest-neighbor interpolation](https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation "Nearest-neighbor interpolation")

    *   [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

*   [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").

*   [Polynomial interpolation](https://en.wikipedia.org/wiki/Polynomial_interpolation "Polynomial interpolation")

    *   [Neville's algorithm](https://en.wikipedia.org/wiki/Neville%27s_algorithm "Neville's algorithm")

*   [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").

    *   [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")

    *   [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")

*   [Trigonometric interpolation](https://en.wikipedia.org/wiki/Trigonometric_interpolation "Trigonometric interpolation")



#### Linear algebra



Further information: [Numerical linear algebra](https://en.wikipedia.org/wiki/Numerical_linear_algebra "Numerical linear algebra")



*   [Eigenvalue algorithms](https://en.wikipedia.org/wiki/Eigenvalue_algorithm "Eigenvalue algorithm")

    *   [Arnoldi iteration](https://en.wikipedia.org/wiki/Arnoldi_iteration "Arnoldi iteration")

    *   [Inverse iteration](https://en.wikipedia.org/wiki/Inverse_iteration "Inverse iteration")

    *   [Jacobi method](https://en.wikipedia.org/wiki/Jacobi_eigenvalue_algorithm "Jacobi eigenvalue algorithm")

    *   [Lanczos iteration](https://en.wikipedia.org/wiki/Lanczos_iteration "Lanczos iteration")

    *   [Power iteration](https://en.wikipedia.org/wiki/Power_iteration "Power iteration")

    *   [QR algorithm](https://en.wikipedia.org/wiki/QR_algorithm "QR algorithm")

    *   [Rayleigh quotient iteration](https://en.wikipedia.org/wiki/Rayleigh_quotient_iteration "Rayleigh quotient iteration")

*   [Gram–Schmidt process](https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process "Gram–Schmidt process"): orthogonalizes a set of vectors

*   [Matrix multiplication algorithms](https://en.wikipedia.org/wiki/Matrix_multiplication_algorithm "Matrix multiplication algorithm")

    *   [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

    *   [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")

    *   [Freivalds' algorithm](https://en.wikipedia.org/wiki/Freivalds%27_algorithm "Freivalds' algorithm"): a randomized algorithm used to verify matrix multiplication

    *   [Strassen algorithm](https://en.wikipedia.org/wiki/Strassen_algorithm "Strassen algorithm"): faster [matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication "Matrix multiplication")



*   Solving [systems of linear equations](https://en.wikipedia.org/wiki/System_of_linear_equations "System of linear equations")

    *   [Biconjugate gradient method](https://en.wikipedia.org/wiki/Biconjugate_gradient_method "Biconjugate gradient method"): solves systems of linear equations

    *   [Conjugate gradient](https://en.wikipedia.org/wiki/Conjugate_gradient "Conjugate gradient"): an algorithm for the numerical solution of particular systems of linear equations

    *   [Gaussian elimination](https://en.wikipedia.org/wiki/Gaussian_elimination "Gaussian elimination")

    *   [Gauss–Jordan elimination](https://en.wikipedia.org/wiki/Gauss%E2%80%93Jordan_elimination "Gauss–Jordan elimination"): solves systems of linear equations

    *   [Gauss–Seidel method](https://en.wikipedia.org/wiki/Gauss%E2%80%93Seidel_method "Gauss–Seidel method"): solves systems of linear equations iteratively

    *   [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")

    *   [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

    *   [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")

    *   [Tridiagonal matrix algorithm](https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm "Tridiagonal matrix algorithm") (Thomas algorithm): solves systems of tridiagonal equations

*   [Sparse matrix](https://en.wikipedia.org/wiki/Sparse_matrix "Sparse matrix") algorithms

    *   [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")

    *   [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")

    *   [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")



#### Monte Carlo



Further information: [Monte Carlo method](https://en.wikipedia.org/wiki/Monte_Carlo_method "Monte Carlo method")



*   [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

*   [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.

*   [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

*   [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



#### Numerical integration



Further information: [Numerical integration](https://en.wikipedia.org/wiki/Numerical_integration "Numerical integration")



*   [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")



#### Root finding



Main article: [Root-finding algorithm](https://en.wikipedia.org/wiki/Root-finding_algorithm "Root-finding algorithm")



*   [Bisection method](https://en.wikipedia.org/wiki/Bisection_method "Bisection method")

*   [False position method](https://en.wikipedia.org/wiki/False_position_method "False position method"): approximates roots of a function

*   [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")

*   [Halley's method](https://en.wikipedia.org/wiki/Halley%27s_method "Halley's method"): uses first and second derivatives

*   [Secant method](https://en.wikipedia.org/wiki/Secant_method "Secant method"): 2-point, 1-sided

*   [False position method](https://en.wikipedia.org/wiki/False_position_method "False position method") and Illinois method: 2-point, bracketing

*   [Ridder's method](https://en.wikipedia.org/wiki/Ridder%27s_method "Ridder's method"): 3-point, exponential scaling

*   [Muller's method](https://en.wikipedia.org/wiki/Muller%27s_method "Muller's method"): 3-point, quadratic interpolation



### Optimization algorithms



Main article: [Mathematical optimization](https://en.wikipedia.org/wiki/Mathematical_optimization "Mathematical optimization")



*   [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

*   [Branch and bound](https://en.wikipedia.org/wiki/Branch_and_bound "Branch and bound")

*   [Bruss algorithm](https://en.wikipedia.org/wiki/Bruss_algorithm "Bruss algorithm"): see [odds algorithm](https://en.wikipedia.org/wiki/Odds_algorithm "Odds algorithm")

*   [Chain matrix multiplication](https://en.wikipedia.org/wiki/Chain_matrix_multiplication "Chain matrix multiplication")

*   [Combinatorial optimization](https://en.wikipedia.org/wiki/Combinatorial_optimization "Combinatorial optimization"): optimization problems where the set of feasible solutions is discrete

    *   [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

    *   [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

*   [Constraint satisfaction](https://en.wikipedia.org/wiki/Constraint_satisfaction "Constraint satisfaction")

    *   General algorithms for the constraint satisfaction

        *   [AC-3 algorithm](https://en.wikipedia.org/wiki/AC-3_algorithm "AC-3 algorithm")

        *   [Difference map algorithm](https://en.wikipedia.org/wiki/Difference_map_algorithm "Difference map algorithm")

        *   [Min conflicts algorithm](https://en.wikipedia.org/wiki/Min_conflicts_algorithm "Min conflicts algorithm")

    *   [Chaff algorithm](https://en.wikipedia.org/wiki/Chaff_algorithm "Chaff algorithm"): an algorithm for solving instances of the boolean satisfiability problem

    *   [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

    *   [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

    *   [Exact cover](https://en.wikipedia.org/wiki/Exact_cover "Exact cover") problem

        *   [Algorithm X](https://en.wikipedia.org/wiki/Algorithm_X "Algorithm X"): a [nondeterministic algorithm](https://en.wikipedia.org/wiki/Nondeterministic_algorithm "Nondeterministic algorithm")

        *   [Dancing Links](https://en.wikipedia.org/wiki/Dancing_Links "Dancing Links"): an efficient implementation of Algorithm X

*   [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")

*   [Differential evolution](https://en.wikipedia.org/wiki/Differential_evolution "Differential evolution")

*   [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")

*   [Ellipsoid method](https://en.wikipedia.org/wiki/Ellipsoid_method "Ellipsoid method"): is an algorithm for solving convex optimization problems

*   [Evolutionary computation](https://en.wikipedia.org/wiki/Evolutionary_computation "Evolutionary computation"): optimization inspired by biological mechanisms of evolution

    *   [Evolution strategy](https://en.wikipedia.org/wiki/Evolution_strategy "Evolution strategy")

    *   [Gene expression programming](https://en.wikipedia.org/wiki/Gene_expression_programming "Gene expression programming")

    *   [Genetic algorithms](https://en.wikipedia.org/wiki/Genetic_algorithms "Genetic algorithms")

        *   [Fitness proportionate selection](https://en.wikipedia.org/wiki/Fitness_proportionate_selection "Fitness proportionate selection") - also known as roulette-wheel selection

        *   [Stochastic universal sampling](https://en.wikipedia.org/wiki/Stochastic_universal_sampling "Stochastic universal sampling")

        *   [Truncation selection](https://en.wikipedia.org/wiki/Truncation_selection "Truncation selection")

        *   [Tournament selection](https://en.wikipedia.org/wiki/Tournament_selection "Tournament selection")

    *   [Memetic algorithm](https://en.wikipedia.org/wiki/Memetic_algorithm "Memetic algorithm")

    *   [Swarm intelligence](https://en.wikipedia.org/wiki/Swarm_intelligence "Swarm intelligence")

        *   [Ant colony optimization](https://en.wikipedia.org/wiki/Ant_colony_optimization "Ant colony optimization")

        *   [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

        *   [Particle swarm](https://en.wikipedia.org/wiki/Particle_swarm_optimization "Particle swarm optimization")

*   [golden section search](https://en.wikipedia.org/wiki/Golden_section_search "Golden section search"): an algorithm for finding the maximum of a real function

*   [Gradient descent](https://en.wikipedia.org/wiki/Gradient_descent "Gradient descent")

*   [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

*   [Interior point method](https://en.wikipedia.org/wiki/Interior_point_method "Interior point method")

*   [Linear programming](https://en.wikipedia.org/wiki/Linear_programming "Linear programming")

    *   [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

    *   [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

    *   [Delayed column generation](https://en.wikipedia.org/wiki/Delayed_column_generation "Delayed column generation")

    *   [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

        *   [Branch and cut](https://en.wikipedia.org/wiki/Branch_and_cut "Branch and cut")

        *   [Cutting-plane method](https://en.wikipedia.org/wiki/Cutting-plane_method "Cutting-plane method")

    *   [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").

    *   [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

*   [Line search](https://en.wikipedia.org/wiki/Line_search "Line search")

*   [Local search](https://en.wikipedia.org/wiki/Local_search_(optimization) "Local search (optimization)"): a metaheuristic for solving computationally hard optimization problems

    *   [Random-restart hill climbing](https://en.wikipedia.org/wiki/Random-restart_hill_climbing "Random-restart hill climbing")

    *   [Tabu search](https://en.wikipedia.org/wiki/Tabu_search "Tabu search")

*   [Minimax](https://en.wikipedia.org/wiki/Minimax#Minimax_algorithm_with_alternate_moves "Minimax") used in game programming

*   [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")

    *   [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

*   [Newton's method in optimization](https://en.wikipedia.org/wiki/Newton%27s_method_in_optimization "Newton's method in optimization")

*   [Nonlinear optimization](https://en.wikipedia.org/wiki/Nonlinear_optimization "Nonlinear optimization")

    *   [BFGS method](https://en.wikipedia.org/wiki/BFGS_method "BFGS method"): A [nonlinear optimization](https://en.wikipedia.org/wiki/Nonlinear_optimization "Nonlinear optimization") algorithm

    *   [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.

    *   [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.

    *   [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

*   [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

*   [Simulated annealing](https://en.wikipedia.org/wiki/Simulated_annealing "Simulated annealing")

*   [Stochastic tunneling](https://en.wikipedia.org/wiki/Stochastic_tunneling "Stochastic tunneling")

*   [Subset sum](https://en.wikipedia.org/wiki/Subset_sum_problem "Subset sum problem") algorithm



Computational science\[[edit](/w/index.php?title=List_of_algorithms&action=edit&section=35 "Edit section: Computational science")\]

-----------------------------------------------------------------------------------------------------------------------------------



Further information: [Computational science](https://en.wikipedia.org/wiki/Computational_science "Computational science")



### Astronomy



Main article: [Astronomical algorithms](https://en.wikipedia.org/wiki/Astronomical_algorithms "Astronomical algorithms")



*   [Doomsday algorithm](https://en.wikipedia.org/wiki/Doomsday_algorithm "Doomsday algorithm"): day of the week

*   [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

*   various [Easter algorithms](https://en.wikipedia.org/wiki/Computus "Computus") are used to calculate the day of Easter



### Bioinformatics



Further information: [Bioinformatics](https://en.wikipedia.org/wiki/Bioinformatics "Bioinformatics")



See also: [Sequence alignment algorithms](https://en.wikipedia.org/wiki/List_of_algorithms#Sequence_alignment "List of algorithms")



*   [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

*   [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.

*   [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")

*   [Sorting by signed reversals](/w/index.php?title=Sorting_by_signed_reversals&action=edit&redlink=1 "Sorting by signed reversals (page does not exist)"): an algorithm for understanding genomic evolution.

*   [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.

*   [UPGMA](https://en.wikipedia.org/wiki/UPGMA "UPGMA"): a distance-based phylogenetic tree construction algorithm.



### Geoscience



Further information: [Geoscience](https://en.wikipedia.org/wiki/Geoscience "Geoscience")



*   [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

*   [Geohash](https://en.wikipedia.org/wiki/Geohash "Geohash"): a public domain algorithm that encodes a decimal latitude/longitude pair as a hash string



### Linguistics



Further 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")



*   [Lesk algorithm](https://en.wikipedia.org/wiki/Lesk_algorithm "Lesk algorithm"): word sense disambiguation

*   [Stemming algorithm](https://en.wikipedia.org/wiki/Stemming "Stemming"): a method of reducing words to their stem, base, or root form

*   [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



### Medicine



Further information: [Medical algorithms](https://en.wikipedia.org/wiki/Medical_algorithms "Medical algorithms")



*   [ESC algorithm](https://en.wikipedia.org/wiki/ESC_algorithm "ESC algorithm") for the diagnosis of heart failure

*   [Manning Criteria](https://en.wikipedia.org/wiki/Manning_Criteria "Manning Criteria") for irritable bowel syndrome

*   [Pulmonary embolism](https://en.wikipedia.org/wiki/Pulmonary_embolism#Algorithms "Pulmonary embolism") diagnostic algorithms

*   [Texas Medication Algorithm Project](https://en.wikipedia.org/wiki/Texas_Medication_Algorithm_Project "Texas Medication Algorithm Project")



### Physics



Further information: [Computational physics](https://en.wikipedia.org/wiki/Computational_physics "Computational physics")



*   [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

*   [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

*   [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

*   [Ground state](https://en.wikipedia.org/wiki/Ground_state "Ground state") approximation

    *   [Variational method](https://en.wikipedia.org/wiki/Variational_method "Variational method")

        *   [Ritz method](https://en.wikipedia.org/wiki/Ritz_method "Ritz method")

*   [N-body problems](https://en.wikipedia.org/wiki/N-body_problem "N-body problem")

    *   [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.

    *   [Fast multipole method](https://en.wikipedia.org/wiki/Fast_multipole_method "Fast multipole method") (FMM): speeds up the calculation of long-ranged forces

*   [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

*   [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

*   [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")



### Statistics



Further information: [Computational statistics](https://en.wikipedia.org/wiki/Computational_statistics "Computational statistics")



*   [Algorithms for calculating variance](https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance "Algorithms for calculating variance"): avoiding instability and numerical overflow

*   [Approximate counting algorithm](https://en.wikipedia.org/wiki/Approximate_counting_algorithm "Approximate counting algorithm"): Allows counting large number of events in a small register

*   [Bayesian statistics](https://en.wikipedia.org/wiki/Bayesian_statistics "Bayesian statistics")

    *   [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

*   [Clustering Algorithms](https://en.wikipedia.org/wiki/Data_clustering "Data clustering")

    *   [Average-linkage clustering](https://en.wikipedia.org/wiki/UPGMA "UPGMA"): a simple agglomerative clustering algorithm

    *   [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

    *   [Complete-linkage clustering](https://en.wikipedia.org/wiki/Complete-linkage_clustering "Complete-linkage clustering"): a simple agglomerative clustering algorithm

    *   [DBSCAN](https://en.wikipedia.org/wiki/DBSCAN "DBSCAN"): a density based clustering algorithm

    *   [Expectation-maximization algorithm](https://en.wikipedia.org/wiki/Expectation-maximization_algorithm "Expectation-maximization algorithm")

    *   [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

        *   [Fuzzy c-means](https://en.wikipedia.org/wiki/Fuzzy_clustering#Fuzzy_c-means_clustering "Fuzzy clustering")

        *   [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

    *   [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.

    *   [k-means clustering](https://en.wikipedia.org/wiki/K-means_clustering "K-means clustering"): cluster objects based on attributes into partitions

    *   [k-means++](https://en.wikipedia.org/wiki/K-means%2B%2B "K-means++"): a variation of this, using modified random seeds

    *   [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

    *   [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

    *   [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")

    *   [OPTICS](https://en.wikipedia.org/wiki/OPTICS_algorithm "OPTICS algorithm"): a density based clustering algorithm with a visual evaluation method

    *   [Single-linkage clustering](https://en.wikipedia.org/wiki/Single-linkage_clustering "Single-linkage clustering"): a simple agglomerative clustering algorithm

    *   [SUBCLU](https://en.wikipedia.org/wiki/SUBCLU "SUBCLU"): a subspace clustering algorithm

    *   [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

    *   [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

*   [Estimation Theory](https://en.wikipedia.org/wiki/Estimation_theory "Estimation theory")

    *   [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

        *   [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.

    *   [Odds algorithm](https://en.wikipedia.org/wiki/Odds_algorithm "Odds algorithm") (Bruss algorithm) Optimal online search for distinguished value in sequential random input

    *   [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

*   [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")

*   [Hidden Markov model](https://en.wikipedia.org/wiki/Hidden_Markov_model "Hidden Markov model")

    *   [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")

    *   [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

    *   [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")

*   [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

*   [Queuing theory](https://en.wikipedia.org/wiki/Queuing_theory "Queuing theory")

    *   [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")

*   [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

*   [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

*   [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

*   [Ziggurat algorithm](https://en.wikipedia.org/wiki/Ziggurat_algorithm "Ziggurat algorithm"): generate random numbers from a non-uniform distribution



Computer science\[[edit](/w/index.php?title=List_of_algorithms&action=edit&section=43 "Edit section: Computer science")\]

-------------------------------------------------------------------------------------------------------------------------



Further information: [Computer science](https://en.wikipedia.org/wiki/Computer_science "Computer science")



### Computer architecture



Further information: [Computer architecture](https://en.wikipedia.org/wiki/Computer_architecture "Computer architecture")



*   [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



### Computer graphics



Further information: [Computer graphics](https://en.wikipedia.org/wiki/Computer_graphics "Computer graphics")



*   [Clipping](https://en.wikipedia.org/wiki/Clipping_(computer_graphics) "Clipping (computer graphics)")

    *   [Line clipping](https://en.wikipedia.org/wiki/Line_clipping "Line clipping")

        *   [Cohen–Sutherland](https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland "Cohen–Sutherland")

        *   [Cyrus–Beck](https://en.wikipedia.org/wiki/Cyrus%E2%80%93Beck "Cyrus–Beck")

        *   [Fast-clipping](https://en.wikipedia.org/wiki/Fast_clipping "Fast clipping")

        *   [Liang–Barsky](https://en.wikipedia.org/wiki/Liang%E2%80%93Barsky "Liang–Barsky")

        *   [Nicholl–Lee–Nicholl](https://en.wikipedia.org/wiki/Nicholl%E2%80%93Lee%E2%80%93Nicholl "Nicholl–Lee–Nicholl")

    *   Polygon clipping

        *   [Sutherland–Hodgman](https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman "Sutherland–Hodgman")

        *   [Vatti](https://en.wikipedia.org/wiki/Vatti_clipping_algorithm "Vatti clipping algorithm")

        *   [Weiler–Atherton](https://en.wikipedia.org/wiki/Weiler%E2%80%93Atherton "Weiler–Atherton")

*   [Contour lines](https://en.wikipedia.org/wiki/Contour_line "Contour line") and [Isosurfaces](https://en.wikipedia.org/wiki/Isosurface "Isosurface")

    *   [Marching cubes](