javascript-algorithms/README.md

238 lines
20 KiB
Markdown
Raw Normal View History

2018-03-27 19:43:15 +08:00
# JavaScript Algorithms and Data Structures
2018-03-26 04:28:32 +08:00
2018-03-28 14:41:20 +08:00
[![Build Status](https://travis-ci.org/trekhleb/javascript-algorithms.svg?branch=master)](https://travis-ci.org/trekhleb/javascript-algorithms)
2018-04-04 12:11:59 +08:00
[![codecov](https://codecov.io/gh/trekhleb/javascript-algorithms/branch/master/graph/badge.svg)](https://codecov.io/gh/trekhleb/javascript-algorithms)
2018-03-28 14:41:20 +08:00
2018-06-12 19:28:19 +08:00
This repository contains JavaScript based examples of many
2018-05-18 03:10:39 +08:00
popular algorithms and data structures.
Each algorithm and data structure has its own separate README
with related explanations and links for further reading (including ones
to YouTube videos).
2018-05-18 03:10:39 +08:00
2018-06-12 19:28:19 +08:00
_Read this in other languages:_
2018-05-26 05:36:45 +08:00
[简体中文](https://github.com/trekhleb/javascript-algorithms/blob/master/README.zh-CN.md),
[繁體中文](https://github.com/trekhleb/javascript-algorithms/blob/master/README.zh-TW.md)
2018-05-24 13:57:11 +08:00
2018-04-26 12:27:44 +08:00
## Data Structures
2018-03-27 20:14:57 +08:00
A data structure is a particular way of organizing and storing data in a computer so that it can
2018-06-12 19:28:19 +08:00
be accessed and modified efficiently. More precisely, a data structure is a collection of data
values, the relationships among them, and the functions or operations that can be applied to
2018-05-19 15:24:32 +08:00
the data.
2018-05-18 03:01:17 +08:00
* [Linked List](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/linked-list)
* [Queue](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/queue)
* [Stack](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/stack)
* [Hash Table](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/hash-table)
* [Heap](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/heap)
* [Priority Queue](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/priority-queue)
* [Trie](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/trie)
* [Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree)
* [Binary Search Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/binary-search-tree)
* [AVL Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/avl-tree)
2018-06-02 13:15:40 +08:00
* [Red-Black Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/red-black-tree)
2018-06-05 13:45:00 +08:00
* [Segment Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/segment-tree) - with min/max/sum range queries examples
* [Fenwick Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/fenwick-tree) (Binary Indexed Tree)
2018-05-18 03:01:17 +08:00
* [Graph](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/graph) (both directed and undirected)
* [Disjoint Set](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/disjoint-set)
2018-03-27 20:14:57 +08:00
2018-04-26 12:27:44 +08:00
## Algorithms
2018-03-29 15:22:08 +08:00
An algorithm is an unambiguous specification of how to solve a class of problems. It is
a set of rules that precisely define a sequence of operations.
2018-05-19 15:34:22 +08:00
2018-04-26 12:39:08 +08:00
### Algorithms by Topic
2018-05-18 03:01:17 +08:00
* **Math**
2018-04-18 18:04:05 +08:00
* [Factorial](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/factorial)
2018-04-02 13:45:50 +08:00
* [Fibonacci Number](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/fibonacci)
2018-04-23 14:38:46 +08:00
* [Primality Test](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/primality-test) (trial division method)
2018-04-24 12:55:53 +08:00
* [Euclidean Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/euclidean-algorithm) - calculate the Greatest Common Divisor (GCD)
* [Least Common Multiple](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/least-common-multiple) (LCM)
2018-04-30 23:00:17 +08:00
* [Integer Partition](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/integer-partition)
* [Sieve of Eratosthenes](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/sieve-of-eratosthenes) - finding all prime numbers up to any given limit
2018-06-05 01:42:22 +08:00
* [Is Power of Two](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/is-power-of-two) - check if the number is power of two (naive and bitwise algorithms)
2018-06-12 22:33:21 +08:00
* [Liu Hui π Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/liu-hui) - approximate π calculations based on N-gons
2018-04-26 12:26:12 +08:00
* **Sets**
* [Cartesian Product](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/cartesian-product) - product of multiple sets
* [Power Set](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/power-set) - all subsets of a set
2018-04-26 12:26:12 +08:00
* [Permutations](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/permutations) (with and without repetitions)
* [Combinations](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/combinations) (with and without repetitions)
2018-04-26 13:08:13 +08:00
* [FisherYates Shuffle](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/fisher-yates) - random permutation of a finite sequence
2018-06-12 22:49:40 +08:00
* [Longest Common Subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequence) (LCS)
2018-06-12 22:51:10 +08:00
* [Longest Increasing Subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-increasing-subsequence)
2018-04-27 13:19:11 +08:00
* [Shortest Common Supersequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/shortest-common-supersequence) (SCS)
2018-04-30 23:05:41 +08:00
* [Knapsack Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/knapsack-problem) - "0/1" and "Unbound" ones
2018-05-01 16:24:27 +08:00
* [Maximum Subarray](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/maximum-subarray) - "Brute Force" and "Dynamic Programming" (Kadane's) versions
* **Strings**
2018-04-25 21:00:26 +08:00
* [Levenshtein Distance](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
2018-04-24 19:45:55 +08:00
* [Hamming Distance](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/hamming-distance) - number of positions at which the symbols are different
2018-04-25 02:36:47 +08:00
* [KnuthMorrisPratt Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/knuth-morris-pratt) - substring search
* [Rabin Karp Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/rabin-karp) - substring search
2018-04-26 12:03:59 +08:00
* [Longest Common Substring](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/longest-common-substring)
* **Searches**
2018-05-26 06:01:08 +08:00
* [Linear Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/search/linear-search)
2018-04-17 00:30:29 +08:00
* [Binary Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/search/binary-search)
2018-04-17 01:49:52 +08:00
* **Sorting**
2018-04-12 16:53:26 +08:00
* [Bubble Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/bubble-sort)
* [Selection Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/selection-sort)
2018-04-13 12:49:47 +08:00
* [Insertion Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/insertion-sort)
2018-04-14 15:29:36 +08:00
* [Heap Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/heap-sort)
2018-04-14 16:48:33 +08:00
* [Merge Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/merge-sort)
* [Quicksort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/quick-sort) - in-place and non-in-place implementations
2018-04-15 13:42:01 +08:00
* [Shellsort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/shell-sort)
2018-05-29 12:29:28 +08:00
* [Counting Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/counting-sort)
* [Radix Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/radix-sort)
2018-06-02 14:15:08 +08:00
* **Trees**
2018-04-25 22:35:44 +08:00
* [Depth-First Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/tree/depth-first-search) (DFS)
* [Breadth-First Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/tree/breadth-first-search) (BFS)
2018-06-02 14:15:08 +08:00
* **Graphs**
2018-04-25 22:35:44 +08:00
* [Depth-First Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/depth-first-search) (DFS)
* [Breadth-First Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/breadth-first-search) (BFS)
2018-05-03 14:58:00 +08:00
* [Dijkstra Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/dijkstra) - finding shortest path to all graph vertices
* [Bellman-Ford Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/bellman-ford) - finding shortest path to all graph vertices
2018-05-06 22:57:45 +08:00
* [Detect Cycle](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/detect-cycle) - for both directed and undirected graphs (DFS and Disjoint Set based versions)
2018-05-07 17:45:10 +08:00
* [Prims Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/prim) - finding Minimum Spanning Tree (MST) for weighted undirected graph
2018-05-07 18:53:13 +08:00
* [Kruskals Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/kruskal) - finding Minimum Spanning Tree (MST) for weighted undirected graph
2018-05-09 00:27:42 +08:00
* [Topological Sorting](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/topological-sorting) - DFS method
2018-05-11 20:34:58 +08:00
* [Articulation Points](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/articulation-points) - Tarjan's algorithm (DFS based)
* [Bridges](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/bridges) - DFS based algorithm
2018-05-17 12:40:13 +08:00
* [Eulerian Path and Eulerian Circuit](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/eulerian-path) - Fleury's algorithm - Visit every edge exactly once
* [Hamiltonian Cycle](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/hamiltonian-cycle) - Visit every vertex exactly once
2018-05-14 12:13:07 +08:00
* [Strongly Connected Components](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/strongly-connected-components) - Kosaraju's algorithm
2018-05-21 14:00:38 +08:00
* [Travelling Salesman Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/travelling-salesman) - shortest possible route that visits each city and returns to the origin city
2018-04-17 01:49:52 +08:00
* **Uncategorized**
2018-05-14 13:56:44 +08:00
* [Tower of Hanoi](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/hanoi-tower)
2018-05-16 12:54:06 +08:00
* [N-Queens Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/n-queens)
2018-05-17 22:48:06 +08:00
* [Knight's Tour](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/knight-tour)
2018-06-12 19:28:19 +08:00
2018-04-26 12:39:08 +08:00
### Algorithms by Paradigm
2018-06-12 19:28:19 +08:00
An algorithmic paradigm is a generic method or approach which underlies the design of a class
of algorithms. It is an abstraction higher than the notion of an algorithm, just as an
2018-05-20 03:50:46 +08:00
algorithm is an abstraction higher than a computer program.
2018-05-20 04:05:20 +08:00
* **Brute Force** - look at all the possibilities and selects the best solution
2018-05-20 04:20:20 +08:00
* [Maximum Subarray](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/maximum-subarray)
2018-05-21 14:00:38 +08:00
* [Travelling Salesman Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/travelling-salesman) - shortest possible route that visits each city and returns to the origin city
2018-05-20 04:05:20 +08:00
* **Greedy** - choose the best option at the current time, without any consideration for the future
2018-04-30 19:08:14 +08:00
* [Unbound Knapsack Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/knapsack-problem)
2018-05-03 14:58:00 +08:00
* [Dijkstra Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/dijkstra) - finding shortest path to all graph vertices
2018-05-07 18:53:13 +08:00
* [Prims Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/prim) - finding Minimum Spanning Tree (MST) for weighted undirected graph
* [Kruskals Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/kruskal) - finding Minimum Spanning Tree (MST) for weighted undirected graph
2018-05-20 04:05:20 +08:00
* **Divide and Conquer** - divide the problem into smaller parts and then solve those parts
* [Binary Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/search/binary-search)
2018-05-14 13:56:44 +08:00
* [Tower of Hanoi](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/hanoi-tower)
2018-04-26 12:45:51 +08:00
* [Euclidean Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/euclidean-algorithm) - calculate the Greatest Common Divisor (GCD)
* [Permutations](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/permutations) (with and without repetitions)
* [Combinations](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/combinations) (with and without repetitions)
2018-04-26 12:52:07 +08:00
* [Merge Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/merge-sort)
* [Quicksort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/quick-sort)
* [Tree Depth-First Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/tree/depth-first-search) (DFS)
* [Graph Depth-First Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/depth-first-search) (DFS)
* **Dynamic Programming** - build up a solution using previously found sub-solutions
2018-04-26 12:42:11 +08:00
* [Fibonacci Number](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/fibonacci)
* [Levenshtein Distance](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
2018-04-26 13:08:13 +08:00
* [Longest Common Subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequnce) (LCS)
2018-04-26 12:42:11 +08:00
* [Longest Common Substring](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/longest-common-substring)
2018-04-26 20:49:52 +08:00
* [Longest Increasing subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-increasing-subsequence)
2018-04-27 13:19:11 +08:00
* [Shortest Common Supersequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/shortest-common-supersequence)
2018-04-30 19:08:14 +08:00
* [0/1 Knapsack Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/knapsack-problem)
2018-04-30 23:00:17 +08:00
* [Integer Partition](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/integer-partition)
2018-05-01 16:16:08 +08:00
* [Maximum Subarray](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/maximum-subarray)
2018-05-03 14:58:00 +08:00
* [Bellman-Ford Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/bellman-ford) - finding shortest path to all graph vertices
2018-06-03 03:43:30 +08:00
* **Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generate next solution you test
2018-06-12 19:28:19 +08:00
if it satisfies all conditions, and only then continue generating subsequent solutions. Otherwise, backtrack, and go on a
2018-06-03 03:43:30 +08:00
different path of finding a solution. Normally the DFS traversal of state-space is being used.
2018-05-17 12:40:13 +08:00
* [Hamiltonian Cycle](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/hamiltonian-cycle) - Visit every vertex exactly once
2018-05-16 12:54:06 +08:00
* [N-Queens Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/n-queens)
2018-05-17 22:48:06 +08:00
* [Knight's Tour](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/uncategorized/knight-tour)
2018-06-03 03:43:30 +08:00
* **Branch & Bound** - remember the lowest-cost solution found at each stage of the backtracking
search, and use the cost of the lowest-cost solution found so far as a lower bound on the cost of
a least-cost solution to the problem, in order to discard partial solutions with costs larger than the
lowest-cost solution found so far. Normally BFS traversal in combination with DFS traversal of state-space
tree is being used.
2018-05-16 12:54:06 +08:00
## How to use this repository
**Install all dependencies**
```
2018-05-18 03:03:10 +08:00
npm install
2018-05-16 12:54:06 +08:00
```
2018-03-27 19:43:15 +08:00
**Run all tests**
```
npm test
```
**Run tests by name**
```
npm test -- -t 'LinkedList'
```
2018-04-12 13:46:35 +08:00
2018-05-18 11:22:37 +08:00
**Playground**
2018-04-12 13:46:35 +08:00
You may play with data-structures and algorithms in `./src/playground/playground.js` file and write
tests for it in `./src/playground/__test__/playground.test.js`.
Then just simply run the following command to test if your playground code works as expected:
```
npm test -- -t 'playground'
```
2018-05-16 12:54:06 +08:00
## Useful Information
2018-04-12 13:46:35 +08:00
2018-05-16 12:54:06 +08:00
### References
2018-04-12 13:46:35 +08:00
2018-05-16 12:54:06 +08:00
[▶ Data Structures and Algorithms on YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
2018-04-12 13:49:34 +08:00
2018-04-12 13:46:35 +08:00
### Big O Notation
2018-06-12 19:28:19 +08:00
2018-04-12 13:46:35 +08:00
Order of growth of algorithms specified in Big O notation.
2018-06-12 19:28:19 +08:00
![Big O graphs](./assets/big-o-graph.png)
2018-04-15 11:57:34 +08:00
2018-04-12 13:46:35 +08:00
Source: [Big O Cheat Sheet](http://bigocheatsheet.com/).
2018-06-12 19:28:19 +08:00
2018-04-12 13:46:35 +08:00
Below is the list of some of the most used Big O notations and their performance comparisons against different sizes of the input data.
| Big O Notation | Computations for 10 elements | Computations for 100 elements | Computations for 1000 elements |
| -------------- | ---------------------------- | ----------------------------- | ------------------------------- |
| **O(1)** | 1 | 1 | 1 |
| **O(log N)** | 3 | 6 | 9 |
| **O(N)** | 10 | 100 | 1000 |
2018-05-24 06:38:02 +08:00
| **O(N log N)** | 30 | 600 | 9000 |
2018-04-12 13:46:35 +08:00
| **O(N^2)** | 100 | 10000 | 1000000 |
| **O(2^N)** | 1024 | 1.26e+29 | 1.07e+301 |
| **O(N!)** | 3628800 | 9.3e+157 | 4.02e+2567 |
2018-04-15 11:56:15 +08:00
### Data Structure Operations Complexity
2018-06-12 19:28:19 +08:00
| Data Structure | Access | Search | Insertion | Deletion | Comments |
2018-06-12 19:28:19 +08:00
| ----------------------- | :-------: | :-------: | :-------: | :-------: | :-------- |
| **Array** | 1 | n | n | n | |
| **Stack** | n | n | 1 | 1 | |
2018-06-12 19:28:19 +08:00
| **Queue** | n | n | 1 | 1 | |
| **Linked List** | n | n | 1 | 1 | |
| **Hash Table** | - | n | n | n | In case of perfect hash function costs would be O(1) |
2018-05-25 12:35:52 +08:00
| **Binary Search Tree** | n | n | n | n | In case of balanced tree costs would be O(log(n)) |
| **B-Tree** | log(n) | log(n) | log(n) | log(n) | |
| **Red-Black Tree** | log(n) | log(n) | log(n) | log(n) | |
| **AVL Tree** | log(n) | log(n) | log(n) | log(n) | |
### Array Sorting Algorithms Complexity
2018-05-29 12:36:41 +08:00
| Name | Best | Average | Worst | Memory | Stable | Comments |
| --------------------- | :-------: | :-------: | :-----------: | :-------: | :-------: | :-------- |
| **Bubble sort** | n | n^2 | n^2 | 1 | Yes | |
| **Insertion sort** | n | n^2 | n^2 | 1 | Yes | |
| **Selection sort** | n^2 | n^2 | n^2 | 1 | No | |
| **Heap sort** | n log(n) | n log(n) | n log(n) | 1 | No | |
| **Merge sort** | n log(n) | n log(n) | n log(n) | n | Yes | |
| **Quick sort** | n log(n) | n log(n) | n^2 | log(n) | No | |
| **Shell sort** | n log(n) | depends on gap sequence | n (log(n))^2 | 1 | No | |
2018-05-29 12:38:49 +08:00
| **Counting sort** | n + r | n + r | n + r | n + r | Yes | r - biggest number in array |
| **Radix sort** | n * k | n * k | n * k | n + k | Yes | k - length of longest key |