0      
     / \                  
     1  2                
     \ /                   
      3                     
      |                     
      4                    
     / \                    
    5   6                     

int main()
/*  depth first and breadth first search of a graph */
{
   int i;
   node_pointer graph[MAX_NODES];
   
   int n = 0; /* number of vertices currently in use */

   int choice = print_menu();
   while (choice !=5) {
      switch(choice) {
          case 1: create_list(graph,&n);
   	           break;
          case 2:  printf("The list has %d vertices in use.\n",n);
   		   print_list(graph, n);
   		   break;
          case 3:  start_depth_first(graph,n);
                   break;
          case 4:  breadth_first_search(0, graph,n);
         }
         printf("\n\n");
         choice = print_menu();
      }     
}

1. Chose a starting vertex. Typically, this is the first vertex, Vertex 0.
2. Mark this vertex as visited. Marking requires an auxiliary array. The array cells are initialized to 0 (false) for non-visted. When you visit a vertex you may mark it with a one (true) to indicate that the cell have been visited, or you may mark it with a number that indicates the order in which the vertex was visited, i.e., 1,2,3,etc. In our example, we'll mark the vertices as 0 or 1.
3. Choose the first unvisited vertex from the current vertex's adjacency list. Continue the search with the new vertex's adjacency list.
4. Continue this process until you reach a vertex that has no unvisited vertices in it adjacency list. At this point, back up to the adjacency list of the last vertex (on the stack).

The code that implements the initialization is called start_depth_first(). This function requires parameters representing the graph and the number of nodes in the graph. The code is found in the following table.

void start_depth_first(node_pointer graph[],int size)
{
   int visited[MAX_NODES];
   int i;
   for (i = 0;  i < size;  i++)
       visited[i] = FALSE;
   printf("Depth first search: ");
   depth_first_search(0, graph, visited);
}

1. Marks the node passed as a parameter as visited.
2. Contains a statement that processes the node's adjacency list. This forstatement assigns node2 to point to the first block in node1's adjacency list. The depth_first_search() function is called recursively with node2. Because the recursive call is contained within the for statement, the function "remembers" the current position in each vertex's adjacency list.

void depth_first_search(int node1, node_pointer graph[], int visited[])
{
/* depth first traversal of a graph beginning with node1.  */
   node_pointer node2;
   visited[node1] = TRUE;
   printf("%5d",node1);
   for (node2 = graph[node1]; node2; node2 = node2->link)
      if (!visited[node2->vertex])
	 depth_first_search(node2->vertex, graph, visited);
}

Enter your choice: 3
Depth first search:     0    2    3    4    6    5    1

    vertex    Adjacency List

    0                 2  1
    1                 3  0
    2                 3  0
    3                 4  2  1
    4                 6  5  3
    5                 4
    6                 4

1. Initial Call. The depth_first_search() function is called with vertex 0. This vertex is marked as visited. The for statement selects vertex 2 for the recursive call.
   
   

   Stack	Selected Vertex	Adjacency List
   ^0	2	1

   
   
   
2. Second Call. Vertex 2 is marked as visited, and vertex 3 is selected for the next recursive call.
   
   

   Stack	Selected Vertex	Adjacency List
   ^2	3	0
   ^0	2	1

   
   
   
3. Third Call Vertex 3 is marked as visited, and vertex 4 is selected for the next recursive call
   
   

   Stack	Selected Vertex	Adjacency List
   ^3	4	2 1
   ^2	3	0
   ^0	2	1

   
   
   
4. Fourth Call Vertex 4 is marked as visited, and vertex 6 is selected for the next recursive call.
   
   

   Stack	Selected Vertex	Adjacency List
   ^4	6	5 3
   ^3	4	2 1
   ^2	3	0
   ^0	2	1

   
   
   
5. Fifth Call Vertex 6 is marked as visited. The only vertex on six s adjacency list is four which was visited so four is popped from the stack
   
   

   Stack	Selected Vertex	Adjacency List
   ^6	NONE 4 visited
   ^4	6	5 3
   ^3	4	2 1
   ^2	3	0
   ^0	2	1

   
   
   
6. Vertex six is popped from the stack. The travesal continues with vertex four's adjacency list
   
   

   Stack	Selected Vertex	Adjacency List
   ^4	5	3
   ^3	4	2 1
   ^2	3	0
   ^0	2	1

   
   
   
7. Vertex five is marked as visited. The only vertex on five's list is four which was previously visited. Five is popped from the stack.
   
   

   Stack	Selected Vertex	Adjacency List
   ^5	NONE
   ^4	5	5 3
   ^3	4	2 1
   ^2	3	0
   ^0	2	1

   
   
   
8. Search returns to vertex four's adjacency list. Only vertex three remains. Since three was previously visisted, vertex 4 is popped from the stack.
   
   

   Stack	Selected Vertex	Adjacency List
   ^4	5	3
   ^3	4	2 1
   ^2	3	0
   ^0	2	1

   
   
   
9. Search returns to vertex three's adjacency list. Links to vertex 2 and vertex 1 remain. Since vertex 2 was previously visited, vertex 1 is chosen.
   
   

   Stack	Selected Vertex	Adjacency List
   ^3	1	2 1
   ^2	3	0
   ^0	2	1

   
   
   
10. Vetex 1 is marked as visited. Since each vertex in its list has been visited, the search would continue with vertex 3's list, then 2's then 0's. Since vertex 1 is the last vertex in the spanning tree, the for statement examines the lists and pops the vertices off of the stack.
    
    

    Stack	Selected Vertex	Adjacency List
    ^1	NONE	3 0
    ^3	1
    ^2	3	0
    ^0	2	1

      0      
      |                 
      2                 
      |                     
      3                     
     / \                    
    4   1                    
   / \                    
  6   5                     

     3 
   /  \ 
  4    2
 / \   |
6   5  0
       |
       1     

   4  
 / | \ 
6 5  3
     |
     2
     |
     0
     |
     1

 5
 |
 4
/ \ 
6  3
   |
   2
   |
   0
   |
   1

1. Initializes the visited array to FALSE
2. Marks node1 as visited. (This is the node passes as the parameter.
3. Adds node1's adjacency list to the queue
4. Uses a while statement to:
   1. Delete a node from the queue
   2. Process each link in the deleted node's adjacency list. (The for statement takes care of this code.) If the vertex in the adjacency list has not been visited, it is:
      1. Marked as visited
      2. The vertex is printed to the screen
      3. The vertex's adjacency list is added to the queue.

void breadth_first_search(int node1, node_pointer graph[], int size)
{
   int i;
   int visited [MAX_NODES];
   node_pointer node2;
   queue_pointer front,rear;
   
   for (i=0; i < size;  i++)
     visited[i] = FALSE;
   printf("\n\nBreadth first search:");
   
   front = rear = NULL; /* initialize queue */
   printf("%5d",node1);
   visited[node1] = TRUE;
   add_queue(&front,&rear,node1);
   while (front) {
      node1 = delete_queue(&front);
      for (node2 = graph[node1]; node2; node2 = node2->link)
	if (!visited[node2->vertex]) {
	   printf("%5d", node2->vertex);
	   add_queue(&front,&rear,node2->vertex);
	   visited[node2->vertex] = TRUE;
       }
    }
}

Enter your choice: 4

Breadth first search:    0    2    1    3    4    6    5

      0      
     / \                  
     2  1                
     |
     3                     
     |                     
     4                    
    / \                    
   6   5                     

     3 
   / | \ 
  4  2  1
 / \ |
6  5 0 

   4  
 / | \ 
6 5   3
     / \
    2   1
    |
    0

 5
 |
 4
/ \ 
6  3
  / \
 2   1
 |
 0