Graph traversal

From Wikipedia, the free encyclopedia
Jump to: navigation, search
"Graph search" redirects here. It is not to be confused with Facebook Graph Search.

In computer science, graph traversal (also known as graph search) refers to the process of visiting (checking and/or updating) each vertex in a graph. Such traversals are classified by the order in which the vertices are visited. Tree traversal is a special case of graph traversal.


Unlike tree traversal, graph traversal may require that some vertices be visited more than once, since it is not necessarily known before transitioning to a vertex that it has already been explored. As graphs become more dense, this redundancy becomes more prevalent, causing computation time to increase; as graphs become more sparse, the opposite holds true.

Thus, it is usually necessary to remember which vertices have already been explored by the algorithm, so that vertices are revisited as infrequently as possible (or in the worst case, to prevent the traversal from continuing indefinitely). This may be accomplished by associating each vertex of the graph with a "color" or "visitation" state during the traversal, which is then checked and updated as the algorithm visits each vertex. If the vertex has already been visited, it is ignored and the path is pursued no further; otherwise, the algorithm checks/updates the vertex and continues down its current path.

Several special cases of graphs imply the visitation of other vertices in their structure, and thus do not require that visitation be explicitly recorded during the traversal. An important example of this is a tree, during a traversal of which it may be assumed that all "ancestor" vertices of the current vertex (and others depending on the algorithm) have already been visited. Both the depth-first and breadth-first graph searches are adaptations of tree-based algorithms, distinguished primarily by the lack of a structurally determined "root" vertex and the addition of a data structure to record the traversal's visitation state.

Graph traversal algorithms[edit]

Note. — If each vertex in a graph is to be traversed by a tree-based algorithm (such as DFS or BFS), then the algorithm must be called at least once for each entirely distinct subgraph of the graph. This is easily accomplished by iterating through all the vertices of the graph, performing the algorithm on each vertex that is still unvisited when examined.

Depth-first search[edit]

Main article: Depth-first search

A depth-first search (DFS) is an algorithm for traversing a finite graph. DFS visits the child vertices before visiting the sibling vertices; that is, it traverses the depth of any particular path before exploring its breadth. A stack (often the program's call stack via recursion) is generally used when implementing the algorithm.

The algorithm begins with a chosen "root" vertex; it then iteratively transitions from the current vertex to an adjacent, unvisited vertex, until it can no longer find an unexplored vertex to transition to from its current location. The algorithm then backtracks along previously visited vertices, until it finds a vertex connected to yet more uncharted territory. It will then proceed down the new path as it had before, backtracking as it encounters dead-ends, and ending only when the algorithm has backtracked past the original "root" vertex from the very first step.

DFS is the basis for many graph-related algorithms, including topological sorts and planarity testing.


  • Input: A graph G and a vertex v of G.
  • Output: A labeling of the edges in the connected component of v as discovery edges and back edges.
1 procedure DFS(G, v):
2     label v as explored
3     for all edges e in G.incidentEdges(v) do
4         if edge e is unexplored then
5             wG.adjacentVertex(v, e)
6             if vertex w is unexplored then
7                 label e as a discovered edge
8                 recursively call DFS(G, w)
9             else
10               label e as a back edge

Breadth-first search[edit]

Main article: Breadth-first search

A breadth-first search (BFS) is another technique for traversing a finite graph. BFS visits the neighbor vertices before visiting the child vertices, and a queue is used in the search process. This algorithm is often used to find the shortest path from one vertex to another.


  • Input: A graph G and a vertex v of G.
  • Output: The closest vertex to v satisfying some conditions, or null if no such a vertex exists.
1 procedure BFS(G, v):
2     create a queue Q
3     enqueue v onto Q
4     mark v
5     while Q is not empty:
6         tQ.dequeue()
7         if t is what we are looking for:
8             return t
9         for all edges e in G.adjacentEdges(t) do
12            oG.adjacentVertex(t, e)
13            if o is not marked:
14                mark o
15                enqueue o onto Q
16     return null


Breadth-first search can be used to solve many problems in graph theory, for example:

Graph exploration[edit]

The problem of graph exploration can be seen as a variant of graph traversal. It is an online problem, meaning that the information about the graph is only revealed during the runtime of the algorithm. A common model is as follows: given a connected graph G = (V, E) with non-negative edge weights. The algorithm starts at some vertex, and knows all incident outgoing edges and the vertices at the end of these edges—but not more. When a new vertex is visited, then again all incident outgoing edges and the vertices at the end of the edges are known. The goal is to visit all n vertices and return to the starting vertex, but the sum of the weights of the tour should be as small as possible. The problem can also be understood as a specific version of the travelling salesman problem, where the salesman has to discover the graph on the go.

For general graphs, the best known algorithms for both undirected and directed graphs is a simple greedy algorithm:

  • In the undirected case, the greedy tour is at most O(ln n)-times longer than an optimal tour.[1] The best lower bound known for any deterministic online algorithm is 2.5 − ε;[2]
  • In the directed case, the greedy tour is at most (n − 1)-times longer than an optimal tour. This matches the lower bound of n − 1.[3] An analogous competitive lower bound of Ω(n) also holds for randomized algorithms that know the coordinates of each node in a geometric embedding. If instead of visiting all nodes just a single "treasure" node has to be found, the competitive bounds are Θ(n²) on unit weight directed graphs, for both deterministic and randomized algorithms.

Universal Traversal Sequences[edit]

A universal traversal sequence is a sequence of instructions comprising a graph traversal for any regular graph with a set number of vertices and for any starting vertex. A probabilistic proof was used by Aleliunas et. al to show that there exists a universal traversal sequence with number of instructions proportional to for any regular graph with n vertices.[4] The steps specified in the sequence are relative to the current node, not absolute. For example, if the current node is vj, and vj has d neighbors, then the traversal sequence will specify the next node to visit, vj+1, as the ith neighbor of vj, where 1 ≤ id.


  1. ^ Rosenkrantz, Daniel J.; Stearns, Richard E.; Lewis, II, Philip M. "An Analysis of Several Heuristics for the Traveling Salesman Problem". SIAM Journal on Computing. 6 (3): 563–581. doi:10.1137/0206041. 
  2. ^ Dobrev, Stefan; Královic, Rastislav; Markou, Euripides (2012). "Online Graph Exploration with Advice". Proc. of the 19th International Colloquium on Structural Information and Communication Complexity (SIROCCO). doi:10.1007/978-3-642-31104-8_23. 
  3. ^ Foerster, Klaus-Tycho; Wattenhofer, Roger (December 2016). "Lower and upper competitive bounds for online directed graph exploration". Theoretical Computer Science. 655: 15–29. doi:10.1016/j.tcs.2015.11.017. 
  4. ^ Aleliunas, R.; Karp, R.; Lipton, R.; Lovász, L.; Rackoff, C. (1979). "Random walks, universal traversal sequences, and the complexity of maze problems". 20th Annual Symposium on Foundations of Computer Science (sfcs 1979). doi:10.1109/SFCS.1979.34.