graph

#include <stdio.h>
#include "graph.h"
#include "fatal.h"

struct GraphRecord
{
      int adj[max][max];
      int visited[max];
      int nodes;
};

Graph CreateGraph(int NodesCount)
{
      Graph G;
      
      G = malloc(sizeof(struct GraphRecord));
      if(G == NULL) FatalError( "Out of space!!!" );
      
      G->nodes = NodesCount;
      
      return G;
}


void DisposeGraph(Graph G)
{
     free(G);
}


/* a function to build adjacency matrix of a graph */
void buildadjm(Graph G)
   {
     int i,j;
     for(i=0;i<G->nodes;i++)
         for(j=0;j<G->nodes;j++)
          {
           printf("enter 1 if there is an edge from %d to %d, otherwise enter 0 \n", i,j);
           scanf("%d",&(G->adj[i][j]));
           }
      }



void printadjm(Graph G)
{
     int i,j;
     for(i=0;i<G->nodes;i++)
     {                            
         for(j=0;j<G->nodes;j++)
          printf(" %d",G->adj[i][j]);
         putchar('\n');
     }   
}

void ClearVisited(Graph G)
{
     int n;
     for(n=0; n<G->nodes; n++)
         G->visited[n] = 0;      
}

void FillGraph(Graph G)
{
        G->adj[0][0]=0;
        G->adj[0][1]=0;
        G->adj[0][2]=1;
        G->adj[0][3]=0;

        G->adj[1][0]=0;
        G->adj[1][1]=0;
        G->adj[1][2]=1;
        G->adj[1][3]=1;

        G->adj[2][0]=1;
        G->adj[2][1]=1;
        G->adj[2][2]=0;
        G->adj[2][3]=0;

        G->adj[3][0]=0;
        G->adj[3][1]=1;
        G->adj[3][2]=0;
        G->adj[3][3]=0;
     
     }


void dfs(Graph G)
{    
     int n;
     
     for(n=0; n<G->nodes; n++){
         if(G->visited[n] ==0){     
             dfsr(n,G);
         }    
     }
}


void dfsr(int x, Graph G)
{
   int j;
   G->visited[x]=1;
   printf("The node visited: %d\n",x);
   for(j=0;j<G->nodes;j++)
      if(G->adj[x][j] ==1 && G->visited[j] ==0)
           dfsr(j,G);
}


void printEdge(int x, Graph G)
{
   int j;
   G->visited[x]=1;   
   for(j=0;j<G->nodes;j++)
      if(G->adj[x][j] ==1 && G->visited[j] ==0){
          printf("Edge: (%d,%d)\n",x,j); 
          printEdge(j,G);
      }
}

void dfsst( Graph G){    
     int n;
     ClearVisited(G);
        
     
     for(n=0; n<G->nodes; n++){
         if(G->visited[n] ==0){     
             printEdge(n,G);
         }    
     }
}