数据结构5.1 有向图的邻接矩阵实现,BFS,DFS

C语言实现

昨天发了一个使用邻接表实现的有向图与无向图. 今天补上一个邻接矩阵实现的有向图与无向图. 这个比起邻接表真的是简单太多了.
代码如下:

//
//  Direct_Graph_AdjMatrix.c
//  Data_structure
//
//  Created by 양송 on 2020/06/05.
//  Copyright © 2020 양송. All rights reserved.
//

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

#define MAX_SIZE 5
#define Queue_Size 20
int Matrix[MAX_SIZE][MAX_SIZE];
char Queue[Queue_Size];
int front = 0;
int rear = 0;
void enQ(char vertex)
{
    if(front == Queue_Size)
    {
        printf("Queue is full\n");
    }
    else
    {
        Queue[front++] = vertex;
    }
}

char deQ()
{
    if(front == rear)
    {
        printf("Queue is empty\n");
        return '-1';
    }
    else
    {
        return Queue[rear++];
    }
}
void Matrix_Init()
{
    memset(Matrix,0,sizeof(int)*MAX_SIZE);
    memset(Queue,'0',sizeof(char)*Queue_Size);
}

int return_index(char vertex_info)
{
    return vertex_info - 'A';
}

void Create_Graph_Direct(char vertex_info, char dest_info)
{
    int vertex = return_index(vertex_info);
    int dest = return_index(dest_info);
    
    Matrix[vertex][dest] = 1;
}


void Create_Graph_Undirect(char vertex_info, char dest_info)
{
    int vertex = return_index(vertex_info);
    int dest = return_index(dest_info);
    
    Matrix[vertex][dest] = 1;
    Matrix[dest][vertex] = 1;
}
void print_matrix()
{
    for(int i = 0; i< MAX_SIZE;i++)
    {
        for(int j = 0; j< MAX_SIZE;j++)
        {
            printf("%d ",Matrix[i][j]);
        }
        printf("\n");
    }
}

void Show_Connect_Vertex(char vertex)
{
    int start_postion = return_index(vertex);
    
    printf("%c->",vertex);
    for(int i = 0; i< MAX_SIZE;i++)
    {
        if(Matrix[start_postion][i] == 1)
            printf("%c-> ", i+'A');
    }
    printf("NULL\n");
}

char Visited[MAX_SIZE];

int In_Visited(char vertex)
{
    for(int i = 0; i< MAX_SIZE;i++)
    {
        if(Visited[i] == vertex)
            return 1;
    }
    return 0;
}
void DFS(char vertex)
{
    int start_position = return_index(vertex);
    int temp = 0;
    int index = 0;
    printf("DFS start form %c->",vertex);
    Visited[index] = vertex;
    index++;
    for(int i = 0; i< MAX_SIZE;i++)
    {
        for(int j = 0; j< MAX_SIZE;j++)
        {
            if(Matrix[start_position][j] == 1)
            {
                if((In_Visited( j + 'A')) == 0)
                {
                    printf("%c-> ",j+'A');
                    Visited[index] = j+'A';
                    index++;
                    temp = j;
                    break;
                }
            }
        }
        start_position = temp;
    }
    printf("NULL\n");
    memset(Visited, '0', sizeof(char)*MAX_SIZE);
}

void BFS(char vertex)
{
    int index = 0;
    enQ(vertex);
    printf("BFS start form %c->",vertex);
    Visited[index] = vertex;
    index++;
    while(front != rear)
    {
        char p = deQ();
        int ind = return_index(p);
        for(int i = 0; i< MAX_SIZE;i++)
        {
            if(Matrix[ind][i] == 1)
            {
                if((In_Visited(i+'A')) == 0)
                {
                    printf("%c->", i+'A');
                    Visited[index] = i+'A';
                    index++;
                    enQ(i + 'A');
                }
            }
        }
    }
    memset(Visited, '0', sizeof(char)*MAX_SIZE);
    memset(Queue, '0', sizeof(char)*Queue_Size);
    printf("NULL\n");
}

int main()
{
    //有向图
   Matrix_Init();
    Create_Graph_Direct('A', 'B');
    Create_Graph_Direct('A', 'D');
    Create_Graph_Direct('B', 'C');
    Create_Graph_Direct('C', 'D');
    Create_Graph_Direct('D', 'E');
    Create_Graph_Direct('E', 'A');
    
    print_matrix();
    
    Show_Connect_Vertex('A');
    Show_Connect_Vertex('B');
    Show_Connect_Vertex('C');
    Show_Connect_Vertex('D');
    Show_Connect_Vertex('E');
    
    DFS('A');
    BFS('A');
    
    //无向图
    /*Matrix_Init();
    Create_Graph_Undirect('A', 'B');
    Create_Graph_Undirect('A', 'D');
    Create_Graph_Undirect('A', 'E');
    Create_Graph_Undirect('B', 'C');
    Create_Graph_Undirect('C', 'D');
    Create_Graph_Undirect('D', 'E');
    
    print_matrix();
    DFS('A');
    BFS('A');*/
    
    
}