graph dfs

#ifndef _GRAPH_H_
#define _GRAPH_H_
#include <stdbool.h>

typedef struct graph Graph;
typedef struct headNode HeadNode;
typedef struct peerNode PeerNode;

struct graph{
    int * vertex;    //vertex array
    int vertexSize;    //graph's vertex size
    HeadNode * head;    //vertex's head node;
};

struct headNode{
    int vertex;            //current vertex 
    int adjSize;        //current vertex's adjacency size
    PeerNode * firstPeer;   //current vertex's first peer node 
};

struct peerNode{
    int peer;            //vertex's peer
    int weight;            //edge weight
    PeerNode * next;        //next peer node
};

void create_graph(Graph * g, int vertexSize);

void destroy_graph(Graph * g);

bool make_edge(Graph * g, int from, int to, int wight);

bool remove_edge(Graph * g, int from, int to);

void print_graph(Graph * g);

//algorithm
void dfs(Graph * g, int from);

#endif

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "graph.h"

static void _make_peer(HeadNode * head, int peerVertex, int weight);

static void _dfs(Graph * g, int from,bool * visited);

static void _make_peer(HeadNode * head, int peerVertex, int weight)
{
    PeerNode * newPeer = (PeerNode *)malloc(sizeof(PeerNode));
    newPeer->peer = peerVertex;
    newPeer->weight = weight;
    newPeer->next = head->firstPeer;
    head->firstPeer = newPeer;
}

void create_graph(Graph * g, int vertexSize)
{
    g->vertexSize = vertexSize;
    g->vertex = (int *)malloc(sizeof(int) * vertexSize);
    g->head = (HeadNode *)malloc(sizeof(HeadNode) * vertexSize);
    for(int i = 0; i < vertexSize; i++)
    {
    g->vertex[i] = 0;
    g->head[i].vertex = i;
    g->head[i].adjSize = 0;
    g->head[i].firstPeer = NULL;
    }
}

void destroy_graph(Graph * g)
{
    for(int i = 0; i < g->vertexSize; i++)
    {
    PeerNode * current = g->head[i].firstPeer;
    PeerNode * nextNode = NULL;
    while(current)
    {
        nextNode = current->next;
        free(current);
        current = nextNode;
    }
    }
    free(g->head);
    free(g->vertex);
}

bool make_edge(Graph * g, int from, int to, int weight)
{
    PeerNode * current = g->head[from].firstPeer;
    while(current)
    {
    if(current->peer == to)
    {
        printf("(%u, %u) is already exist!
", from, to);
        return false;
    }
    current = current->next;
    }
    _make_peer(&g->head[from], to, weight);
    g->head[from].adjSize++;
    return true;
}

bool remove_edge(Graph * g, int from, int to)
{
    PeerNode * current = g->head[from].firstPeer;
    while(current->next && current->next->peer != to)
    current = current->next;
    if(!current)
    {
    printf("(%d, %d) is not exist!
", from, to);
    return false;
    }
    else
    {
    PeerNode * delPeer = current->next;
    current->next = current->next->next;
    free(delPeer);
    return true;
    }
}

void print_graph(Graph * g)
{
    for(int i = 0; i < g->vertexSize; i++)
    {
    HeadNode currentHead = g->head[i];
    printf("[%d: %d]: ", currentHead.vertex, currentHead.adjSize);
    PeerNode * currentNode = currentHead.firstPeer; 
    for(;currentNode; currentNode = currentNode->next)
        printf("(%d, %d) ",currentNode->peer, currentNode->weight);
    printf("
");    
    }
   printf("
"); 
}

//algorithm

void dfs(Graph * g, int from)
{
    bool * visited = (bool *)malloc(sizeof(bool) * g->vertexSize);
    memset(visited, 0, g->vertexSize * sizeof(bool));
    printf("run dfs:
");
    _dfs(g,from,visited);
    printf("NULL 
");
    free(visited);
}

static void _dfs(Graph * g, int from,bool * visited)
{
    visited[from] = true;
    printf("%d - > ", from);
    PeerNode * currentPeer = g->head[from].firstPeer;
    while(currentPeer)
    {
    int nextFrom = currentPeer->peer;
    if(!visited[nextFrom])
        _dfs(g, nextFrom, visited);
    currentPeer = currentPeer->next;
    }
}

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

void create_edge(Graph * g);
int main()
{
    Graph g;
    create_graph(&g,8);
    create_edge(&g);
    print_graph(&g);
    dfs(&g,0);
    destroy_graph(&g);
    return 0;
}

void create_edge(Graph * g)
{
    make_edge(g,0,4,1);
    make_edge(g,1,0,1);
    make_edge(g,1,3,1);
    make_edge(g,1,6,1);
    make_edge(g,2,5,1);
    make_edge(g,3,5,1);
    make_edge(g,3,7,1);
    make_edge(g,4,2,1);
    make_edge(g,4,7,1);
    make_edge(g,5,6,1);
    make_edge(g,7,6,1);
}