201

5.

GRAFOVI
OBILAZAK
BFS(G,v)
for i=1 to n do
visit[i] = false
end_for
visit[v] = true
INSERT (Q,v)
while (not QUEUE-EMPTY(Q)) do
v = DELETE(Q)
for {u: (v , u)E } do
if (not visit[u]) then
visit[u] = true
INSERT (Q,u)
end_if
end_for
end_while

DFS-VISIT(v)
visit[v]=true
for {u: (v , u) E } do
if (not visit[u]) then
DFS-VISIT(u)
end_if
end_for
DFS(G,v)
for i = 1 to n do
visit[i] = false
end_for
DFS-VISIT(v)

CONN-COMP(G)
n_cc = 0
for i = 1 to n do
visit[i] = false
end_for
for i = 1 to n do
if (not (visit[i])) then
n_cc = n_cc + 1
DFS-VISIT(i) -->
CC(n_cc)
end_if
end_for
OBUHVATNA STABLA
PRIM(G,s)
KRUSKAL(G)
U = {s}
E' =
E' =
for each (u,v) in E do
while (U V) do
PQ-INSERT(PQ, w(u,v))
find (u,v) => min{w(u,v):
end_for
( uU ) and ( v (V U ) )} num = 0
while (num < n-1) do
U = U + {v}
w(u,v)=PQ-MIN-DELETE(PQ)
E' = E' + {(u,v)}
if ((u in Ti)and(v in Tj)and(ij))then
end_while
E' = E' + {(u,v)}
MST = (U,E')
T k = T i + Tj
num = num + 1
end_if
end_while
MST = (V,E')

MATRICA PUTA
WARSHALL (A)
P=A
for k = 1 to n do
for i = 1 to n do
for j = 1 to n do
p[i,j]=p[i,j] or (p[i,k] and
p[k,j])
end_for
end_for
end_for
NAJKRAA RASTOJANJA
PATH(i,j)
FLOYD (W)
D=W
if (i = j) then
for k = 1 to n do
PRINT(i)
for i = 1 to n do
return
for j = 1 to n do
else
if (d[i,j] > d[i,k] + d[k,j])
if (t[i,j] = 0) then
then
PRINT(Nema puta izmeu i i j)
t[i,j] = t[k,j]
else
d[i,j] = d[i,k] + d[k,j]
PATH(i, t[i,j])
end_if
PRINT(j)
end_for
end_if
end_for
end_if
end_for
BELLMAN-FORD(G, W)
for i = 1 to n do
d[i] = w[1,i]
DIJKSTRA (W)
S = {1}
if (w[1,i] ) then
for i = 2 to n do
t[i] = 1
d[i] = w[1,i]
else
if (w[1,i] ) then
t[i] = 0
t[i] = 1
end_if
else
end_for
t[i] = 0
for k = 1 to n-1 do
end_if
for each (u,v) in E do
end_for
if (d[u] + w[u,v] < d[v]) then
for k = 1 to n do
d[v] = d[u] + w[u,v]
find min {d[i]: i in (V - S)}
t[v] = u
S = S + {i}
end_if
for each j in (V S) do
end_for
if (d[i] + w[i,j] < d[j]) then
end_for
d[j] = d[i] + w[i,j]
for each (u,v) in E do
t[j] = i
if (d[u] + w[u,v] < d[v]) then
end_if
return false
end_for
end_if
end_for
end_for
return true

PROTOK
FORD-FULKERSON (G)
for each (u,v) in E do
f(u,v) = 0
f(v,u) = 0
end_for
while exists p(S,T) in GF do
cf(p) = min {cf(u,v): (u,v) in p}
for each (u,v) in p do
f(u,v) = f(u,v) + cf(p)
f(v,u) = -f(u,v)
end_for
end_while
KRITINI PUT
CRITICAL-PATH (G)
TOP-SORT(G)
EST[1] = 0
for u = 2 to n do
i = T[u]
for each j in P(i) do
EST[i] = max{EST[j] + w(j,i)}
end_for
end_for
LST[n] = EST[n]
for u = n-1 downto 1 do
i = T[u]
for each j in S(i) do
LST[i] = min{LST[j] w(i,j)}
end_for
end_for
for i = 1 to n do
L[i] = LST[i] - EST[i]
end_for

TOPOLOKO SORTIRANJE
TOP-SORT (G)
A=V
B=E
for i = 1 to n do
find u in A: dIN(u) = 0
T[i] = u
A = A {u}
for all v: (u,v) in B do
B = B {(u,v)}
end_for
end_for

PRETRAIVANJE
SEKVENCIJALNO PRETRAIVANJE
SEQ-SEARCH (K, key)
i=1
while (i n) do
if (key = K[i]) then
return i
else
i=i+1
end_if
end_while
return 0
SEQ-SEARCH-SENT (K, key)
K[n+1] = key
i=1
while (key K[i]) do
i=i+1
end_while
if (i = n+1) then
i=0
end_if
return i

SEQ-SEARCH-MUL (K, S)
for i = 1 to m do
P[i] = 0
end_for
i=j=1
while (in) and (jm) do
while (i<n) and (S[j]>K[i]) do
i=i+1
end_while
if (S[j]=K[i]) then
P[j] = i
end_if
j=j+1
end_while
return

BINARNO PRETRAIVANJE
BIN-SEARCH (K, key)
low = 1
high = n
while (lowhigh) do
mid = (low + high) / 2
if (key = K[mid]) then
return mid
else if (key<K[mid]) then
high = mid - 1
else
low = mid + 1
end_if
end_if
end_while
return 0

STABLA BINARNOG PRETRAIVANJA

BST-SEARCH(root, K)
p = root
if (p = nil) or (K = key(p)) then
return p
else if (K<key(p)) then
return BSTSEARCH(left(p),K)
else
return BSTSEARCH(right(p),K)
end_if
end_if
BST-MIN(root)
p = root
while (left(p) nil) do
p = left(p)
end_while
return p

BST-SEARCH-I(root, K)
p = root
while (p nil) and (K key(p)) do
if (K<key(p)) then
p = left(p)
else
p = right(p)
end_if
end_while
return p
BST-MAX(root)
p = root
while (right(p) nil) do
p = right(p)
end_while
return p

BST-INSERT-I(new, root)
p = root
BST-SUCC (r)
q = nil
p=r
while (p nil) do
if (right(p) nil) then
q=p
return BST-MIN(right(p))
if (key(new) = key(p)) then
else
ERROR(Postoji klju)
q = parent(p)
else if (key(new)<key(p)) then
while (q nil) and (p=right(q))
p = left(p)
do
else
p=q
p = right(p)
q = parent (q)
end_if
end_while
end_if
return q
end_while
end_if
if (q = nil) then
root = new
BST-INSERT(new, root)
else
p = root
if (key(new)<key(q)) then
if (p = nil) then
left(q) = new
root = new
else
else
right(q) = new
if (key(new) = key(p)) then
end_if
ERROR(Postoji klju)
end_if
else if (key(new)<key(p)) then
BST-INSERT(new, left(p))
AVL
else
BST-INSERT(new,
RIGHT-ROTATION(x)
right(p))
y = left(x)
end_if
temp = right(x)
end_if
right(y) = x
end_if
left(x) = temp

STABLA OPTEG PRETRAIVANJA

INORDER-M(root)
if (root nil) then
p = root
for i = 0 to n do
INORDER-M(pi(p))
PRINT(Ki+1(p))
end_for
INORDER-M(pm-1(p))
end_if

HEIRANJE
HASH-INSERT (T,K)
i=0
repeat
j = hi(K)
if (T[j] = empty) then
T[j] = K
return j
else
i=i+1
end_if
until i = n
ERROR(Tabela puna)

HASH-SEARCH (T,K)
i=0
repeat
j = hi(K)
if (T[j] = K) then
return j
else
i=i+1
end_if
until (T[j] = empty) or (i = n)
return empty

SEARCH-INSERT-CH (T,K)
i = h(K)
while (T[i].keyK) and (T[i].next1) do
i = T[i].next
end_while
if (T[i].key = K) then
return i
end_if
if (T[i].key = empty) then
j=i
else
while (T[free].key empty) do
free = free - 1
if (free < 0) then
ERROR(Tabela puna)
T[i].next = free
end_if
end_if
end_while
T[j].key = K
j=free
return j

SORTIRANJE
UMETANJE

INSERTION-SORT(a)
for i = 2 to n do
K = a[i]
j=i-1
while (j>0) and (a[j]>K) do
a[j+1] = a[j]
j=j-1
end_while
a[j+1] = K
end_for

SHELL-SORT(a,h)
for i = 1 to t do
inc = h[i]
for j = inc + 1 to n do
y = a[j]
k = j - inc
while (k1) and (y<a[k]) do
a[k+inc] = a[k]
k = k - inc
end_while
a[k+inc] = y
end_for
end_for

SELEKCIJA
SELECTION-SORT(a)
for i = 1 to n - 1 do
min = a[i]
pos = i
for j = i + 1 to n do
if (a[j] < min) then
min = a[j]
pos = j
end_if
end_for
a[pos] = a[i]
a[i] = min
end_for

HEAPSORT(a)
for i = 2 to n do
nhe = a[i]
s=i
f=s/2
while (s>1) and (a[f]<nhe) do
a[s] = a[f]
s=f
f=s/2
end_while
a[s] = nhe
end_for
for i = n downto 2 do
last = a[i]
a[i] = a[1]
f=1
if (i-13) and (a[3]>a[2]) then
s=3
else
s=2
end_if
while (si-1) and (a[s]>last) do
a[f] = a[s]
f=s
s = 2f
if(s+1i-1) and (a[s+1]>a[s])
then
s=s+1
end_if
end_while
a[f] = last
end_for

ADJUST(a,i,n)
K = a[i]
j = 2i
while (j n) do
if (j < n) and (a[j] < a[j+1])
then
j=j+1
end_if
if (K a[j]) then
a[j/2] = K
return
else
a[j/2] = a[j]
j = 2j
end_if
end_while
a[j/2] = K

HEAPSORT-1(a)
for i = n / 2 downto 1 do
ADJUST(a,i,n)
end_for
for i = n-1 downto 1 do
a[i+1]a[1]
ADJUST(a,1,i)
end_for

ZAMENA
BUBBLESORT(a)
pos = n
repeat
bound = pos
pos = 0
for i = 1 to bound - 1 do
if (a[i]>a[i+1]) then
a[i]a[i+1]
pos = i
end_if
end_for
until pos = 0

QUICKSORT(a,low,high)
if (low < high) then
j = PARTITION(a,low,high)
QUICKSORT(a,low,j-1)
QUICKSORT(a,j+1,high)
end_if
PARTITION(a,down,up)
i = down
j = up
pivot = a[down]
while (i<j) do
while (a[i]<pivot) and (i<j) do
i=i+1
end_while
while (a[j]>pivot) do
j=j-1
end_while
if (i<j) then
a[i]a[j]
end_if
end_while
a[down] = a[j]
a[j] = pivot
return j

BROJANJE
COUNTING-SORT(a)
for i = 1 to k do
C[i] = 0
end_for
for j = 1 to n do
C[a[j]] = C[a[j]] + 1
end_for
for i = 2 to k do
C[i] = C[i] + C[i-1]
end_for
for j = n downto 1 do
B[C[a[j]]] = a[j]
C[a[j]] = C[a[j]] - 1
end_for

SPOLJANJE SORTIRANJE
MERGE(a,l1,u1,b,l2,u2,c,l3)
i = l1
j = l2
k = l3
while (iu1) and (ju2) do
if (a[i]<b[j]) then
c[k] = a[i]
i=i+1
else
c[k] = b[j]
j=j+1
end_if
k=k+1
end_while
if (i>u1) then
while (ju2) do
c[k] = b[j]
j=j+1
k=k+1
end_while
else
while (iu1) do
c[k] = a[i]
i=i+1
k=k+1
end_while
end_if

DIRECT-MERGE(F,n)
l=1
repeat
SPLIT(F,l,F1,F2)
for j = 1 to n/(2l) do
MERGE(F1,(j-1)l+1,jl,F2,(j-1)l+1,jl,
F,2(j-1)l+1)
end_for
l = 2l
until ln
BALANCED-DIRECT-MERGE(F,n)
l=1
SPLIT(F,l,F1,F2)
a = F1
b = F2
c=F
d = F3
repeat
for j = 1 to n/(4l) do
MERGE(a,(j-1)2l+1,(2j-1)l,
b,(j-1)2l+1,(2j-1)l,c,(j-1)2l+1)
MERGE(a,(2j-1)l+1,2jl,b,(2j-1)l+1,
2jl,d,(j-1)2l+1)
end_for
l = 2l
ac
bd
until ln

LIST-MERGE(q,r,p)
i=q
j=r
k=d
while (i0) and (j0) do
if (a[i]a[j]) then
next(a[k]) = i
k=i
i = next(a[i])
else
next(a[k]) = j
k=j
j = next(a[j])
end_if
end_while
if (i=0) then
next(a[k]) = j
else
next(a[k]) = i
end_if
p = next(a[d])

MERGE-SORT-R(a,l,u)
if (lu) then
p=l
else
mid = (l+u)/2
q = MERGE-SORT-R(a,l,mid)
r = MERGE-SORT-R(a,mid+1,u)
LIST-MERGE(q,r,p)
end_if
return p