图的概念与实现

图是由顶点的有穷非空集合和顶点之间边的集合组成，所以，图不允许没有顶点。可以有空表，空树，但是没有空图。

图分有向图和无向图。无向图油顶点和边构成，有向图油顶点和狐构成。弧有弧头和弧尾。

图按照边或弧的多少分希疏图和稠密图。如果任意两个顶点之间都存在边叫完全图，有向的叫有向完全图。若无重复的边或顶点到自身的边则叫简单图。

无向图顶点的边数叫度，有向图顶点分为入度和出度。图上的边或弧带权叫网。

图中顶点间存在路径，两顶点存在路径则说明是连通的，如果路径最终回到起始点则称为环，当中不重复叫简单路径。若任意两点间都是连通的，则图就是连通图，有向则称为强连通图。图中有子图，若子图极大连通则就是连通分量，有向的则称强连通分量。

无向图中连通且n个顶点n-1条边叫生成树。有向图中一顶点入读为0其余顶点入度为1的叫有向树。一个有向图由若干棵有向树构成生成森林。

/*图的实现*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "Queue.h"

#define OK 1
#define ERROR 0
typedef int Status;

typedef char VertexType;
typedef int EdgeType;
#define MAXVEX 100
#define INFINITY 65535

/*邻接矩阵*/
typedef struct
{
    VertexType vex[MAXVEX];
    EdgeType arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
}MGraph;

void CreateMGraph(MGraph *G)
{
    int i, j, k, w;
    char tmp;
    tmp = getchar();
    printf("Input ver and edg :");
    scanf("%d %d", &G->numVertexes, &G->numEdges);
    tmp = getchar();
    for (i = 0; i < G->numVertexes; i++)
    {
        printf("Input vertex :");
        //scanf(&G->vex[i]);
        char s = getchar();
        G->vex[i] = s;
        tmp = getchar();
    }
    for(i=0;i<G->numEdges;i++)
        for (j = 0; j < G->numEdges; j++)
        {
            G->arc[i][j] = INFINITY;
        }
    for (k = 0; k < G->numEdges; k++)
    {
        printf("Input ver1 and ver2 and w:");
        scanf("%d %d %d", &i, &j, &w);
        tmp = getchar();
        G->arc[i][j] = w;
        G->arc[j][i] = G->arc[i][j];
    }
}
/*邻接表*/
typedef struct EdgeNode
{
    int adjvex;
    EdgeType weight;
    struct EdgeNode * next;
}EdgeNode;
typedef struct VertexNode
{
    VertexType data;
    EdgeNode *firstedge;
}VertexNode, AdjList[MAXVEX];
typedef struct
{
    AdjList adjList;
    int numVertexes, numEdges;
}GraphAdjList;
void CreateALGraph(GraphAdjList *G)
{
    int i, j, k;
    EdgeNode *e;
    char tmp;
    printf("Input ver and edg :");
    scanf("%d %d", &G->numVertexes, &G->numEdges);
    tmp = getchar();
    for (i = 0; i < G->numVertexes; i++)
    {
        printf("Input vertex :");
        //scanf("%c",&G->adjList[i].data);
        char s;
        s = getchar();
        tmp = getchar();
        G->adjList[i].data = s;
        G->adjList[i].firstedge = NULL;
    }
    for (k = 0; k < G->numEdges; k++)
    {
        printf("Input ver1 and ver2:");
        scanf("%d %d", &i, &j);
        tmp = getchar();
        e = (EdgeNode*)malloc(sizeof(EdgeNode));
        e->adjvex = j;

        e->next = G->adjList[i].firstedge;
        G->adjList[i].firstedge = e;
        e = (EdgeNode*)malloc(sizeof(EdgeNode));
        e->adjvex = i;
        e->next = G->adjList[j].firstedge;
        G->adjList[j].firstedge = e;
    }
}
/*邻接矩阵的深度优先遍历*/
typedef int Boolean;
Boolean visited[MAXVEX];
void DFSM(MGraph G, int i)
{
    int j;
    visited[i] = true;
    printf("%c ", G.vex[i]);
    for (j = 0; j < G.numVertexes; j++)
    {
        if (G.arc[i][j] == 1 && !visited[j])
            DFSM(G, j);
    }
}
void DFSMTraverse(MGraph G)
{
    int i;
    for (i = 0; i < G.numVertexes; i++)
        visited[i] = false;
    for (i = 0; i < G.numVertexes; i++)
        if (!visited[i])
            DFSM(G, i);
}
/*邻接表的深度优先遍历，递归算法*/
void DFSAL(GraphAdjList G, int i)
{
    EdgeNode* p;
    visited[i] = true;
    printf("%c ", G.adjList[i].data);
    p = G.adjList[i].firstedge;
    while (p)
    {
        if (!visited[p->adjvex])
            DFSAL(G, p->adjvex);
        p = p->next;
    }
}
void DFSALTraverse(GraphAdjList G)
{
    int i;
    for (i = 0; i < G.numVertexes; i++)
        visited[i] = false;
    for (i = 0; i < G.numVertexes; i++)
        if (!visited[i])
            DFSAL(G, i);
}
/*邻接矩阵的广度优先遍历*/
void BFSMTraverse(MGraph G)
{
    int i, j;
    SqQueue Q;
    for (i = 0; i < G.numVertexes; i++)
        visited[i] = false;
    InitQueue(&Q);
    for (i = 0; i < G.numVertexes; i++)
    {
        if (!visited[i])
        {
            visited[i] = true;
            printf("%c ", G.vex[i]);
            EnQueue(&Q, i);
            while(!QueueEmpty(Q))
            {
                DeQueue(&Q, &i);
                for (j = 0; j < G.numVertexes; j++)
                {
                    if (G.arc[i][j] == 1 && !visited[j])
                    {
                        visited[j] = true;
                        printf("%c ", G.vex[j]);
                        EnQueue(&Q, j);
                    }
                }
            }
        }
    }
}
/*邻接表的广度优先遍历*/
void BFSALTraverse(GraphAdjList G)
{
    int i;
    EdgeNode *p;
    SqQueue Q;
    for (i = 0; i < G.numVertexes; i++)
        visited[i] = false;
    InitQueue(&Q);
    for (i = 0; i < G.numVertexes; i++)
    {
        if (!visited[i])
        {
            visited[i] = true;
            printf("%c ", G.adjList[i].data);
            EnQueue(&Q, i);
            while (!QueueEmpty(Q))
            {
                DeQueue(&Q, &i);
                p = G.adjList[i].firstedge;
                while(p)
                {
                    if (!visited[p->adjvex])
                    {
                        visited[p->adjvex] = true;
                        printf("%c ", G.adjList[p->adjvex].data);
                        EnQueue(&Q, p->adjvex);
                    }
                    p = p->next;
                }
            }
        }
    }
}
int main()
{
    MGraph T;
    GraphAdjList G;
    char opp = '-1';

    printf("\n1.创建邻接矩阵图 \n2.创建邻接表图  \n3.深度遍历邻接矩阵 \n4.深度遍历邻接表 \n5 广度遍历邻接矩阵 \n6 广度遍历邻接表 \n0 退出 \n请选择你的操作：\n");

    while (opp != '0') {
        opp = getchar();
        switch (opp) {
        case '1':
            CreateMGraph(&T);
            printf("create finish!\n");
            break;
        case '2':
            CreateALGraph(&G);
            printf("create finish!\n");
            break;
        case '3':
            DFSMTraverse(T);
            printf("\n");
            break;
        case '4':
            DFSALTraverse(G);
            printf("\n");
            break;
        case '5':
            BFSMTraverse(T);
            printf("\n");
            break;
        case '6':
            BFSALTraverse(G);
            printf("\n");
            break;
        case '0':
            exit(0);
        }
    }
}