基于《算法導論(第三版)》,殷劍平等譯，機械工業出版社，2013年1月第一版。
代碼塊用Cpp代碼塊；空格兩次代表層次結構；未使用斜體標注變量或性質。
Pxx(yy) 表示 PDF 文件xx頁，原書頁碼yy頁；有關系：xx = yy + 15。故之后簡化，僅標注PDF頁數。

排序算法

（排序算法表示從小往大排序。）

插入排序(Insertion Sort)

排序算法主要涉及本書的第二部分。
P25(10)

INSERTION_SORT(A)for j = 2 to A.lengthkey = A[j]i = j - 1while i > 0 and A[i] > keyA[i+1] = A[i]i = i - 1A[i+1] = key

堆排序(Heap Sort)

P99(84)

PARENT(i)return floor(i/2)LEFT(i)return 2iRIGHT(i)return 2i+1MAX_HEAPIFY(A,i)l = LEFT(i)r = RIGHT(i)if l <= A.heap-size and A[l] > A[i]largest = lelse largest = iif r <= A.heap-size and A[r] > A[largest]largest = rif largest != iswap(A[i], A[largest])MAX_HEAPIFY(A, largest)BUILD_MAX_HEAP(A)A.heap-size = A.lengthfor i = floor(A.length/2) downto 1MAX_HEAPIFY(A,i)HEAPSORT(A)BUILD_MAX_HEAP(A)for i = A.length downto 2swap(A[1], A[i])A.heap-size = A.heap-size - 1MAX-HEAPIFY(A,1)

快速排序(Quick Sort)

P110

QUICKSORT(A, p, r)if p < rq = PARTITION(A, p, r)QUICKSORT(A, p, q-1)QUICKSORT(A, q+1, r)PARTITION(A, p, r)x = A[r]i = p - 1for j = p to r-1if A[j] <= xi = i + 1swap(A[i], A[j])swap(A[i+1], A[r])return i+1RANDOMIZED_PARTITION(A, p, r)i = RANDOM(p, r)swap(A[r], A[i])return PARTITION(A, p, r)RANDOMIZED_QUICKSORT(A, p, r)if p < rq = RANDOMIZED_PARTITION(A, p, r)RANDOMIZED_QUICKSORT(A, p, q-1)RANDOMIZED_QUICKSORT(A, q+1, r)

計數排序(Counting sort)

P124

//Assume all the numbers are integers between 0 and k. COUNTING_SORT(A, B, k)let C[0 .. k] be a new arrayfor i = 0 to kC[i] = 0for j = 1 to A.lengthC[A[j]] = C[A[j]] + 1for i = 1 to kC[i] = C[i] + C[i-1]for j = A.length downto 1B[C[A[j]]] = A[j]C[A[j]] = C[A[j]] - 1RADIX_SORT(A, d)for i = 1 to duse a stable sort to sort array A on digit i//Assume all the number are doubles between 0 and 1. BUCKET_SORT(A)n = A.lengthlet B[0 .. n-1] be a new arrayfor i = 0 to n-1make B[i] an empty listfor i = 1 to ninsert A[i] into list B[floor(nA[i])]for i = 0 to n-1sort list B[i] with insertion sortconcatenate the list B[0], B[1], ..., B[n-1] together in order

圖算法

第六部分內容

廣度優先搜索(BFS, Breadth-First Search)

P359
無注釋版：

BFS（G, s）for each vertex u in G.V-{s}u.color = WHITEu.d = infu.pi = NILs.color = GRAYs.d = 0s.pi = NILQ = NULLENQUEUE(Q, s)while Q != NULLu = DEQUEUE(Q)for each v in G.Adj[u]if v.color == WHITEv.color = GRAYv.d = u.d + 1v.pi = uENQUEUE(Q, v)u.color = BLACK

注釋版：

BFS（G, s） //Graph:G and root vertex:sfor each vertex u in G.V-{s}u.color = WHITE // set every vertex to Undiscovered Stateu.d = inf //distance from s to uu.pi = NIL //precedent vertexs.color = GRAYs.d = 0s.pi = NIL //root vertex has been searchedQ = NULL //First in, first out.ENQUEUE(Q, s)while Q != NULLu = DEQUEUE(Q) for each v in G.Adj[u] //Search EVERY adjacent vertex of uif v.color == WHITE //Undiscoveredv.color = GRAY //Discovered but un-exaustedv.d = u.d + 1v.pi = uENQUEUE(Q, v)u.color = BLACK //exausted

打印廣度優先樹(BFT)上的最短路徑

P363

PRINT_PATH(G, s, v)if v == sprint selse if v.pi == NILprint 'no path from' s 'to' v 'exists'else PRINT-PATH(G, s, v.pi)print v

深度優先搜索(Depth-First Search)

P365

DFS(G)for each vertex u in G.Vu.color = WHITEu.pi = NILtime = 0for each vertex u in G.Vif u.color == WHITEDFS_VISIT(G, u)DFS_VISIT(G, u)time = time + 1 // White vertex u has just been discoveredu.d = time //Discovered timeu.color = GRAYfor each v in G.Adj[u] // Explore edge (u,v)if v.color == WHITE //Undiscoveredv.pi = uDFS_VISIT(G, v)u.color = BLACK // blacken u; it is finishedtime = time + 1u.f = time //Finished time

拓撲排序(Topological Sort)

P371

TOPOLOGICAL_SORT(G)call DFS(G) to compute finishing times v.f for each vertex vas each vertex is finished, insert it onto the front of a linked list

強連通分量(Strongly Connected Components)

P372

STRONGLY_CONNECTED_COMPONENTS(G)call DFS(G) to compute finishing times u.f for each vertex ucompute G^Tcall DFS(G^T),but in the main loop of DFS, consider the vertices in order of decreasing u.f (as computed in line 1)output the vertices of each tree in the depth-first forest formed in line3 as a separate strongly connected component

最小生成樹(Minimum Spanning Tree)

P378

GENERIC_MST(G,w)A = EmptySetwhile A does not form a spanning treefind an edge(u,v) that is safe for AA = A U {(u,v)}return A

單源最短路徑(Single Source Shortest Path)

P392

INITIALIZE_SINGLE_SOURCE(G,s) // s is the source vertexfor each vertex v in G.Vv.d = inf // v.distance from s (shortest)v.pi = NIL // v.father vertexs.d = 0RELAX(u,v,w)if v.d > u.d + w(u,v)v.d = u.d + w(u,v)v.pi = u

Bellman-Ford 算法

P394

BELLMAN_FORD(G,w,s)INITIAZE_SINGLE_SOURCE(G,s)for i = 1 to |G.V|-1for each edge(u,v) in G.ERELAX(u,v,w)for each edge(u,v) in G.Eif v.d > u.d + w(u,v) //for negative-value Loopreturn FALSEreturn TRUE

有向無環圖(DAG, Directed Acyclic Graph)中的單源最短路徑問題

P396

DAG_SHORTEST_PATHS(G,w,s)topologically sort the vertices of GINITIALIZE_SINGLE_SOURCE(G,s)for each vertex u, taken in topologically sorted orderfor each vertex v in G.Adj[u]RELAX(u,v,w)

Dijkstras算法

P398

DIJKSTRA(G,w,s)INITIALIZE_SINGLE_SOURCE(G,s)S = EMPTY_SET // empty setQ = G.Vwhile Q != EMPTY_SETu = EXTRACT_MIN(Q)S = S U {u}for each vertex v in G.Adj[u]RELAX(u,v,w)

節點對最短路徑

打印最短路徑

P414

PRINT_ALL_PAIRS_SHORTEST_PATH(Π,i,j) //前驅矩陣Π，存儲了從i到j的最短路徑中j的前驅節點pai[i][j]if i == jprint ielse if pai[i][j] == NILprint "no path from" i "to" j "exists"else PRINT_ALL_PAIRS_SHORTEST_PATH(Π,i,pai[i][j])

基于矩陣乘法的動態規劃法(O(n⁴),O(n³lgn))

EXTEND_SHORTEST_PATHS(L,W)n = L.rowsLet Lprim=(lprim[i][j]) be a new n*n matrixfor i = 1 to nfor j = 1 to nlprim[i][j] = Inffor k = 1 to nlprim[i][j] = min(lprim[i][j],l[i][k]+w[k][j])return LprimSQUARE_MATRIX_MULTIPLY(A,B)n = A.rowslet C be a new n*n matrixfor i = 1 to nfor j = 1 to nc[i][j] = 0for k = 1 to nc[i][j] = c[i][j] + a[i][k] * b[k][j]return C SLOW_ALL_PAIRS_SHORTEST_PATHS(W)n = W.rowsL_1 = Wfor m = 2 to n-1let L_m be a new n*n matrixL_m = EXTEND_SHORTEST_PATHS(L_m-1,W)return L_n-1FASTER_ALL_PAIRS_SHORTEST_PATHS(W)n = W.rowsL_1 = Wm = 1while m < n-1let L_2m be a new n*n matrixL_2m = EXTEND_SHORTEST_PATHS(L_m,L_m)m = 2mreturn L_m

Floyd-Warshall算法(O(n³))

FLOYD_WARSHALL(W)n = W.rowsD_0 = Wfor k = 1 to nlet D_k = (d_k[i][j]) be a new n*n matrixfor i = 1 to nfor j = 1 to nd_k[i][j] = min(d_k-1[i][j],d_k-1[i][k]+d_k-1[k][j])return D_nFLOYD_WARSHALL_PRIME(W)n = W.rowsD = Wfor k = 1 to nfor i = 1 to nfor j = 1 to nd[i][j] = min(d[i][j],d[i][k]+d[k][j])return D

構建傳遞閉包

TRANSITIVE_CLOSURE(G)n = |G.V|let T_0 = (t_0[i][j]) be a new n*n matrixfor i = 1 to nfor j = 1 to nif i == j or (i,j) in G.Et_0[i][j] = 1else t_0[i][j] = 0for k = 1 to nlet T_k = (t_k[i][j]) be a new n*n matrixfor i = 1 to nfor j = 1 to nt_k[i][j] = t_k-1[i][j] ∪ (t_k-1[i][k] ∩ t_k-1[k][j])return T_n

Johnson算法(O(n²lgn+VE))

散列表/哈希表(Hash table)

P157

直接尋址表(direct-address table)

DIRECT_ADDRESS_SEARCH(T, k)return T[k]DIRECT_ADDRESS_INSERT(T, x)T[x.key] = xDIRECT_ADDRESS_DELETE(T, x)T[x.key] = NIL

鏈接法(Chaining)解決沖突

P159

CHAINED_HASH_INSERT(T, x)insert x at the head of list T[h(x.key)]CHAINED_HASH_SEARCH(T, x)search for an element with key k in list T[h(k)]CHAINED_HASH_DELETE(T, x)delete x from the list T[h(x.key)]

開放尋址法(open addressing)

P167

HASH_INSERT(T, k)i = 0repeatj = h(k,i) // <h(k,0),h(k,1),…，h(k,m-1)> 探查序列(probe sequence)if T[j] == NILT[j] = kreturn jelse i = i+1until i == merror "hash table overflow"HASH_SEARCH(T, k)i = 0repeatj = h(k,i)if T[j] == kreturn ji = i+1until T[j] == NIL or i == mreturn NILHASH_DELETE(T, k) //比較困難；故在必須刪除關鍵字的應用中，常使用鏈接法來解決沖突

總結

以上是生活随笔為你收集整理的算法导论中的伪代码的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。