经典常用算法 伪代码合集
文章目录
- 类别一：Sorting Algorithms（排序算法）
- Bucket Sort
- COUNTING_SORT
- RADIX_SORT
- INSERT_SORT
- MERGE_SORT
- QUICK_SORT
- HEAP_SORT
- 类别二：BINARY TREE ALGORITHMS（二叉树算法）
- TREE_SEARCH
- TREE_MINIMUM
- TREE_MAXIMUM
- TREE_INSERT
- TREE_DELETE
- Minimum spanning tree
- MST_KRUSKAL
- MST_PRIM
- 第三类：Graph Algorithms（图类算法）
- BFS
- DFS
- DIJKSTRA
类别一：Sorting Algorithms（排序算法）
Bucket Sort
BUCKET_SORT(A)
n = A.length
let B[0...n-1] be a new array
for i = 0 to n-1
make B[i] an empty list
for i = 1 to n
insert A[i] to B[A[i]]
for i = 0 to n
sort list B[i] with insertion sort
concatenate the lists B[0]...B[n] together in order
COUNTING_SORT
COUNTING_SORT(A,B,k)
n = A.length
let C[0...k] be a new array
for i = 0 to k
C[i] = 0
for i = 1 to n
C[A[i]] = C[A[i]]+1
for i = 1 to k
C[i] = C[i-1]+C[i]
for i = n down to 1
B[C[A[i]]] = A[i]
C[A[i]] = C[A[i]]-1
RADIX_SORT
RADIX_SORT(A,d)
for i = 1 to b
user a stable sort to sort array A on digit i
example use COUNTING_SORT:
COUNTING_SORT(A,exp)
n = A.length
let B[1...n] C[0...k] be new arrays
for i = 0 to k
C[i] = 0
for i = 1 to n
C[(A[i]/exp)%10] = C[(A[i]/exp)%10] +1
for i = 1 to k
C[i] = C[i-1] + C[i]
for i = n down to 1
B[C[(A[i])/exp]%10] = A[i]
C[(A[i])/exp]%10] = C[(A[i])/exp]%10]-1
for i = n down to 1
A[i] = B[i]
RADIX_SORT(A,k)
exp = 1
while (k/exp)%10!=0
COUNTING_SORT(A,k)
exp = exp*10
INSERT_SORT
INSERT_SORT(A)
for i = 2 to n
key = A[i]
j = i-1
while j > 0 and A[j]>key
A[j+1] = A[j]
j = j -1
A[j+1] = key
MERGE_SORT
MERGE_SORT(A,low,high)
if low<high
mid = (low+high)/2
MERGE_SORT(A,low,mid-1)
MERGE_SORT(A,mid,high)
MERGE(A,low,high,mid)
MERGE(A,low,high,mid)
let LA[1..mid-low] RA[1...high-mid+1] be new arrays
for i = 1 to mid-low
LA[i] = A[i+low]
for j = 1 to high-mid+1
RA[i] = A[i+mid-1]
l = 1
r = 1
k = low
while l<=i and r <= j
if(LA[l]>RA[r])
A[k++] = LA[l++]
else A[k++] = RA[r++]
while l<=i
A[k++] = LA[l++]
while r<=j
A[k++] = RA[r++]
QUICK_SORT
QUICK_SORT(A,p,r)
if p<r
q = PARTITION(A,p,r)
QUICK_SORT(A,p,q-1)
QUICK_SORT(A,q+1,r)
PARTITION(A,p,r)
i = p-1
for j = p to r-1
if A[j]<A[r]
i = i+1
exchange A[j] with A[i]
exchange A[i+1] with A[r]
return i+1
HEAP_SORT
HEAP_SORT(A)
BUILD_MAX_HEAP(A)
for i = [A.length]/2 down to 1
MAX_HEAPIFY(A,i)
MAX_HEAPIFY(A,i)
l = LEFT(i)
r = RIGHT(i)
if l <=A.heap-size and A[l]>A[i]
largest = l
else largest = i
if r <= A.heap-size and A[r]> A[i]
largest = r
if largest != i
exchange A[i] with A[largest]
MAX_HEAPITY(A,largest)
BUILD_MAX_HEAP(A)
A.heap-size = A.length
for i = A.heap-size/2 down to 1
MAX_HEAPITY(A,i)
类别二：BINARY TREE ALGORITHMS（二叉树算法）
TREE_SEARCH
TREE_SEARCH(x,k)
while x!=NIL and k! = x.key
if k<x.key
x = x.left
else x = x.right
if x!=NIL
return x
TREE_MINIMUM
TREE_MINIMUM(x,k)
whiel x!= NIL and k!=x.key
if k<x.key
x = x.left
else x= x.right
return x
TREE_MAXIMUM
TREE_MAXIMUM(x)
while x.right != NIL
x = x.right
return x
TREE_INSERT
TREE_INSERT(T,z)
y = NIL
x = T.root
while x!=NIL
y = x
if z.key < x.key
x = x.left
else x = x.right
z.p = y
if(y==NIL)
T.root = z
else if z.key > y.key
y.right = z
else y.left = z
TREE_DELETE
TREE_DELETE(T,z)
if z.left == NIL
TRANSPLANT(T,z,z.right)
else if z.right == NIL
TRANSPLANT(T,z,z.left)
else y = TREE_MINIMUM(z.right)
if y.p!=z
TRANSPLANT(T,y,y.right)
y.right = z.right
y.right.p = y
TRANSPLANT(T,z,y)
y.left = z.left
y.left.p = y
TRANSPLANT(T,u,v)
if u.p == NIL
T.root = v
else if u == u.p.left
u.p.left = v
else u.p.right = v
if v!=NIL
v.p = u.p
Minimum spanning tree
GENETRIC_MST(A,W)
A = ∅
while A doesn't form a spanning tree
find an edge(u,v) that is safe for A
A = A∪(u,v)
return A
MST_KRUSKAL
MST_KRUSKAL(G,w)
A = ∅
for each vertex v ∈ G.V
MAKE SET(v)
sort the edges of G.E into nondecreasing order by weight w
for each edge (u,v) ∈ G.V taken in nondecreasing order by weight
if FIND-SET(u) != FIND-SET(v)
A = A∪(u,v)
UNION(u,v)
return A
MST_PRIM
MST_PRIM(G,w,r)
for each u ∈ G.V
u.key = ∞
u.π = NIL
r.key = 0
Q = G.V
while Q != ∅
u = EXTRACT-MIN(Q)
for each v∈G.Adj(u)
if v∈Q and w(u,v)<v.key
v.π = u
v.key = w(u,v)
第三类：Graph Algorithms（图类算法）
BFS
BFS(G,s)
for each vertex u∈G.V-{s}
u.color = WHITE
u.d = ∞
u.π = NIL
s.color = GRAY
s.d = 0
s.π = NIL
Q= ∅
ENQUEUE(Q,s)
while Q!=∅
u = DEQUEUE(Q)
for each v ∈ G.Adj(u)
v.color = GRAY
v.d = u.d + 1
v.π = u
ENQUEUE(Q,v)
u.color = BLACK
DFS
DFS(G)
for each vertex u ∈ G.V
u.color = WHITE
u.π = NIL
time = 0
for each vertex u ∈ G.V
if u.color = WHITE
DFS-VISIT(G,u)
DFS-VISIT(G,u)
time = time +1
u.d = time
u.color = GRAY
for each v ∈ G.Adj(u)
if v.color = WHITE
DFS-VISIT(v)
u.color = BLACK
time = time +1
u.f = time
DIJKSTRA
DIJKSTRA(G,w,s)
S = ∅
Q = G.V
while Q!= ∅
u = EXTRACT-MIN(Q)
S = S ∪ {u};
for each vertex v Q.Adj(u)
RELAX(v)
RELAX(u,v,w)
if v.d > u.d + w(u,v)
v.d = u.d + w(u,v)
v.π = u