邻接表DFS&&BFS

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

#define MaxVertexNodeNumSize 1000
#define MaxVertexNodeNameSize 100

struct VertexBodyNode
{
    char VertexName[MaxVertexNodeNameSize];
    int ArcWeight;
    int VertexIndex;
    struct VertexBodyNode *Next;
};

struct VertexHeadNode
{
    char VertexName[MaxVertexNodeNameSize];
    int VertexWeight;
    struct VertexBodyNode *Next;
};

struct _Graph
{
    struct VertexHeadNode VertexHeadNodeList[MaxVertexNodeNumSize];
    int ArcNum,VertexNum;
};

//Real capacity is CircularQueueMaxSize -1
#define CircularQueueMaxSize 1000

typedef int ElementType;

struct CircularQueue
{
    ElementType QueueData[CircularQueueMaxSize];
    int Front;
    int Rear;
};

int CircularQueueIsEmpty(struct CircularQueue *Queue)
{
    return (Queue -> Front == Queue -> Rear);
}

int CircularQueueIsFull(struct CircularQueue *Queue)
{
    return ((Queue -> Rear + 1) % CircularQueueMaxSize == Queue -> Front);
}

struct CircularQueue *CircularQueueInit()
{
    struct CircularQueue *Queue;
    Queue = malloc(sizeof(struct CircularQueue));
    
    Queue -> Front = Queue -> Rear = 0;
    
    return Queue;
}

//if Queue is full,return 1 
int CircularQueueEnqueue(struct CircularQueue *Queue,ElementType ToBeEnqueue)
{
    if(CircularQueueIsFull(Queue))
    {
        return 1;
    }
    else
    {
        Queue -> Rear = (Queue -> Rear + 1) % CircularQueueMaxSize;
        Queue -> QueueData[Queue -> Rear] = ToBeEnqueue;
    }
    return 0;
}

//if Queue is empty,return 1 
ElementType CircularQueueTop(struct CircularQueue *Queue)
{
    if(CircularQueueIsEmpty(Queue))
    {
        return ;
    }
    else
    {
        return Queue -> QueueData[(Queue -> Front + 1) % CircularQueueMaxSize];
    }
    return ;
}

//if Queue is empty,return 1 
int CircularQueueDequeue(struct CircularQueue *Queue)
{
    if(CircularQueueIsEmpty(Queue))
    {
        return 1;
    }
    else
    {
        Queue -> Front = (Queue -> Front + 1) % CircularQueueMaxSize;
        return 0;
    }
}

int MakeCircularQueueEmpty(struct CircularQueue *Queue)
{
    Queue -> Front = Queue -> Rear = 0;
    
    return 0;
}

int CircularQueueDelete(struct CircularQueue *Queue)
{
    free(Queue);
    Queue = NULL;
    return 0;
}

int VertexName2Index(struct _Graph *UnsignedGraph,char *VName)
{
    int i;
    for(i = 0; i < UnsignedGraph -> VertexNum; i ++)
    {
        if(strcmp(UnsignedGraph -> VertexHeadNodeList[i].VertexName,VName)==0)
        {
            return i;
        }
    }
    return -1;
}

void AddOneArc(struct _Graph *UnsignedGraph,int ArcIndex_1,int ArcIndex_2,int AWeight)
{
    struct VertexBodyNode *BNode_1 = malloc(sizeof(struct VertexBodyNode));
    struct VertexBodyNode *BNode_2 = malloc(sizeof(struct VertexBodyNode));

    strcpy(BNode_1 -> VertexName,UnsignedGraph -> VertexHeadNodeList[ArcIndex_1].VertexName);
    strcpy(BNode_2 -> VertexName,UnsignedGraph -> VertexHeadNodeList[ArcIndex_2].VertexName);
    BNode_1 -> ArcWeight = AWeight;
    BNode_2 -> ArcWeight = AWeight;
    BNode_1 -> VertexIndex = ArcIndex_1;
    BNode_2 -> VertexIndex = ArcIndex_2;
    BNode_1 -> Next = BNode_2 -> Next = NULL;

    struct VertexBodyNode *TmpPointer;
    TmpPointer = UnsignedGraph -> VertexHeadNodeList[ArcIndex_1].Next;
    while(TmpPointer != NULL && TmpPointer -> Next != NULL)
    {
        TmpPointer = TmpPointer -> Next;
    }
    if(TmpPointer==NULL)
    {
        UnsignedGraph -> VertexHeadNodeList[ArcIndex_1].Next = BNode_2;
    }
    else
    {
        TmpPointer -> Next = BNode_2;
    }

    TmpPointer = UnsignedGraph -> VertexHeadNodeList[ArcIndex_2].Next;
    while(TmpPointer != NULL && TmpPointer -> Next != NULL)
    {
        TmpPointer = TmpPointer -> Next;
    }
    if(TmpPointer==NULL)
    {
        UnsignedGraph -> VertexHeadNodeList[ArcIndex_2].Next = BNode_1;
    }
    else
    {
        TmpPointer -> Next = BNode_1;
    }
}

struct _Graph *UGCreat(int ArcSum,int VertexSum)
{
    int i,j;
    struct _Graph *UnsignedGraph = malloc(sizeof(struct _Graph));
    UnsignedGraph -> ArcNum = ArcSum;
    UnsignedGraph -> VertexNum = VertexSum;

    for(i = 0; i < VertexSum; i ++)
    {
        scanf("%s %d",UnsignedGraph -> VertexHeadNodeList[i].VertexName,&UnsignedGraph -> VertexHeadNodeList[i].VertexWeight);
    }

    for(i = 0; i < VertexSum; i ++)
    {
        UnsignedGraph -> VertexHeadNodeList[i].Next = NULL;
    }

    for(i = 0; i < ArcSum; i ++)
    {
        char Arc_1[MaxVertexNodeNameSize];
        char Arc_2[MaxVertexNodeNameSize];
        int ArcIndex_1;
        int ArcIndex_2;
        int ArcWeight;

        scanf("%s %s %d",Arc_1,Arc_2,&ArcWeight);

        ArcIndex_1 = VertexName2Index(UnsignedGraph,Arc_1);
        ArcIndex_2 = VertexName2Index(UnsignedGraph,Arc_2);

        AddOneArc(UnsignedGraph,ArcIndex_1,ArcIndex_2,ArcWeight);
    }
    return UnsignedGraph;
}

void Travel(struct _Graph *UnsignedGraph)
{
    char StartingPoint[MaxVertexNodeNameSize];
    char OverPoint[MaxVertexNodeNameSize];

    printf("Input start and over
");
    scanf("%s %s",StartingPoint,OverPoint);

    int StartIndex = VertexName2Index(UnsignedGraph,StartingPoint);
    int OverIndex = VertexName2Index(UnsignedGraph,OverPoint);

    struct VertexBodyNode *TmpPointer;
    TmpPointer = UnsignedGraph -> VertexHeadNodeList[StartIndex].Next;
    while(TmpPointer != NULL && TmpPointer -> Next != NULL)
    {
        if(OverIndex==TmpPointer -> VertexIndex)
        {
            printf("Distance:%d GetVertexPointSum:%d",TmpPointer->ArcWeight
                   ,UnsignedGraph -> VertexHeadNodeList[StartIndex].VertexWeight+UnsignedGraph -> VertexHeadNodeList[OverIndex].VertexWeight);
            break;
        }
        else
        {
            TmpPointer = TmpPointer -> Next;
        }
    }
}

void _UGDFS(struct _Graph *UnsignedGraph,int *Visit,int Index)
{
    Visit[Index] = 1;
//    printf("%s %d    ",UnsignedGraph -> VertexHeadNodeList[Index].VertexName,UnsignedGraph -> VertexHeadNodeList[Index].VertexWeight);
    
    struct VertexBodyNode *TmpPointer = UnsignedGraph -> VertexHeadNodeList[Index].Next;
    while(TmpPointer)
    {
        if(!Visit[TmpPointer->VertexIndex])
        {
            printf("%s->%s
",UnsignedGraph -> VertexHeadNodeList[Index].VertexName,UnsignedGraph -> VertexHeadNodeList[TmpPointer->VertexIndex].VertexName);
            _UGDFS(UnsignedGraph,Visit,TmpPointer->VertexIndex);
        }
        TmpPointer = TmpPointer -> Next;
    }
}

void UnsignedGraphDFS(struct _Graph *UnsignedGraph)
{
    int Visit[UnsignedGraph->VertexNum];
    memset(Visit,0,sizeof(Visit));

    int i;
    for(i = 0;i < UnsignedGraph->VertexNum;i ++)
    {
        if(!Visit[i])
        {
            _UGDFS(UnsignedGraph,Visit,i);
        }
    }
}

void UnsignedGraphBFS(struct _Graph *UnsignedGraph)
{
    int Visit[UnsignedGraph->VertexNum];
    memset(Visit,0,sizeof(Visit));
    
    struct CircularQueue *Queue;
    Queue = CircularQueueInit();
    
    int i;
    for(i = 0;i < UnsignedGraph->VertexNum;i ++)
    {
        if(!Visit[i])
        {
            Visit[i] = 1;
            //printf("%s %d    ",UnsignedGraph -> VertexHeadNodeList[i].VertexName,UnsignedGraph -> VertexHeadNodeList[i].VertexWeight);
            CircularQueueEnqueue(Queue,i);
            
            while(!CircularQueueIsEmpty(Queue))
            {
                int TmpIndex = CircularQueueTop(Queue);
                CircularQueueDequeue(Queue);
                struct VertexBodyNode *TmpPointer = UnsignedGraph -> VertexHeadNodeList[TmpIndex].Next;
                
                while(TmpPointer)
                {
                    if(!Visit[TmpPointer->VertexIndex])
                    {
                        Visit[TmpPointer->VertexIndex] = 1;
                    //    printf("%s %d    ",UnsignedGraph -> VertexHeadNodeList[TmpPointer->VertexIndex].VertexName,UnsignedGraph -> VertexHeadNodeList[TmpPointer->VertexIndex].VertexWeight);
                        printf("%s->%s
",UnsignedGraph -> VertexHeadNodeList[TmpIndex].VertexName,UnsignedGraph -> VertexHeadNodeList[TmpPointer->VertexIndex].VertexName);
                        CircularQueueEnqueue(Queue,TmpPointer->VertexIndex);
                    }
                    TmpPointer = TmpPointer -> Next;
                }
            } 
        }
    }
}

int main()
{
    struct _Graph *G = UGCreat(8,5);

    //Travel(G);
    printf("
DFS:
");
    UnsignedGraphDFS(G);
    printf("
BFS:
");
    UnsignedGraphBFS(G);
    return 0;
}

/*
        beijing 18
        zhengzhou 10
        hefei 9
        nanjing 12
        guangzhou 14
        beijing zhengzhou 7
        beijing hefei 9
        beijing nanjing 8
        zhengzhou hefei 5
        hefei nanjing 3
        zhengzhou guangzhou 7
        hefei guangzhou 8
        nanjing guangzhou 6
*/