javascript-algorithms/README.md

# JavaScript Algorithms and Data Structures

[![Build Status](https://travis-ci.org/trekhleb/javascript-algorithms.svg?branch=master)](https://travis-ci.org/trekhleb/javascript-algorithms)
[![codecov](https://codecov.io/gh/trekhleb/javascript-algorithms/branch/master/graph/badge.svg)](https://codecov.io/gh/trekhleb/javascript-algorithms)

## Data Structures

1. [Linked List](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/linked-list)
2. [Queue](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/queue)
3. [Stack](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/stack)
4. [Hash Table](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/hash-table)
5. [Heap](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/heap)
6. [Priority Queue](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/priority-queue)
7. [Trie](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/trie)
8. [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)
    * Red-Black Tree
    * Suffix Tree
    * Segment Tree or Interval Tree
    * Binary Indexed Tree or Fenwick Tree
9. [Graph](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/graph) (both directed and undirected)
9. [Disjoint Set](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/disjoint-set)

## Algorithms

### Algorithms by Topic

* **Math**
  * [Factorial](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/factorial)
  * [Fibonacci Number](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/fibonacci)
  * [Primality Test](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/primality-test) (trial division method)
  * [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)
  * [Integer Partition](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/integer-partition)
* **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 the set 
  * [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)
  * [Fisher–Yates Shuffle](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/fisher-yates) - random permutation of a finite sequence
  * [Longest Common Subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequnce) (LCS) 
  * [Longest Increasing subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-increasing-subsequence)
  * [Shortest Common Supersequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/shortest-common-supersequence) (SCS)
  * [Knapsack Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/knapsack-problem) - "0/1" and "Unbound" ones
  * [Maximum Subarray](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/maximum-subarray) - "Brute Force" and "Dynamic Programming" (Kadane's) versions
* **String**
  * [Levenshtein Distance](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
  * [Hamming Distance](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/hamming-distance) - number of positions at which the symbols are different
  * [Knuth–Morris–Pratt 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
  * [Longest Common Substring](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/longest-common-substring)
* **Search**
  * [Binary Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/search/binary-search)
* **Sorting**
  * [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)
  * [Insertion Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/insertion-sort)
  * [Heap Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/heap-sort)
  * [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)
  * [Shellsort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/shell-sort)
* **Tree**  
  * [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)
* **Graph**
  * [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)
  * [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
  * [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)
  * [Prim’s Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/prim) - finding Minimum Spanning Tree (MST)
  * Kruskal’s Algorithm - finding Minimum Spanning Tree (MST)
  * Topological Sorting
  * Eulerian path, Eulerian circuit
  * Strongly Connected Component algorithm
  * Shortest Path Faster Algorithm (SPFA)
* **Uncategorized**  
  * Union-Find
  * Maze
  * Sudoku
  
### Algorithms by Paradigm

* **Greedy**
  * [Unbound Knapsack Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/knapsack-problem)
  * [Dijkstra Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/dijkstra) - finding shortest path to all graph vertices
  * [Prim’s Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/prim) - finding Minimum Spanning Tree (MST)
* **Divide and Conquer**
  * [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)
  * [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**
  * [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
  * [Longest Common Subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequnce) (LCS)
  * [Longest Common Substring](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/string/longest-common-substring)
  * [Longest Increasing subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-increasing-subsequence)
  * [Shortest Common Supersequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/shortest-common-supersequence)
  * [0/1 Knapsack Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/knapsack-problem)
  * [Integer Partition](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/integer-partition)
  * [Maximum Subarray](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/maximum-subarray)
  * [Bellman-Ford Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/bellman-ford) - finding shortest path to all graph vertices
* **Backtracking**
* **Branch & Bound**

## Running Tests

**Run all tests**
```
npm test
```

**Run tests by name**
```
npm test -- -t 'LinkedList'
```

## Playground

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'
```

## Useful links

[▶ Data Structures and Algorithms on YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

## Useful Information

### Big O Notation
    
Order of growth of algorithms specified in Big O notation.
    
![Big O graphs](https://github.com/trekhleb/javascript-algorithms/blob/master/assets/big-o-graph.png)

Source: [Big O Cheat Sheet](http://bigocheatsheet.com/).
    
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                            |
| **O(N log N)** | 30                           | 60                            | 9000                            |
| **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                      |

### Data Structure Operations Complexity
        
| Data Structure          | Access    | Search    | Insertion | Deletion  |
| ----------------------- | :-------: | :-------: | :-------: | :-------: | 
| **Array**               | 1         | n         | n         | n         |
| **Stack**               | n         | n         | 1         | 1         |
| **Queue**               | n         | n         | 1         | 1         | 
| **Linked List**         | n         | n         | 1         | 1         |
| **Hash Table**          | -         | n         | n         | n         |
| **Binary Search Tree**  | n         | n         | n         | 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

| Name                  | Best      | Average   | Worst         | Memory    | Stable    |
| --------------------- | :-------: | :-------: | :-----------: | :-------: | :-------: |
| **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        |
-												Update README.

											
										
										
											2018-03-27 19:43:15 +08:00
+								# JavaScript Algorithms and Data Structures
-												Add linked_list.

											
										
										
											2018-03-26 04:28:32 +08:00
-												Add Travis support.

											
										
										
											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)
-												Integrate codecov.

											
										
										
											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)
-												Add Travis support.

											
										
										
											2018-03-28 14:41:20 +08:00
-												Update README.

											
										
										
											2018-04-26 12:27:44 +08:00
+								## Data Structures
-												Add LinkedList.

											
										
										
											2018-03-27 20:14:57 +08:00
-												Add Stack.

											
										
										
											2018-03-28 22:01:46 +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)
-												Add Stack.

											
										
										
											2018-03-28 22:02:20 +08:00
+. [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)
-												Add Heap.

											
										
										
											2018-03-30 13:03:26 +08:00
+. [Heap](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/heap)
-												Refactor MinHeap.

											
										
										
											2018-04-03 23:17:14 +08:00
+. [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)
-												Add binary search tree.

											
										
										
											2018-04-02 22:53:38 +08:00
+								    * [Binary Search Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/binary-search-tree)
-												Add AVL Tree.

											
										
										
											2018-04-06 14:12:01 +08:00
+								    * [AVL Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/avl-tree)
-												Update README.

											
										
										
											2018-04-17 01:49:52 +08:00
+								    * Red-Black Tree
 								    * Suffix Tree
 								    * Segment Tree or Interval Tree
 								    * Binary Indexed Tree or Fenwick Tree
-												Update README.md

											
										
										
											2018-04-26 22:32:48 +08:00
+. [Graph](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/graph) (both directed and undirected)
-												Add disjoint set.

											
										
										
											2018-05-03 21:49:46 +08:00
+. [Disjoint Set](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/disjoint-set)
-												Add LinkedList.

											
										
										
											2018-03-27 20:14:57 +08:00
-												Update README.

											
										
										
											2018-04-26 12:27:44 +08:00
+								## Algorithms
-												Add Algorithms.

											
										
										
											2018-03-29 15:22:08 +08:00
-												Update README.

											
										
										
											2018-04-26 12:39:08 +08:00
+								### Algorithms by Topic
-												Update README.

											
										
										
											2018-04-17 01:49:52 +08:00
+								* **Math**
-												Add factorial.

											
										
										
											2018-04-18 18:04:05 +08:00
+								  * [Factorial](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/factorial)
-												Refactor algorithms structure.

											
										
										
											2018-04-02 13:45:50 +08:00
+								  * [Fibonacci Number](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/fibonacci)
-												Add combinations.

											
										
										
											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)
-												Add Levenshtein.

											
										
										
											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)
-												Add integer partition.

											
										
										
											2018-04-30 23:00:17 +08:00
+								  * [Integer Partition](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/integer-partition)
-												Restructure folders.

											
										
										
											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 the set
 								  * [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)
-												Update README.

											
										
										
											2018-04-26 13:08:13 +08:00
+								  * [Fisher–Yates Shuffle](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/fisher-yates) - random permutation of a finite sequence
 								  * [Longest Common Subsequence](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequnce) (LCS)
-												Add longest increasing subsequence.

											
										
										
											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)
-												Add SCS.

											
										
										
											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)
-												Add integer partition.

											
										
										
											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
-												Add maximum subarray.

											
										
										
											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
-												Update README.

											
										
										
											2018-04-17 01:49:52 +08:00
+								* **String**
-												Update README.

											
										
										
											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
-												Add Hamming.

											
										
										
											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
-												Add Rabin.

											
										
										
											2018-04-25 02:36:47 +08:00
+								  * [Knuth–Morris–Pratt 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
-												Add LCS.

											
										
										
											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)
-												Update README.

											
										
										
											2018-04-17 01:49:52 +08:00
+								* **Search**
-												Add binary search.

											
										
										
											2018-04-17 00:30:29 +08:00
+								  * [Binary Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/search/binary-search)
-												Update README.

											
										
										
											2018-04-17 01:49:52 +08:00
+								* **Sorting**
-												Add BubbleSort.

											
										
										
											2018-04-12 16:53:26 +08:00
+								  * [Bubble Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/bubble-sort)
-												Add big O sheet for sorting algorithms.

											
										
										
											2018-04-13 11:25:06 +08:00
+								  * [Selection Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/selection-sort)
-												Add insertion sort.

											
										
										
											2018-04-13 12:49:47 +08:00
+								  * [Insertion Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/insertion-sort)
-												Add heap sort.

											
										
										
											2018-04-14 15:29:36 +08:00
+								  * [Heap Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/heap-sort)
-												Add merge sort.

											
										
										
											2018-04-14 16:48:33 +08:00
+								  * [Merge Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/merge-sort)
-												Add quick sort.

											
										
										
											2018-04-15 13:42:01 +08:00
+								  * [Quicksort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/quick-sort)
 								  * [Shellsort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/shell-sort)
-												Add BFS and DFS for tree.

											
										
										
											2018-04-25 22:35:44 +08:00
+								* **Tree**
 								  * [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)
-												Update README.

											
										
										
											2018-04-17 01:49:52 +08:00
+								* **Graph**
-												Add BFS and DFS for tree.

											
										
										
											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)
-												Add Bellman-Ford.

											
										
										
											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
-												Add detect cycle.

											
										
										
											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)
-												Update README.

											
										
										
											2018-05-07 03:18:09 +08:00
+								  * [Prim’s Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/prim) - finding Minimum Spanning Tree (MST)
-												Update README.

											
										
										
											2018-05-07 03:04:36 +08:00
+								  * Kruskal’s Algorithm - finding Minimum Spanning Tree (MST)
-												Update README.

											
										
										
											2018-04-17 01:49:52 +08:00
+								  * Topological Sorting
 								  * Eulerian path, Eulerian circuit
 								  * Strongly Connected Component algorithm
 								  * Shortest Path Faster Algorithm (SPFA)
 								* **Uncategorized**
 								  * Union-Find
 								  * Maze
-												Add knapsack problem.

											
										
										
											2018-04-30 19:08:53 +08:00
+								  * Sudoku
-												Update README.

											
										
										
											2018-04-17 01:49:52 +08:00
-												Update README.

											
										
										
											2018-04-26 12:39:08 +08:00
+								### Algorithms by Paradigm
 								* **Greedy**
-												Add knapsack problem.

											
										
										
											2018-04-30 19:08:14 +08:00
+								  * [Unbound Knapsack Problem](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/knapsack-problem)
-												Add Bellman-Ford.

											
										
										
											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
-												Update README.

											
										
										
											2018-05-07 03:18:09 +08:00
+								  * [Prim’s Algorithm](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/graph/prim) - finding Minimum Spanning Tree (MST)
-												Update README.

											
										
										
											2018-04-26 12:39:08 +08:00
+								* **Divide and Conquer**
-												Update README.

											
										
										
											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)
-												Update README.

											
										
										
											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)
-												Update README.

											
										
										
											2018-04-26 12:39:08 +08:00
+								* **Dynamic Programming**
-												Update README.

											
										
										
											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
-												Update README.

											
										
										
											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)
-												Update README.

											
										
										
											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)
-												Add longest increasing subsequence.

											
										
										
											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)
-												Add SCS.

											
										
										
											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)
-												Add knapsack problem.

											
										
										
											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)
-												Add integer partition.

											
										
										
											2018-04-30 23:00:17 +08:00
+								  * [Integer Partition](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/integer-partition)
-												Add maximum subarray.

											
										
										
											2018-05-01 16:16:08 +08:00
+								  * [Maximum Subarray](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/maximum-subarray)
-												Add Bellman-Ford.

											
										
										
											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
-												Update README.

											
										
										
											2018-04-26 12:39:08 +08:00
+								* **Backtracking**
 								* **Branch & Bound**
-												Add big O sheet for sorting algorithms.

											
										
										
											2018-04-13 11:25:06 +08:00
-												Add LinkedList.

											
										
										
											2018-03-27 20:18:28 +08:00
+								## Running Tests
-												Update README.

											
										
										
											2018-03-27 19:43:15 +08:00
 								**Run all tests**
 								```
 								npm test
 								```
 								**Run tests by name**
 								```
 								npm test -- -t 'LinkedList'
 								```
-												Update READMEs.

											
										
										
											2018-04-12 13:46:35 +08:00
 								## Playground
 								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'
 								```
-												Update READMEs.

											
										
										
											2018-04-12 13:49:34 +08:00
+								## Useful links
-												Update READMEs.

											
										
										
											2018-04-12 13:46:35 +08:00
-												Add BFS and DFS for tree.

											
										
										
											2018-04-25 22:44:24 +08:00
+								[▶ Data Structures and Algorithms on YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
-												Update READMEs.

											
										
										
											2018-04-12 13:46:35 +08:00
-												Update READMEs.

											
										
										
											2018-04-12 13:49:34 +08:00
+								## Useful Information
-												Update READMEs.

											
										
										
											2018-04-12 13:46:35 +08:00
+								### Big O Notation
 								Order of growth of algorithms specified in Big O notation.
 								![Big O graphs](https://github.com/trekhleb/javascript-algorithms/blob/master/assets/big-o-graph.png)
-												Add quick sort.

											
										
										
											2018-04-15 11:57:34 +08:00
-												Update READMEs.

											
										
										
											2018-04-12 13:46:35 +08:00
+								Source: [Big O Cheat Sheet](http://bigocheatsheet.com/).
 								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                            |
 								| **O(N log N)** | 30                           | 60                            | 9000                            |
 								| **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                      |
-												Add quick sort.

											
										
										
											2018-04-15 11:56:15 +08:00
+								### Data Structure Operations Complexity
 								| Data Structure          | Access    | Search    | Insertion | Deletion  |
-												Add quick sort.

											
										
										
											2018-04-15 11:51:47 +08:00
+								| ----------------------- | :-------: | :-------: | :-------: | :-------: |
-												Add quick sort.

											
										
										
											2018-04-15 11:56:15 +08:00
+								| **Array**               | 1         | n         | n         | n         |
 								| **Stack**               | n         | n         | 1         | 1         |
 								| **Queue**               | n         | n         | 1         | 1         |
 								| **Linked List**         | n         | n         | 1         | 1         |
 								| **Hash Table**          | -         | n         | n         | n         |
 								| **Binary Search Tree**  | n         | n         | n         | 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)    |
-												Add big O sheet for sorting algorithms.

											
										
										
											2018-04-13 11:11:39 +08:00
-												Add big O sheet for sorting algorithms.

											
										
										
											2018-04-13 11:38:38 +08:00
+								### Array Sorting Algorithms Complexity
-												Add big O sheet for sorting algorithms.

											
										
										
											2018-04-13 11:11:39 +08:00
-												Add quick sort.

											
										
										
											2018-04-15 13:42:01 +08:00
+								| Name                  | Best      | Average   | Worst         | Memory    | Stable    |
 								| --------------------- | :-------: | :-------: | :-----------: | :-------: | :-------: |
 								| **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        |