javascript-algorithms/README.zh-CN.md
2018-07-24 11:56:25 +03:00

216 lines
12 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# JavaScript 算法与数据结构
[![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)
本仓库包含了多种基于 JavaScript 的算法与数据结构。
每种算法和数据结构都有自己的 README 并提供相关说明以及进一步阅读和 YouTube 视频。
_Read this in other languages:_
[_English_](https://github.com/trekhleb/javascript-algorithms/),
[繁體中文](README.zh-TW.md)
## 数据结构
数据结构是在计算机中组织和存储数据的一种特殊方式,它可以高效地访问和修改数据。更确切地说,数据结构是数据值的集合,它们之间的关系、函数或操作可以应用于数据。
* [链表](src/data-structures/linked-list)
* [双向链表](src/data-structures/doubly-linked-list)
* [队列](src/data-structures/queue)
* [](src/data-structures/stack)
* [哈希表](src/data-structures/hash-table)
* [](src/data-structures/heap)
* [优先队列](src/data-structures/priority-queue)
* [字典树](src/data-structures/trie)
* [](src/data-structures/tree)
* [二分查找](src/data-structures/tree/binary-search-tree)
* [AVL 树](src/data-structures/tree/avl-tree)
* [红黑树](src/data-structures/tree/red-black-tree)
* [](src/data-structures/graph) (有向图与无向图)
* [并查集](src/data-structures/disjoint-set)
## 算法
算法是如何解决一类问题的明确规范。 算法是一组精确定义操作序列的规则。
### 算法主题
* **数学**
* [阶乘](src/algorithms/math/factorial)
* [斐波那契数](src/algorithms/math/fibonacci)
* [素数检测](src/algorithms/math/primality-test) (排除法)
* [欧几里得算法](src/algorithms/math/euclidean-algorithm) - 计算最大公约数GCD
* [最小公倍数](src/algorithms/math/least-common-multiple) (LCM)
* [整数拆分](src/algorithms/math/integer-partition)
* **集合**
* [笛卡尔积](src/algorithms/sets/cartesian-product) - 多集合结果
* [幂集](src/algorithms/sets/power-set) - 该集合的所有子集
* [排列](src/algorithms/sets/permutations) (有/无重复)
* [组合](src/algorithms/sets/combinations) (有/无重复)
* [洗牌算法](src/algorithms/sets/fisher-yates) - 随机置换有限序列
* [最长公共子序列](src/algorithms/sets/longest-common-subsequence) (LCS)
* [最长递增子序列](src/algorithms/sets/longest-increasing-subsequence)
* [Shortest Common Supersequence](src/algorithms/sets/shortest-common-supersequence) (SCS)
* [背包问题](src/algorithms/sets/knapsack-problem) - "0/1" and "Unbound" ones
* [最大子数列问题](src/algorithms/sets/maximum-subarray) - BF算法 与 动态编程
* **字符串**
* [莱温斯坦距离](src/algorithms/string/levenshtein-distance) - 两个序列之间的最小编辑距离
* [汉明距离](src/algorithms/string/hamming-distance) - 符号不同的位置数
* [克努斯-莫里斯-普拉特算法](src/algorithms/string/knuth-morris-pratt) - 子串搜索
* [字符串快速查找](src/algorithms/string/rabin-karp) - 子串搜索
* [最长公共子串](src/algorithms/string/longest-common-substring)
* **搜索**
* [二分查找](src/algorithms/search/binary-search)
* **排序**
* [冒泡排序](src/algorithms/sorting/bubble-sort)
* [选择排序](src/algorithms/sorting/selection-sort)
* [插入排序](src/algorithms/sorting/insertion-sort)
* [堆排序](src/algorithms/sorting/heap-sort)
* [归并排序](src/algorithms/sorting/merge-sort)
* [快速排序](src/algorithms/sorting/quick-sort)
* [希尔排序](src/algorithms/sorting/shell-sort)
* **树**
* [深度优先搜索](src/algorithms/tree/depth-first-search) (DFS)
* [广度优先搜索](src/algorithms/tree/breadth-first-search) (BFS)
* **图**
* [深度优先搜索](src/algorithms/graph/depth-first-search) (DFS)
* [广度优先搜索](src/algorithms/graph/breadth-first-search) (BFS)
* [戴克斯特拉算法m](src/algorithms/graph/dijkstra) - 找到所有图顶点的最短路径
* [贝尔曼-福特算法](src/algorithms/graph/bellman-ford) - 找到所有图顶点的最短路径
* [判圈算法](src/algorithms/graph/detect-cycle) - 对于有向图和无向图基于DFS和不相交集的版本
* [普林演算法](src/algorithms/graph/prim) - 寻找加权无向图的最小生成树MST
* [克鲁斯克尔演算法](src/algorithms/graph/kruskal) - 寻找加权无向图的最小生成树MST
* [拓撲排序](src/algorithms/graph/topological-sorting) - DFS 方法
* [关节点](src/algorithms/graph/articulation-points) - Tarjan算法基于DFS
* [](src/algorithms/graph/bridges) - 基于DFS的算法
* [欧拉路径与一笔画问题](src/algorithms/graph/eulerian-path) - Fleury的算法 - 一次访问每个边缘
* [哈密顿图](src/algorithms/graph/hamiltonian-cycle) - 恰好访问每个顶点一次
* [强连通分量](src/algorithms/graph/strongly-connected-components) - Kosaraju算法
* [旅行推销员问题](src/algorithms/graph/travelling-salesman) - 尽可能以最短的路线访问每个城市并返回原始城市
* [Floyd-Warshall algorithm](src/algorithms/graph/floyd-warshall) - 一次循环可以找出所有顶点之间的最短路径
* **未分类**
* [汉诺塔](src/algorithms/uncategorized/hanoi-tower)
* [八皇后问题](src/algorithms/uncategorized/n-queens)
* [骑士巡逻](src/algorithms/uncategorized/knight-tour)
### 算法范式
算法范式是基于类的设计的通用方法或方法的算法。 这是一个比算法概念更高的抽象,就像一个
算法是比计算机程序更高的抽象。
* **BF算法** - 查找所有可能性并选择最佳解决方案
* [最大子数列](src/algorithms/sets/maximum-subarray)
* [旅行推销员问题](src/algorithms/graph/travelling-salesman) - 尽可能以最短的路线访问每个城市并返回原始城市
* **贪心法** - 在当前选择最佳选项,不考虑以后情况
* [背包问题](src/algorithms/sets/knapsack-problem)
* [戴克斯特拉算法](src/algorithms/graph/dijkstra) - 找到所有图顶点的最短路径
* [普里姆算法](src/algorithms/graph/prim) - 寻找加权无向图的最小生成树MST
* [克鲁斯卡尔算法](src/algorithms/graph/kruskal) - 寻找加权无向图的最小生成树MST
* **分治法** - 将问题分成较小的部分,然后解决这些部分
* [二分查找](src/algorithms/search/binary-search)
* [汉诺塔](src/algorithms/uncategorized/hanoi-tower)
* [欧几里得算法](src/algorithms/math/euclidean-algorithm) - 计算最大公约数GCD
* [排列](src/algorithms/sets/permutations) (有/无重复)
* [组合](src/algorithms/sets/combinations) (有/无重复)
* [归并排序](src/algorithms/sorting/merge-sort)
* [Quicksort](src/algorithms/sorting/quick-sort)
* [树深度优先搜索](src/algorithms/tree/depth-first-search) (DFS)
* [图深度优先搜索](src/algorithms/graph/depth-first-search) (DFS)
* **动态编程** - 使用以前找到的子解决方案构建解决方案
* [斐波那契数](src/algorithms/math/fibonacci)
* [莱温斯坦距离](src/algorithms/string/levenshtein-distance) - 两个序列之间的最小编辑距离
* [最长公共子序列](src/algorithms/sets/longest-common-subsequence) (LCS)
* [最长公共子串](src/algorithms/string/longest-common-substring)
* [最长递增子序列](src/algorithms/sets/longest-increasing-subsequence)
* [最短公共子序列](src/algorithms/sets/shortest-common-supersequence)
* [0-1背包问题](src/algorithms/sets/knapsack-problem)
* [整数拆分](src/algorithms/math/integer-partition)
* [最大子数列](src/algorithms/sets/maximum-subarray)
* [贝尔曼-福特算法](src/algorithms/graph/bellman-ford) - 找到所有图顶点的最短路径
* **回溯法** - 类似于 BF算法 试图产生所有可能的解决方案,但每次生成解决方案测试如果它满足所有条件,那么只有继续生成后续解决方案。 否则回溯并继续寻找不同路径的解决方案。
* [哈密顿图](src/algorithms/graph/hamiltonian-cycle) - 恰好访问每个顶点一次
* [八皇后问题](src/algorithms/uncategorized/n-queens)
* [骑士巡逻](src/algorithms/uncategorized/knight-tour)
* **B & B**
## 如何使用本仓库
**安装依赖**
```
npm install
```
**执行测试**
```
npm test
```
**按照名称执行测试**
```
npm test -- 'LinkedList'
```
**Playground**
你可以在`./src/playground/playground.js`文件中操作数据结构与算法,并在`./src/playground/__test__/playground.test.js`中编写测试。
然后,只需运行以下命令来测试你的 Playground 是否按无误:
```
npm test -- 'playground'
```
## 有用的信息
### 引用
[▶ YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
### 大O符号
大O符号中指定的算法的增长顺序。
![Big O graphs](./assets/big-o-graph.png)
源: [Big O Cheat Sheet](http://bigocheatsheet.com/).
以下是一些最常用的 大O标记法 列表以及它们与不同大小输入数据的性能比较。
| 大O标记法 | 计算10个元素 | 计算100个元素 | 计算1000个元素 |
| -------------- | ---------------------------- | ----------------------------- | ------------------------------- |
| **O(1)** | 1 | 1 | 1 |
| **O(log N)** | 3 | 6 | 9 |
| **O(N)** | 10 | 100 | 1000 |
| **O(N log N)** | 30 | 600 | 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 |
### 数据结构操作的复杂性
| 数据结构 | 连接 | 查找 | 插入 | 删除 |
| ----------------------- | :-------: | :-------: | :-------: | :-------: |
| **数组** | 1 | n | n | n |
| **栈** | n | n | 1 | 1 |
| **队列** | n | n | 1 | 1 |
| **链表** | n | n | 1 | 1 |
| **哈希表** | - | n | n | n |
| **二分查找树** | n | n | n | n |
| **B树** | log(n) | log(n) | log(n) | log(n) |
| **红黑树** | log(n) | log(n) | log(n) | log(n) |
| **AVL树** | log(n) | log(n) | log(n) | log(n) |
### 数组排序算法的复杂性
| 名称 | 最优 | 平均 | 最坏 | 内存 | 稳定 |
| --------------------- | :-------: | :-------: | :-----------: | :-------: | :-------: |
| **冒泡排序** | n | n^2 | n^2 | 1 | Yes |
| **插入排序** | n | n^2 | n^2 | 1 | Yes |
| **选择排序** | n^2 | n^2 | n^2 | 1 | No |
| **堆排序** | n log(n) | n log(n) | n log(n) | 1 | No |
| **归并排序** | n log(n) | n log(n) | n log(n) | n | Yes |
| **快速排序** | n log(n) | n log(n) | n^2 | log(n) | No |
| **希尔排序** | n log(n) | 取决于差距序列 | n (log(n))^2 | 1 | No |