| 图与树搜索算法 |
| --- |
| * α–β
* A\*
* B\*（英语：）
* 回溯
* 集束（英语：）
* 贝尔曼-福特
* 最佳优先（英语：）
* 双向
* 布魯瓦卡（英语：）
* 分支限界
* BFS
* 大英博物馆
* D\*（英语：）
* DFS
* 深度限制（英语：）
* 迪杰斯特拉
* 愛德蒙斯（英语：）
* 弗洛伊德
* 边缘搜索
* 爬山
* IDA\*（英语：）
* 迭代加深
* 约翰逊（英语：）
* 跳点（英语：）
* 克鲁斯克尔
* 词典BFS（英语：）
* LPA\*（英语：）
* 普里姆
* SMA\*（英语：）
* 最短路径快速
 |
| 
分类 |
| * 图算法
* 搜索算法
* 算法列表（英语：）
 |
| 
相关主题 |
| * 动态规划
* 图的遍历
* 树的遍历
 |
| * 
* 论
* 编
 |

**戴克斯特拉算法**（英語：），又稱**迪杰斯特拉算法**、**Dijkstra算法**，是由荷兰计算机科学家艾茲赫尔·戴克斯特拉在1956年发现的算法，并于3年后在期刊上发表。戴克斯特拉算法使用类似廣度优先搜索的方法解决赋权图的单源最短路径问题。

该算法存在很多变体：戴克斯特拉的原始版本仅适用于找到两个顶点之间的最短路径，后来更常见的变体固定了一个顶点作为源结点然后找到该顶点到图中所有其它结点的最短路径，产生一个最短路径树。

该算法解决了圖 {\displaystyle G=\langle V,E\rangle }上带权的单源最短路径问题。具体来说，戴克斯特拉算法设置了一顶点集合S，在集合S中所有的顶点与源点s之间的最终最短路径权值均已确定。算法反复选择最短路径估计最小的点{\displaystyle u\in {V-S}}并将u加入S中。该算法常用于路由算法或者作为其他图算法的一个子模块。举例来说，如果图中的顶点表示城市，而边上的权重表示城市间开车行经的距离，该演算法可以用来找到两个城市之间的最短路径。

应当注意，绝大多数的戴克斯特拉算法不能有效处理带有负权边的图。

戴克斯特拉算法在计算机科学的人工智能等领域也被称为均一开销搜索，并被认为是最良优先搜索（英语：）的一个特例。

描述
--

上圖為**戴克斯特拉演算法**應用示意圖。  
起點以左下角的紅點，目標是右上角的綠點，中間灰色的倒L型為障礙物。藍色空圈表示"暫定"，用以搜索下一步；已經填充顏色的表示探訪過，圖中顏色以紅到綠，越綠表示離起點越遠。所有節點都被均勻的探索。
戴克斯特拉算法通過保留目前為止所找到的每個頂點v \in V從s到v的最短路徑來工作。初始時，原點s的路径权重被賦為 0 （即原点的实际最短路径=0）。同時把所有其他頂點的路徑長度設為無窮大，即表示我們不知道任何通向這些頂點的路徑。當算法結束時，{\displaystyle d[v]} 中儲存的便是從s到v的最短路徑，或者如果路徑不存在的話是無窮大。

松弛操作是戴克斯特拉算法的基礎操作：如果存在一條從u到v的邊，那麼從s到v的一条新路径是將邊{\displaystyle w(u,v)\in E}添加到從s到u的路徑尾部來拓展一條從s到v的路径。這條路徑的長度是{\displaystyle d[u]+w(u,v)}。如果這個值比目前已知的{\displaystyle d[v]}的值要小，那么可以用这个值來替代當前{\displaystyle d[v]}中的值。松弛邊的操作一直執行到所有的{\displaystyle d[v]}都代表從s到v的最短路徑的长度值。

算法維護兩個頂點集合S和Q。集合S保留所有已知实际最短路径值的頂點，而集合Q則保留其他所有頂點。集合S初始狀態為空，而後每一步都有一個頂點從Q移動到S。這個被選擇的頂點是Q中擁有最小的{\displaystyle d[u]}值的頂點。當一個頂點u從Q中轉移到了S中，算法對u的每条外接邊{\displaystyle w(u,v)}進行松弛。

《算法导论》中给出了以下伪代码：该伪代码计算并保留图G中原点s到每一顶点v的最短距离{\displaystyle d[v]}。其中，函数{\displaystyle Extract-Min(Q)}将頂點集合Q中有最小{\displaystyle d[u]}值的頂點u从Q中删除并返回u。

```

 1  **function** Dijkstra(G, w, s)
 2   INITIALIZE-SINGLE-SOURCE(G, s)                //实际上的操作是将每个除原点外的顶点的{\displaystyle d[v]}置为无穷大，{\displaystyle d[s]=0}
 3   {\displaystyle S\leftarrow \emptyset }
 4   {\displaystyle Q\leftarrow s}                                //Q是顶点V的一个优先队列，以顶点的最短路径估计排序
 5   while({\displaystyle Q\not =\emptyset })
 6       do {\displaystyle u\leftarrow EXTRACT-MIN(Q)}          //选取u为Q中最短路径估计最小的顶点
 7       {\displaystyle S\leftarrow S\cup u}
 8       for each vertex v {\displaystyle \in Adj[u]}
 9            do RELAX(u, v, w)            //松弛成功的结点会被加入到队列中
```

如果我們只對在s和t之間尋找一條最短路徑的話，我們可以在第5或第6行添加條件如果滿足{\displaystyle u=t}的話終止程序。

在肯尼·罗森所著的《离散数学及其应用》中给出了如下的另一份伪代码：

```

 1 **procedure** Dijkstra(G：边全为正权的图）
 2   {G带有顶点{\displaystyle a=v\_{0},v\_{1},v\_{2}...}和若干边{\displaystyle w(v\_{i},v\_{j})}}
 3    for {\displaystyle i:=1} to n
 4       {\displaystyle D(v\_{i}):=\infty }
 5    {\displaystyle D(a):=0}
 6    {\displaystyle S:=\emptyset }
 7    while {\displaystyle z\notin S}
 8    begin
 9          {\displaystyle u:=}不属于S的{\displaystyle D(u)}最小的一个顶点
 10        {\displaystyle S:=S\cup \{u\}}
 11        for 所有不属于S的顶点v
 12            if {\displaystyle D(u)+w(u,v)<D(v)} then {\displaystyle D(v):=D(u)+w(u,v)}
 13    end{{\displaystyle D(z)=}从a到z的最短路长度}
```

時間複雜度
-----

我們可以用大O符號將该算法的運行時間表示為邊數|E|和頂點數|V|的函數。

对于任何基于顶点集Q的实现，算法的运行时间是O(|E|\cdot dk\_{Q}+|V|\cdot em\_{Q})，其中dk\_{Q}和em\_{Q}分别表示完成键的降序排列时间和从Q中提取最小键值的时间。

对于没有任何优化的戴克斯特拉算法，实际上等价于每次遍历了整个图的所有结点来找到Q中满足条件的元素（即寻找最小的頂點是O(|V|)的），此外实际上还需要遍历所有的边一遍，因此算法的复杂度是{\displaystyle O(|V|^{2}+|E|)}。

對於邊數少於{\displaystyle |V|^{2}}的稀疏圖來說，可以用鄰接表來更有效的實現该算法。

可以使用一個二叉堆或者斐波納契堆用作優先隊列來尋找最小的頂點（{\displaystyle Extract-Min}）以优化算法。當用到二叉堆的時候，算法所需的時間為{\displaystyle O((|E|+|V|)\log |V|)}，斐波納契堆能提高一些性能，讓算法運行時間達到{\displaystyle O(|E|+|V|\log |V|)}。然而，使用斐波納契堆进行编程，有时会由于算法常数过大而导致速度没有显著提高。

下面是一些戴克斯特拉算法经典实现的复杂度比较：

| 算法 | 最坏时间复杂度  | 发现者（按照论文发表时间从前向后排序） |
| --- | --- | --- |
| 使用鄰接表的戴克斯特拉算法 | O(|V|^{2}) | 莱索雷克及格雷等人，艾兹赫尔·戴克斯特拉，明蒂，怀廷及希利尔 |
| 使用二叉堆优化的戴克斯特拉算法 | {\displaystyle O((|E|+|V|)\log |V|)} | 唐纳德·约翰逊 |
| 使用斐波那契堆优化的戴克斯特拉算法 | {\displaystyle O(|E|+|V|\log |V|)} | 迈克尔·弗雷德曼及羅伯特·塔揚 |
|  | {\displaystyle O(|E|\log \log |L|)} | 唐纳德·约翰逊，洛夫·卡尔松及帕特里西奥·波夫莱特 |

正确性证明
-----

艾兹赫尔·戴克斯特拉，戴克斯特拉算法的发现者
戴克斯特拉本人在他的论文中给出了一份简单的证明。

《算法导论》使用循环不变式（数学归纳法）给出了如下的一份证明：

已知一带权图{\displaystyle G=<V,E>}，其加权函数w的值非负，源点为s。对该图运行戴克斯特拉算法，对所有{\displaystyle u\in V}有{\displaystyle d[u]=\delta (s,u)}。其中{\displaystyle d[u]}表示u点的最短路径估计，{\displaystyle \delta (s,u)}表示s到u点的最短路径。
证明：证明如下的循环不变式成立即可：在每次执行EXTRACT-MIN时，对每个顶点{\displaystyle u\in S}，有{\displaystyle d[u]=\delta (s,u)}成立即可。由于上界性质，在u加入了S之后，一旦有{\displaystyle d[u]=\delta (s,u)}，则在后面的每次循环中都不会改变这个性质。
初始化：第一次循环前，{\displaystyle S=\emptyset }，因此循环不变式显然成立。
保持：实际上要证明每一轮循环中加入到S中的结点满足{\displaystyle d[u]=\delta (s,u)}。利用反证法，假设u是第一个不满足此条件的结点，考虑循环开始前的状况，首先u一定不等于s，这是显然的。其次s一定有到u的路径，否则路径为无穷大。那么假设在u进入时，有最短路径{\displaystyle p=s->u}，假设该路径上存在两个点x，y。{\displaystyle y\in V-S}、x\in S，且x是y的前驱，路径p可以分解为{\displaystyle s-p\_{1}->x->y-p\_{2}->u}（此处{\displaystyle -p\_{1}->}表示经过p\_{1}这条路径，后同），其中路径p\_{1}和路径p\_{2}可以为空。由于u是第一个不满足{\displaystyle d[u]=\delta (s,u)}的，又因为x是满足该条件的，而且(x,y)一定已经被松弛过了，所以y是满足该条件的。
现在只需要推出矛盾，即可证明u不存在：y在u之前出现，而且图中所有权值非负，因此有{\displaystyle \delta (s,y)\leq \delta (s,u)}，所以：  
{\displaystyle d[y]\leq \delta (s,y)\leq \delta (s,u)\leq d[u]}，但是由于u和y同时在{\displaystyle V-S}中，因此{\displaystyle d[u]\leq d[y]}，因此必有{\displaystyle d[y]=\delta (s,y)=\delta (s,u)=d[u]}，也就证明了u点不可能不满足该条件，上述假设为假，原命题得证。
终止：终止时，{\displaystyle Q=\emptyset }，由于{\displaystyle Q=V-S}，因此{\displaystyle V=S}，因此对所有{\displaystyle u\in V}有{\displaystyle d[u]=\delta (s,u)}。

起源与历史
-----

> 从鹿特丹到格罗宁根的最短路径是什么？实际上，这就是对于任意两座城市之间的最短路问题。解决这个问题实际上大概只花了我20分钟：一天早上，我和我的未婚妻在阿姆斯特丹购物，累了，我们便坐在咖啡馆的露台上喝咖啡，然后我就试了一下能否用一个算法解决最短路问题。正如我所说，这是一个20分钟的发现。不过实际上，我在3年后的1959年才把这个算法发表在论文上。即使现在来看这篇论文的可读性也非常高，这个算法之所以如此优雅，其中一个原因就是我没用笔纸就设计了它。后来我才知道，没用笔纸设计的优点之一是你不得不避免所有可避免的复杂问题。令我惊讶的是，这个算法最终成为我成名的基石之一。
> 
> ——艾兹赫尔·戴克斯特拉在2001年的采访中提到戴克斯特拉算法的发现历程

戴克斯特拉1956年在荷兰数学和计算机科学研究学会担任程序员时为了展示新型计算机ARMAC的功能曾思考过最短路径问题的解法。他的目标是让不去实际计算的人也能理解这个问题和解决的方法，于是他在发现了这个算法之后在ARMAC上做了简单实验。1959年，他正式将此算法发表在期刊上，该算法也成为了戴克斯特拉成名的基石之一。

相关应用
----

一个多区域OSPF网络，在OSPF中使用本算法计算最短路径
链路状态路由协议（英语：）中需要计算最短路时常常要用到该算法，该算法在開放最短路徑優先和中间系统到中间系统协议中的相关应用是其在網絡路由中的典型實現。

戴克斯特拉算法及其改进算法应用广泛，尤其是在寻路、交通、规划中。

如果有已知信息可用來估計某一點到目標點的距離，則可改用A\*搜尋算法，以減小最短路徑的搜索範圍，戴克斯特拉算法本身也可以看作是A\*搜索算法的一个特例。

戴克斯特拉算法本身采用了与Prim算法类似的贪心策略。快速行进算法与戴克斯特拉算法同样有相似之处。

参考源程序
-----

以下是该算法使用堆优化的一个C++实现参考：

```
#include<bits/stdc++.h> 
using namespace std; 
# define INF 0x3f3f3f3f 
 
// iPair ==> Integer Pair（整数对）
typedef pair<int, int> iPair; 
 
// 加边
void addEdge(vector <pair<int, int> > adj[], int u, 
 int v, int wt) 
{ 
 adj[u].push\_back(make\_pair(v, wt)); 
 adj[v].push\_back(make\_pair(u, wt)); 
} 
 
 
// 计算最短路
void shortestPath(vector<pair<int,int> > adj[], int V, int src) 
{ 
   // 关于stl中的优先队列如何实现，参考下方网址：
   // http://geeksquiz.com/implement-min-heap-using-stl/ 
 priority\_queue< iPair, vector <iPair> , greater<iPair> > pq; 
 
   // 距离置为正无穷大
   vector<int> dist(V, INF); 
 vector<bool> visited(V, false);

   // 插入源点，距离为0
   pq.push(make\_pair(0, src)); 
 dist[src] = 0; 
 
   /\* 循环直到优先队列为空 \*/
 while (!pq.empty()) 
 { 
       // 每次从优先队列中取出顶点事实上是这一轮最短路径权值确定的点
       int u = pq.top().second; 
 pq.pop(); 
 if (visited[u]) {
 continue;
 }
 visited[u] = true;
       // 遍历所有边
       for (auto x : adj[u]) 
 { 
           // 得到顶点边号以及边权
 int v = x.first; 
 int weight = x.second; 
 
           //可以松弛
           if (dist[v] > dist[u] + weight) 
 { 
 // 松弛 
 dist[v] = dist[u] + weight; 
 pq.push(make\_pair(dist[v], v)); 
 } 
 } 
 } 
 
   // 打印最短路
   printf("Vertex Distance from Source\n"); 
 for (int i = 0; i < V; ++i) 
 printf("%d \t\t %d\n", i, dist[i]); 
} 
int main() 
{ 
 int V = 9; 
 vector<iPair > adj[V]; 
 addEdge(adj, 0, 1, 4); 
 addEdge(adj, 0, 7, 8); 
 addEdge(adj, 1, 2, 8); 
 addEdge(adj, 1, 7, 11); 
 addEdge(adj, 2, 3, 7); 
 addEdge(adj, 2, 8, 2); 
 addEdge(adj, 2, 5, 4); 
 addEdge(adj, 3, 4, 9); 
 addEdge(adj, 3, 5, 14); 
 addEdge(adj, 4, 5, 10); 
 addEdge(adj, 5, 6, 2); 
 addEdge(adj, 6, 7, 1); 
 addEdge(adj, 6, 8, 6); 
 addEdge(adj, 7, 8, 7); 
 
 shortestPath(adj, V, 0); 
 
 return 0; 
}

```

以下是该算法Python的一个实现:

```
import sys
max = sys.maxsize

vertices\_number = 6
adjacency\_matrix = [
    [0, 1, 10, -1, -1, 2],
    [10, 0, 1, -1, -1, -1],
    [1, 10, 0, -1, -1, -1],
    [-1, -1, 2, 0, 1, 10],
    [-1, -1, -1, 10, 0, 1],
    [-1, -1, -1, 1, 10, 0]]
start = []
dest = ["2", "5"]
key = []

def init\_keys(s: int):
    global key
    key = [ max ] \* vertices\_number
    key[s] = 0

def dijkstra(from\_vertex, dest\_vertex):
    fid = int(from\_vertex) - 1
    tid = int(dest\_vertex) - 1
    init\_keys(fid)
    rel = [fid]
    min\_vertex = fid
    hop\_path = {}

    while len(rel) <= vertices\_number and min\_vertex != tid:
        for i in range(vertices\_number):
            if i != min\_vertex and i not in rel and \
                adjacency\_matrix[min\_vertex][i] > 0 \
                and key[i] > key[min\_vertex] + adjacency\_matrix[min\_vertex][i]:
                key[i] = key[min\_vertex] + adjacency\_matrix[min\_vertex][i]
                hop\_path.update({i + 1: {"from": min\_vertex + 1, "cost": adjacency\_matrix[min\_vertex][i]}})

        if min\_vertex not in rel:
            rel.append(min\_vertex)

        min\_vertex = tid
        for i in range(vertices\_number):
            if i not in rel and key[i] < key[min\_vertex]:
                min\_vertex = i

    if len(hop\_path) == 0 or int(dest\_vertex) not in hop\_path:
        return -1, -1
    else:
        next\_hop = int(dest\_vertex)
        path\_str = dest\_vertex
        while hop\_path[next\_hop]["from"] != int(from\_vertex):
            cost = hop\_path[next\_hop]["cost"]
            next\_hop = hop\_path[next\_hop]["from"]
            path\_str =  "{} -({})-> {}".format(str(next\_hop), cost ,path\_str)
        path\_str =  "{} -({})-> {}".format(str(hop\_path[next\_hop]["from"]), hop\_path[next\_hop]["cost"], path\_str)

        return key[tid], path\_str

def find\_shortest\_router():
    for s in start:
        print("Forwarding Table for {}".format(s))
        print("{:>10} {:>10} {}".format("To", "Cost", "Path"))
        for d in dest:
            c, n = dijkstra(s, d)
            print("{:>10} {:>10} {}".format(d, c, n))

def main():
    for i in range(1, vertices\_number + 1):
        if str(i) not in dest:
            start.append(str(i))
    find\_shortest\_router()

if \_\_name\_\_ == '\_\_main\_\_':
    main()

```

参见
--

* 信息技术主题
* icon计算机程序设计主题

* 图论
* A\*搜尋演算法
* 贝尔曼-福特算法
* 宽度优先搜索
* Flood fill
* Floyd-Warshall算法
* 最长路径问题

參考
--

### 参考文献

1. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30  Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford..  Second. MIT Press and McGraw–Hill. 2001: 595–601. ISBN 0-262-03293-7.
2. 1 2 3 4 5 6 7 8 9  Rosen, Kenneth H.. McGraw-Hill College. 2002. ISBN 0-07-293033-0.
3. ↑  有争议，见：Moshe Sniedovich.. Control and Cybernetics. 2006, **35**: 599–620  [2020-03-04]. （原始内容存档于2020-03-04）. 等
4. 1 2 3 4  Fredman, Michael Lawrence; Tarjan, Robert E.. 25th Annual Symposium on Foundations of Computer Science. IEEE: 338–346. 1984. doi:10.1109/SFCS.1984.715934.
5. ↑  Andrew V. Goldberg; Robert E. Tarjan.. NEC Research Institute Report. 1996年  [2019-12-12]. （原始内容存档于2021-11-22）.  引文使用过时参数`coauthors` (帮助)
6. ↑  乐阳、龚健雅.. 《科学技术创新》. 2020, (17): 75–77  [2020-06-30]. （原始内容存档于2021-02-13）.
7. ↑  Richards, Hamilton.. A.M. Turing Award. Association for Computing Machinery.  [2017-10-16]. （原始内容存档于2017-10-21）. At the Mathematical Centre a major project was building the ARMAC computer. For its official inauguration in 1956, Dijkstra devised a program to solve a problem interesting to a nontechnical audience: Given a network of roads connecting cities, what is the shortest route between two designated cities?
8. 1 2 3 4 5  Frana, Phil.. Communications of the ACM. August 2010, **53** (8): 41–47. doi:10.1145/1787234.1787249.
9. 1 2 3 4 5 6 7 8 9 10 11  Dijkstra, E. W.  (PDF). Numerische Mathematik. 1959, **1**: 269–271  [2020-01-27]. doi:10.1007/BF01386390. （原始内容存档 (PDF)于2020-01-23）.
10. 1 2  Felner, Ariel.. Proc. 4th Int'l Symp. on Combinatorial Search. 2011  [2020-02-18]. （原始内容存档于2020-02-18）.
11. ↑  Mehlhorn, Kurt; Sanders, Peter.  (PDF).. Springer. 2008  [2020-02-14]. ISBN 978-3-540-77977-3. doi:10.1007/978-3-540-77978-0. （原始内容存档 (PDF)于2021-02-24）.
12. 1 2  H. Ishikawa, S. Shimizu, Y. Arakawa, N. Yamanaka, K. Shiba.. IEEE. 13 August 2007  [2020-03-21]. doi:10.1109/ICC.2007.332. （原始内容存档于2020-12-18）.
13. ↑  Yefim, Dinitz; Rotem, Itzhak.. Journal of Discrete Algorithms. 2017, **42**: 35–44. doi:10.1016/j.jda.2017.01.001.
14. 1 2 3  Johnson, Donald B.. Journal of the ACM. 1977, **24** (1): 1–13. doi:10.1145/321992.321993.
15. 1 2 3  Fredman, Michael Lawrence; Tarjan, Robert E.. Journal of the Association for Computing Machinery. 1987, **34** (3): 596–615  [2018-04-03]. doi:10.1145/28869.28874. （原始内容存档于2006-04-28）.
16. ↑  Skiena, Steven.  (PDF) 2. Springer. 2008-07-26: 212  [2015-04-11]. ISBN 978-0073523408. doi:10.1007/978-1-84800-070-4. （原始内容 (PDF)存档于2015-06-09） （英语）.
17. ↑  Leyzorek, M.; Gray, R. S.; Johnson, A. A.; Ladew, W. C.; Meaker, Jr. S. R.; Petry, R. M.; Seitz, R. N.. Cleveland, Ohio: Case Institute of Technology. 1957.
18. ↑  见Pollack, Maurice; Wiebenson, Walter.. Oper. Res. March–April 1960, **8** (2): 224–230. doi:10.1287/opre.8.2.224.  Attributes Dijkstra's algorithm to Minty ("private communication") on p.225.
19. ↑  Whiting, P. D.; Hillier, J. A.. Operational Research Quarterly. March–June 1960, **11** (1/2): 37–40. doi:10.1057/jors.1960.32.
20. ↑  Johnson, Donald B.. Mathematical Systems Theory. December 1981, **15** (1): 295–309. MR 0683047. doi:10.1007/BF01786986.
21. ↑  Karlsson, Rolf G.; Poblete, Patricio V.. Discrete Applied Mathematics. 1983, **6** (1): 91–93. MR 0700028. doi:10.1016/0166-218X(83)90104-X.
22. ↑ . Unsung Heroes in Dutch Computing History. 2007. （原始内容存档于2013-11-13）.
23. ↑  Sven Peyer; Dieter Rautenbach,Jens Vygen.. Journal of Discrete Algorithms. 2007, **7** (4): 377–390. doi:10.1016/j.jda.2007.08.003.  引文使用过时参数`coauthors` (帮助)
24. ↑  Ismail Rakip Karas，Sait Demir.  (PDF). Energy Education Science and Technology Part A: Energy Science and Research. 2011, **28**: 445–452  [2020-03-04]. （原始内容存档 (PDF)于2020-03-04）.
25. ↑  Dean Djokic,David R. Maidment.. Journal of Water Resources Planning and Management. 1993, **119** (2). doi:10.1061/(ASCE)0733-9496(1993)119:2(229).
26. ↑  江琦浩.. 中国商贸. 2012, (03X)  [2020-12-24]. （原始内容存档于2021-02-13）.
27. ↑  De Smith, Michael John; Goodchild, Michael F.; Longley, Paul, Troubadour Publishing Ltd: 344, 2007  [2020-03-04], ISBN 9781905886609, （原始内容存档于2017-02-27） .
28. ↑  Hetland, Magnus Lie, Apress: 214, 2010  [2020-03-04], ISBN 9781430232377, （原始内容存档于2017-02-28） .
29. ↑  Tarjan, Robert Endre, CBMS\_NSF Regional Conference Series in Applied Mathematics **44**, Society for Industrial and Applied Mathematics: 75, 1983, The third classical minimum spanning tree algorithm was discovered by Jarník and rediscovered by Prim and Dikstra; it is commonly known as Prim's algorithm.
30. ↑  Prim, R.C.  (PDF). Bell System Technical Journal. 1957, **36** (6): 1389–1401  [18 July 2017]. Bibcode:1957BSTJ...36.1389P. doi:10.1002/j.1538-7305.1957.tb01515.x. （原始内容 (PDF)存档于18 July 2017）.
31. ↑  V. Jarník: *O jistém problému minimálním* [About a certain minimal problem], Práce Moravské Přírodovědecké Společnosti, 6, 1930, pp. 57–63. (in Czech)
32. ↑  Danielsson, Per-Erik; Lin, Qingfen.. Image Analysis. 24 June 2003: 1154–1161  [2020-03-25]. （原始内容存档于2021-02-13）.  引文使用过时参数`coauthors` (帮助)
33. ↑  geeksforgeeks.. geeksforgeeks.  [2020-05-11]. （原始内容存档于2021-02-13）.

### 扩展阅读

* Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford..  second. MIT Press、S&P Global. 2001: 595–601. ISBN 0-262-03293-7.
* Dial, Robert B.. CACM. 1969, **12** (11): 632–633. doi:10.1145/363269.363610.
* Zhan, F. Benjamin; Noon, Charles E.. Transportation Science. February 1998, **32** (1): 65–73. doi:10.1287/trsc.32.1.65.
* Knuth, D.E.. Information Processing Letters. 1977, **6** (1): 1–5. doi:10.1016/0020-0190(77)90002-3.
* Ahuja, Ravindra K.; Mehlhorn, Kurt; Orlin, James B.; Tarjan, Robert E.. Journal of Association for Computing Machinery (ACM). April 1990, **37** (2): 213–223. doi:10.1145/77600.77615.
* Raman, Rajeev.. SIGACT News. 1997, **28** (2): 81–87. doi:10.1145/261342.261352.
* Thorup, Mikkel.. SIAM Journal on Computing. 2000, **30** (1): 86–109. doi:10.1137/S0097539795288246.
* Thorup, Mikkel.. journal of the ACM. 1999, **46** (3): 362–394  [2017-11-01]. doi:10.1145/316542.316548. （原始内容存档于2017-09-21）.
* ZHANG Lin-guang,FANG Jin-yun,SHEN Pai-wei.. Journal of Image and Graphics. 2007-05.

外部連結
----

|  |  |
| --- | --- |
|  | 维基共享资源中相关的多媒体资源：**戴克斯特拉算法** |

* 迪科斯彻算法分解演示视频（优酷） （页面存档备份，存于）
* Animation of Dijkstra's algorithm （页面存档备份，存于）
* The Boost Graph Library (BGL) （页面存档备份，存于）
* Interactive Implementation of Dijkstra's Algorithm （页面存档备份，存于）
* Shortest Path Problem: Dijkstra's Algorithm
* Dijkstra算法使用TDD的一个实现 （页面存档备份，存于）
* Graphical explanation of Dijkstra's algorithm step-by-step on an example （页面存档备份，存于）

|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
算法 |
| --- |
|  |
| 排序 | 

|  |  |
| --- | --- |
| 比较排序 | 
* 冒泡排序
* 选择排序
* 插入排序
* 希尔排序
* 快速排序
* 归并排序
* 堆排序
* 鸡尾酒排序
* 梳排序
* 侏儒排序
* 图书馆排序
* 内省排序
* 奇偶排序

 |
|  |
| 线性时间排序 | 
* 鸽巢排序
* 基数排序
* 計數排序
* 桶排序

 |
|  |
| 并行排序 | 
* 排序网络（英语：）
* Batcher归并网络

 |
|  |
| 不实用的 | 
* Bogo排序
* 臭皮匠排序

 |
|  |
| 图 | 
* 拓撲排序

 |

 |
|  |
| 搜索 | 

|  |  |
| --- | --- |
| 列表 | 
* 线性搜索
* 二分搜索
* 插值搜尋

 |
|  |
| 树・图 | 
* 广度优先搜索
	+ 最良優先搜索（英语：）
	+ 均一开销搜索
	+ A\*
* 深度优先搜索
	+ 迭代深化深度优先搜索
	+ 深度限制搜索（日语：）
	+ 双向搜索
* 分枝限定法（英语：）

 |
|  |
| 字符串 | 
* KMP算法
* 博耶-穆尔字符串搜索算法
* AC自动机算法
* 拉宾-卡普算法
* bitap算法

 |

 |
|  |
| 最短路问题 | 
* 戴克斯特拉算法
* 贝尔曼-福特算法
* A\*搜尋演算法
* Floyd-Warshall算法

 |
|  |
| 最小生成树 | 
* 普林姆算法
* 克鲁斯克尔演算法

 |
|  |
| 最大流最小割 | 
* 福特-富尔克森算法
* 埃德蒙兹-卡普算法
* 迪尼茨算法

 |
|  |
| 线性规划 | 
* 单纯形法
* 卡马卡尔算法（英语：）

 |
|  |
| 順序統計量 | 
* 选择算法
* 中位数的中位数（英语：）

 |
|  |
| 種類 | 
* 精确算法
* 近似算法
* 随机化算法

 |
|  |
| 其他 | 
* 分治法
* 动态规划
* 贪心算法

 |
|  |
| **Category:算法** |

 |