BFS(G, s)
  for each u ∈ V[G] − {s}
    color[u] ← WHITE
    d[u]     ← ∞
    π[u]     ← NIL
  color[s] ← GRAY
  d[s]     ← 0
  Q ← ∅
  ENQUEUE(Q, s)
  while Q ≠ ∅
    u ← DEQUEUE(Q)
    for each v ∈ Adj[u]
      if color[v] = WHITE
        color[v] ← GRAY
        d[v]     ← d[u] + 1
        π[v]     ← u
        ENQUEUE(Q, v)
    color[u] ← BLACK

// Time: O(V + E)

DFS(G)
  for each u ∈ V[G]
    color[u] ← WHITE
    π[u] ← NIL
  time ← 0
  for each u ∈ V[G]
    if color[u] = WHITE
      DFS-VISIT(u)

DFS-VISIT(u)
  color[u] ← GRAY
  time ← time + 1;  d[u] ← time
  for each v ∈ Adj[u]
    if color[v] = WHITE
      π[v] ← u
      DFS-VISIT(v)
  color[u] ← BLACK
  time ← time + 1;  f[u] ← time

// Time: O(V + E)

TOPOLOGICAL-SORT(G)
  1. DFS(G) // her v için f[v] hesaplanır
  2. Köşeleri f[v] değerinin azalan sırasına göre sırala
  3. Sıralı listeyi döndür

// Time: Θ(V + E)

MST-PRIM(G, w, r)
  for each u ∈ V[G]
    key[u] ← ∞
    π[u]   ← NULL
  key[r] ← 0
  Q ← BuildMinHeap(V, key)
  while Q ≠ ∅
    u ← ExtractMin(Q)
    for each v ∈ Adj[u]
      if v ∈ Q and w(u, v) < key[v]
        π[v]   ← u
        key[v] ← w(u, v)

// Time: O(E lg V)

MST-KRUSKAL(G, w)
  A ← ∅
  for each v ∈ V[G]
    Make-Set(v)
  Kirişleri ağırlığa göre artan sırayla sırala
  for each (u, v) ∈ E  // artan ağırlık
    if Find-Set(u) ≠ Find-Set(v)
      A ← A ∪ {(u, v)}
      Union(Find-Set(u), Find-Set(v))
  return A

// Time: O(E lg E)

DIJKSTRA(G, w, s)
  INIT-SINGLE-SOURCE(V, s)   // d[v]←∞, π[v]←NIL, d[s]←0
  S ← ∅
  Q ← V[G]
  while Q ≠ ∅
    u ← EXTRACT-MIN(Q)
    S ← S ∪ {u}
    for each v ∈ Adj[u]
      if d[v] > d[u] + w(u, v)
        d[v] ← d[u] + w(u, v)
        π[v] ← u

// Time: O((V + E) log V)

BELLMAN-FORD(G, w, s)
  INIT-SINGLE-SOURCE(V, s)
  for i ← 1 to |V| − 1
    for each edge (u, v) ∈ E
      if d[v] > d[u] + w(u, v)
        d[v] ← d[u] + w(u, v); π[v] ← u
  for each edge (u, v) ∈ E
    if d[v] > d[u] + w(u, v)
      return FALSE
  return TRUE

// Time: O(V · E)

FLOYD-WARSHALL(W)
  n ← rows[W]
  D ← W
  for k ← 1 to n
    for i ← 1 to n
      for j ← 1 to n
        D[i][j] ← min(D[i][j], D[i][k] + D[k][j])
  return D

// Time: Θ(V³)

FORD-FULKERSON(G, s, t)
  for each edge (u, v) ∈ E
    f(u, v) ← 0
  while ∃ augmenting path p in residual G_f
    c_f(p) ← min{ c_f(u,v) : (u,v) ∈ p }
    for each (u, v) ∈ p
      f(u, v) ← f(u, v) + c_f(p)
  return f

// Edmonds-Karp (BFS path): O(V · E²)