#include <stdio.h>
#include <malloc.h>

#define true 1
#define false 0
#define INFINITY 1000000
#define MaxVertexNum 100
#define MaxArcNum 100


struct ArcNode {
    int vname;
    int dist;
    struct ArcNode* Next;
};
struct VerNode {
    struct ArcNode* First;
};
struct GraphStruct {
    int vexnum, arcnum;
    struct VerNode list[MaxVertexNum];
    int Visited[MaxVertexNum];
};
struct QueueStruct {
    int capacity;
    int rear, front;
    int Array[MaxVertexNum];
};
typedef struct ArcNode* Arc;
typedef struct GraphStruct* Graph;
typedef struct QueueStruct* Queue;

void printfError();
Graph createGraph();
void initializeGraph( Graph G );
Arc createArcNode( int vname, int dist );
void BFS( Graph G, int u );
void DFS( Graph G, int u );
void enQueue( Queue q, int u );
int deQueue( Queue q );
Queue createQueue();
void initializeQueue( Queue q );

int main( void ) {

    Graph G = createGraph();
    int i = 0;
    int V1, V2, dist;
    Arc tmp = NULL;
    FILE *fp = fopen("ArrayGraph.txt", "r");
    if( !fp ) {
        printfError();
    }


    for( i = 0; i < G->arcnum; i++ ) {
        fscanf(fp, "%d %d %d", &V1, &V2, &dist);

        tmp = createArcNode( V2, dist );
        tmp->Next = G->list[V1-1].First;//這段程式碼可能可讀性比較低
        G->list[V1-1].First = tmp;
    }

    //BFS( G, 0 );
    DFS( G, 0 );

    return 0;
}
void printfError() {
    printf("Space Error!");
    exit( 0 );
}
Graph createGraph() {
    Graph G = ( Graph )malloc( sizeof( struct GraphStruct ) );
    if( !G ) {
        printfError();
    }
    initializeGraph( G );

    return G;
}
void initializeGraph( Graph G ) {
    int i = 0;
    FILE *fp = fopen("NumOfVAndA.txt", "r");
    if( !fp ) {
        printfError();
    }
    fscanf(fp, "%d %d", &G->vexnum, &G->arcnum);
    for( i = 0; i < G->vexnum; i++ ) {
        G->Visited[i] = false;
        G->list[i].First = NULL;
    }
}
Arc createArcNode( int vname, int dist ) {
    Arc tmp = ( Arc )malloc( sizeof(struct ArcNode) );
    if( !tmp ) {
        printfError();
    }

    tmp->vname = vname-1;
    tmp->dist = dist;
    tmp->Next = NULL;

    return tmp;
}
void BFS( Graph G, int u ) {
    Queue q = createQueue();
    int e = 0;
    Arc a = NULL;

    G->Visited[u] = true;
    enQueue( q, u );
    printf("%d ", u+1);

    while( q->front != q->rear ) {

        e = deQueue( q );
        a = G->list[e].First;

        while( a ) {
            if( !G->Visited[a->vname] ) {
                printf("%d ", (a->vname)+1);
                G->Visited[a->vname] = true;
 

		enQueue( q, a->vname );
            }
            a = a->Next;
        }
    }
}
void DFS( Graph G, int u ) {
    Arc a = G->list[u].First;
    G->Visited[u] = true;
    printf("%d ", u+1);

    while( a ) {
        if( !G->Visited[a->vname] ) {
            DFS( G, a->vname );
        }
        a = a->Next;
    }
}
void enQueue( Queue q, int u ) {
    if( (q->rear+1) % MaxVertexNum == q->front ) {
        printf("IsFull");
        return;
    }
    q->rear = ( q->rear+1 ) % MaxVertexNum;
    q->Array[q->rear] = u;
}
int deQueue( Queue q ) {
    if( q->front == q->rear ) {
        printf("IsEmpty");
        return 1314521;
    }

    q->front = ( q->front+1 ) % MaxVertexNum;

    return q->Array[q->front];
}
Queue createQueue() {
    Queue q = ( Queue )malloc( sizeof(struct QueueStruct) );
    if( !q ) {
        printfError();
    }

    initializeQueue( q );

    return q;
}
void initializeQueue( Queue q ) {
    q->capacity = MaxVertexNum-1;
    q->front = q->rear = 0;
}