领接表的基本操作（以任意结点为开始结点，含拓扑排序）

最新推荐文章于 2022-12-31 09:48:18 发布

M DownTime

最新推荐文章于 2022-12-31 09:48:18 发布

阅读量367

点赞数

文章标签：算法 c++ 开发语言

本文链接：https://blog.csdn.net/qq_43346784/article/details/128426679

版权

11 建队列，进队列，退出队列，判空队列，求队首元素（为BFS准备）

0.功能区

    printf("0.退出\n");
    printf("1.建立一个有向图\n");
    printf("2.建立一个无向图\n");
    printf("3.打印邻接表的样式\n");
    printf("4.深度优先遍历\n");
    printf("5.广度优先遍历\n");
    printf("6.拓扑排序判断是否为有向无环图\n");

1.预处理区

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

#define Stack_Init_Size 100
#define max 100
typedef struct ArcNode
{
    int adjvex;
    struct ArcNode *nextarc;
    char *Info;
}ArcNode;
typedef struct VNode
{
    int in;
    char data;
    ArcNode *firstarc;
}Vode,AdjList[max];
typedef struct
{
    AdjList vertices;
    int vexnum,arcnum;
    int kind; //无用;
}ALGraph;
typedef struct{
    int rear;
    int front;
    int *base;
    int maxsize;
}SqQueue;
typedef struct
{
    int *base;
    int *top;
    int stacksize;    
}SqStack;

2 函数声明区

int Locate(ALGraph G,char v);//定位函数
void CreatALGraphYouXiang(ALGraph &G);
void CreatALGraphWuXiang(ALGraph &G);
void showLinJieBiao(ALGraph G);
int FirstAdjVex(ALGraph G,char v);
int NextAdjVex(ALGraph G,char v,char w);
void DFS(ALGraph G,int v,int V[]);
void DFSTraverse(ALGraph G,int V[]);
void InitQueue(SqQueue &Q,ALGraph G);
void EnQueue(SqQueue &Q,int v);
void DeQueue(SqQueue &Q,int &v);
int IsNullQueue(SqQueue Q);
int firstqueue(SqQueue Q);
void IsNullGraph(int flag);
void BFS(ALGraph G,int v,SqQueue Q,int V[]);
void BFSTraverse(ALGraph G,SqQueue Q,int V[]);
void InitStack(SqStack &S);
void Push(SqStack &S,int e);
int Pop(SqStack &S,int *e);
int IsNullStack(SqStack S);
void TopologicalSort(ALGraph G);
void pro();
void switchs(ALGraph G,SqQueue Q,int V[]);

3 建栈，进栈，弹栈，判断栈空

void InitStack(SqStack &S)
{
    //建栈
    S.base=(int*)malloc(Stack_Init_Size*sizeof(int));
    S.top=S.base;
    S.stacksize=Stack_Init_Size;
}

void Push(SqStack &S,int e)
{
    *S.top++=e;
}

int Pop(SqStack &S,int *e)
{   
    //弹栈，并且返回出弹栈元素
    *e=*--S.top;
}

int IsNullStack(SqStack S)
{
    //判断栈是否为空
    if(S.base==S.top||S.base==NULL)
        return 1;
    else 
        return 0;
}

4 定位函数

int Locate(ALGraph G,char v)//定位函数
{
    int i;
    for(i=0;i<G.vexnum;i++)
    {
        if(v==G.vertices[i].data)
            return i;
    }
    return -1;
}

5 建立邻接表函数(有向图)

void CreatALGraphYouXiang(ALGraph &G)
{
    int i;
    printf("请输入邻接表顶点的个数和边的个数\n");
    scanf("%d%d",&G.vexnum,&G.arcnum);
    getchar();
    printf("请输入邻接表顶点入度和顶点\n");
    for(i=0;i<G.vexnum;i++)
    {
        
        scanf("%d %c",&G.vertices[i].in,&G.vertices[i].data);
        getchar();
        G.vertices[i].firstarc=NULL;
    }
    printf("请输入两个顶点，即两个得关系\n");
    for(i=0;i<G.arcnum;i++)
    {
        char v1,v2;
        scanf("%c %c",&v1,&v2);
        getchar();
        int l1=Locate(G,v1);
        int l2=Locate(G,v2);
        ArcNode *p1=(ArcNode *)malloc(sizeof(ArcNode));
        p1->adjvex=l2;
        p1->nextarc=G.vertices[l1].firstarc;
        G.vertices[l1].firstarc=p1;
    }
}

6 建立无向图

void CreatALGraphWuXiang(ALGraph &G)
{
    int i;
    printf("请输入邻接表顶点的个数和边的个数\n");
    scanf("%d%d",&G.vexnum,&G.arcnum);
    getchar();
    printf("请输入邻接表的全部顶点\n");
    for(i=0;i<G.vexnum;i++)
    {
        
        scanf("%c",&G.vertices[i].data);
        getchar();
        G.vertices[i].firstarc=NULL;
    }
    printf("请输入两个顶点，即两个得关系\n");
    for(i=0;i<G.arcnum;i++)
    {
        char v1,v2;
        scanf("%c %c",&v1,&v2);
        getchar();
        int l1=Locate(G,v1);
        int l2=Locate(G,v2);
        ArcNode *p1=(ArcNode *)malloc(sizeof(ArcNode));
        p1->adjvex=l2;
        p1->nextarc=G.vertices[l1].firstarc;
        G.vertices[l1].firstarc=p1;
        ArcNode *p2=(ArcNode *)malloc(sizeof(ArcNode));
        p2->adjvex=l1;
        p2->nextarc=G.vertices[l2].firstarc;
        G.vertices[l2].firstarc=p2;
    }
}

7 展示领接表函数

void showLinJieBiao(ALGraph G)
{
    int i;
    ArcNode *p;
    for(i=0;i<G.vexnum;i++)
    {
        printf("%c ",G.vertices[i].data);
        p=G.vertices[i].firstarc;
        while(p)
        {
            printf(" -> %c",G.vertices[p->adjvex].data);
            p=p->nextarc;
        }
        printf(" -> NULL ");
        printf("\n");
    }
}

8元素v对应的第一个邻接点

int FirstAdjVex(ALGraph G,char v)
{
    int num;
    num=Locate(G,v);
    if(num==-1)
    {
        printf("没有邻接点\n");
        return -1;
    }
    if(G.vertices[num].firstarc==NULL)
    {
        printf("没有邻接点\n");
        return -1;
    }
    return G.vertices[num].firstarc->adjvex;
}

9 返回G中顶点v相对于u的下一邻接点

int NextAdjVex(ALGraph G,char v,char w)
{
    int num = Locate(G,v);
    int num2 = Locate(G,w);
    if(num==-1)
        return -1;
    else{
        ArcNode *p = G.vertices[num].firstarc;
        while(p!=NULL&&p->adjvex!=num2)
        {
            p=p->nextarc;
        }
        if(p->nextarc==NULL)
        {
            printf("G中顶点%c相对于%c的下一邻接点\n",G.vertices[num].data,G.vertices[num2].data);
            return -1;
        }
    }
}

10 DFS

void DFS(ALGraph G,int v,int V[])
{
    int i,j;
    printf("%c",G.vertices[v].data);
    V[v]=1;
    ArcNode *p=G.vertices[v].firstarc;
    while(p)
    {
        v=p->adjvex;
        if(!V[v])
            DFS(G,v,V);
        p=p->nextarc;
    }
}

void DFSTraverse(ALGraph G,int V[])
{
    printf("请输入起点元素\n");
    int m1,i;
    char v1;
     fflush(stdin);
    scanf("%c",&v1);
    m1=Locate(G,v1);
    for(i=0;i<G.vexnum;i++)
    {
        V[i]=0;
    }
        DFS(G,m1,V);
    for(i=0;i<G.vexnum;i++)
    {
        if(V[i]==0)
            DFS(G,i,V);
    }
}

11 建队列，进队列，退出队列，判空队列，求队首元素（为BFS准备）

//建队列
void InitQueue(SqQueue &Q,ALGraph G)
{
    Q.base=(int *)malloc(G.vexnum*sizeof(int));
    Q.front=Q.rear=0;
    Q.maxsize=G.vexnum;
}

//进队列
void EnQueue(SqQueue &Q,int v)
{
    Q.base[Q.rear]=v;
    Q.rear = (Q.rear+1)%Q.maxsize;
}

//退出队列
void DeQueue(SqQueue &Q,int &v)
{
    v=Q.base[Q.front];
    Q.front=(Q.front+1)%Q.maxsize;
}

int IsNullQueue(SqQueue Q)
{
    if(Q.front==Q.rear)
        return 1;
    else 
        return 0;
}

int firstqueue(SqQueue Q)
{
    return Q.base[Q.front];
}

12 判断图空

int firstqueue(SqQueue Q)
{
    return Q.base[Q.front];
}

13 BFS操作

void BFS(ALGraph G,int v,SqQueue Q,int V[])
{
    int i,j;
    ArcNode *p;
    printf("%c",G.vertices[v].data);
    V[v]=1;
    EnQueue(Q,v);
    while(!IsNullQueue(Q))
    {
        //j=firstqueue(Q);
        DeQueue(Q,v);
        p=G.vertices[v].firstarc;
        while(p!=NULL)
        {
            if(V[p->adjvex]==0)
            {
                printf("%c",G.vertices[p->adjvex].data);
                V[p->adjvex]=1;
                EnQueue(Q,p->adjvex);
                
            }
            p=p->nextarc;
        }
    }
}

void BFSTraverse(ALGraph G,SqQueue Q,int V[])
{
    int i,v;char v1;
    for(i=0;i<G.vexnum;i++)
        V[i]=0;
    fflush(stdin);
    printf("请输入起点顶点\n");
    scanf("%c",&v1);
    v=Locate(G,v1);
    BFS(G,v,Q,V);
    for(i=0;i<G.vexnum;i++)
    {
        if(V[i]==0)
            BFS(G,i,Q,V);
    }
}

14 拓扑排序


void TopologicalSort(ALGraph G)
{
    SqStack S;
    int i,count,k;
    ArcNode *p;
    InitStack(S);
    for(i=0;i<G.vexnum;i++)
    {
        if(G.vertices[i].in==0)
            Push(S,i);
    }
    count = 0;
    while(!IsNullStack(S))
    {
        Pop(S,&i);
        printf("%d,%c",i,G.vertices[i].data);
        ++count;
        for(p=G.vertices[i].firstarc;p;p=p->nextarc)
        {
            k=p->adjvex;
            if(!(--G.vertices[k].in))
            Push(S,k);
        }
        
    }
    if(count<G.vexnum)
            printf("此图不是有向无环图\n");
        else
            printf("此图是有向无环图\n");
}

15 Switch

void pro()
{
    printf("0.退出\n");
    printf("1.建立一个有向图\n");
    printf("2.建立一个无向图\n");
    printf("3.打印邻接表的样式\n");
    printf("4.深度优先遍历\n");
    printf("5.广度优先遍历\n");
    printf("6.拓扑排序判断是否为有向无环图\n");
}

void switchs(ALGraph G,SqQueue Q,int V[])
{
    int num;
    pro();
    printf("请输入功能数字\n");
    scanf("%d",&num);
    while(num)
    {
        switch(num)
        {
            case 0:
                num=0;
                break;
            case 1:
                CreatALGraphYouXiang(G);
            break;
            case 2:
                CreatALGraphWuXiang(G);
            break;
            case 3:
                showLinJieBiao(G);
            break;
            case 4:
                DFSTraverse(G,V);
            break;
            case 5:
                BFSTraverse(G,Q,V);
            break;
            case 6:
                TopologicalSort(G);
            break;
            default:
                printf("输入错误请重新输入\n");
        }
            printf("\n\n");
            pro();
            printf("请输入功能数字\n");
            scanf("%d",&num);
    }
}

//主函数
int main()
{
    ALGraph G;
    SqQueue Q;
    InitQueue(Q,G);
    int V[20];
    switchs(G,Q,V);
}

16 全部代码

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

#define Stack_Init_Size 100
#define max 100
typedef struct ArcNode
{
    int adjvex;
    struct ArcNode *nextarc;
    char *Info;
}ArcNode;
typedef struct VNode
{
    int in;
    char data;
    ArcNode *firstarc;
}Vode,AdjList[max];
typedef struct
{
    AdjList vertices;
    int vexnum,arcnum;
    int kind; //无用;
}ALGraph;
typedef struct{
    int rear;
    int front;
    int *base;
    int maxsize;
}SqQueue;
typedef struct
{
    int *base;
    int *top;
    int stacksize;    
}SqStack;

int Locate(ALGraph G,char v);//定位函数
void CreatALGraphYouXiang(ALGraph &G);
void CreatALGraphWuXiang(ALGraph &G);
void showLinJieBiao(ALGraph G);
int FirstAdjVex(ALGraph G,char v);
int NextAdjVex(ALGraph G,char v,char w);
void DFS(ALGraph G,int v,int V[]);
void DFSTraverse(ALGraph G,int V[]);
void InitQueue(SqQueue &Q,ALGraph G);
void EnQueue(SqQueue &Q,int v);
void DeQueue(SqQueue &Q,int &v);
int IsNullQueue(SqQueue Q);
int firstqueue(SqQueue Q);
void IsNullGraph(int flag);
void BFS(ALGraph G,int v,SqQueue Q,int V[]);
void BFSTraverse(ALGraph G,SqQueue Q,int V[]);
void InitStack(SqStack &S);
void Push(SqStack &S,int e);
int Pop(SqStack &S,int *e);
int IsNullStack(SqStack S);
void TopologicalSort(ALGraph G);
void pro();
void switchs(ALGraph G,SqQueue Q,int V[]);

void InitStack(SqStack &S)
{
    //建栈
    S.base=(int*)malloc(Stack_Init_Size*sizeof(int));
    S.top=S.base;
    S.stacksize=Stack_Init_Size;
}

void Push(SqStack &S,int e)
{
    *S.top++=e;
}

int Pop(SqStack &S,int *e)
{   
    //弹栈，并且返回出弹栈元素
    *e=*--S.top;
}

int IsNullStack(SqStack S)
{
    //判断栈是否为空
    if(S.base==S.top||S.base==NULL)
        return 1;
    else 
        return 0;
}

int Locate(ALGraph G,char v)//定位函数
{
    int i;
    for(i=0;i<G.vexnum;i++)
    {
        if(v==G.vertices[i].data)
            return i;
    }
    return -1;
}

//建立邻接表函数(有向图)
void CreatALGraphYouXiang(ALGraph &G)
{
    int i;
    printf("请输入邻接表顶点的个数和边的个数\n");
    scanf("%d%d",&G.vexnum,&G.arcnum);
    getchar();
    printf("请输入邻接表顶点入度和顶点\n");
    for(i=0;i<G.vexnum;i++)
    {
        
        scanf("%d %c",&G.vertices[i].in,&G.vertices[i].data);
        getchar();
        G.vertices[i].firstarc=NULL;
    }
    printf("请输入两个顶点，即两个得关系\n");
    for(i=0;i<G.arcnum;i++)
    {
        char v1,v2;
        scanf("%c %c",&v1,&v2);
        getchar();
        int l1=Locate(G,v1);
        int l2=Locate(G,v2);
        ArcNode *p1=(ArcNode *)malloc(sizeof(ArcNode));
        p1->adjvex=l2;
        p1->nextarc=G.vertices[l1].firstarc;
        G.vertices[l1].firstarc=p1;
    }
}

//建立无向图
void CreatALGraphWuXiang(ALGraph &G)
{
    int i;
    printf("请输入邻接表顶点的个数和边的个数\n");
    scanf("%d%d",&G.vexnum,&G.arcnum);
    getchar();
    printf("请输入邻接表的全部顶点\n");
    for(i=0;i<G.vexnum;i++)
    {
        
        scanf("%c",&G.vertices[i].data);
        getchar();
        G.vertices[i].firstarc=NULL;
    }
    printf("请输入两个顶点，即两个得关系\n");
    for(i=0;i<G.arcnum;i++)
    {
        char v1,v2;
        scanf("%c %c",&v1,&v2);
        getchar();
        int l1=Locate(G,v1);
        int l2=Locate(G,v2);
        ArcNode *p1=(ArcNode *)malloc(sizeof(ArcNode));
        p1->adjvex=l2;
        p1->nextarc=G.vertices[l1].firstarc;
        G.vertices[l1].firstarc=p1;
        ArcNode *p2=(ArcNode *)malloc(sizeof(ArcNode));
        p2->adjvex=l1;
        p2->nextarc=G.vertices[l2].firstarc;
        G.vertices[l2].firstarc=p2;
    }
}

void showLinJieBiao(ALGraph G)
{
    int i;
    ArcNode *p;
    for(i=0;i<G.vexnum;i++)
    {
        printf("%c ",G.vertices[i].data);
        p=G.vertices[i].firstarc;
        while(p)
        {
            printf(" -> %c",G.vertices[p->adjvex].data);
            p=p->nextarc;
        }
        printf(" -> NULL ");
        printf("\n");
    }
}

//元素v对应的第一个邻接点
int FirstAdjVex(ALGraph G,char v)
{
    int num;
    num=Locate(G,v);
    if(num==-1)
    {
        printf("没有邻接点\n");
        return -1;
    }
    if(G.vertices[num].firstarc==NULL)
    {
        printf("没有邻接点\n");
        return -1;
    }
    return G.vertices[num].firstarc->adjvex;
}

//返回G中顶点v相对于u的下一邻接点
int NextAdjVex(ALGraph G,char v,char w)
{
    int num = Locate(G,v);
    int num2 = Locate(G,w);
    if(num==-1)
        return -1;
    else{
        ArcNode *p = G.vertices[num].firstarc;
        while(p!=NULL&&p->adjvex!=num2)
        {
            p=p->nextarc;
        }
        if(p->nextarc==NULL)
        {
            printf("G中顶点%c相对于%c的下一邻接点\n",G.vertices[num].data,G.vertices[num2].data);
            return -1;
        }
    }
}

/*void DFS(ALGraph G,int w,int V[])
{
    int num,i;
    char v;

    printf("%c ",G.vertices[num].data);
        V[w]=0;
    for(i=FirstAdjVex(G,G.vertices[num].data);i>=0;i=NextAdjVex(G,G.vertices[num].data,G.vertices[i].data))
        if(!V[i])
            DFS(G,i,V);
}

//DFS
void DFSTraverse(ALGraph G,int V[])
{
    int i,num;
    char v;
    for(i=0;i<G.vexnum;i++)
        V[i]=0;
    printf("请输入一个开始访问的结点\n");
    getchar();
    scanf("%c",&v);
    num=Locate(G,v);
    DFS(G,num,V);
    for(i=0;i<G.vexnum;i++)
        if(V[i]==0)
            DFS(G,i,V);
}*/
void DFS(ALGraph G,int v,int V[])
{
    int i,j;
    printf("%c",G.vertices[v].data);
    V[v]=1;
    ArcNode *p=G.vertices[v].firstarc;
    while(p)
    {
        v=p->adjvex;
        if(!V[v])
            DFS(G,v,V);
        p=p->nextarc;
    }
}

void DFSTraverse(ALGraph G,int V[])
{
    printf("请输入起点元素\n");
    int m1,i;
    char v1;
     fflush(stdin);
    scanf("%c",&v1);
    m1=Locate(G,v1);
    for(i=0;i<G.vexnum;i++)
    {
        V[i]=0;
    }
        DFS(G,m1,V);
    for(i=0;i<G.vexnum;i++)
    {
        if(V[i]==0)
            DFS(G,i,V);
    }
}

//建队列
void InitQueue(SqQueue &Q,ALGraph G)
{
    Q.base=(int *)malloc(G.vexnum*sizeof(int));
    Q.front=Q.rear=0;
    Q.maxsize=G.vexnum;
}

//进队列
void EnQueue(SqQueue &Q,int v)
{
    Q.base[Q.rear]=v;
    Q.rear = (Q.rear+1)%Q.maxsize;
}

//退出队列
void DeQueue(SqQueue &Q,int &v)
{
    v=Q.base[Q.front];
    Q.front=(Q.front+1)%Q.maxsize;
}

int IsNullQueue(SqQueue Q)
{
    if(Q.front==Q.rear)
        return 1;
    else 
        return 0;
}

int firstqueue(SqQueue Q)
{
    return Q.base[Q.front];
}
void IsNullGraph(int flag)
{
    if(flag==0)
    {
        printf("图为空\n");
    }else{
        printf("图不为空\n");
    }
}

void BFS(ALGraph G,int v,SqQueue Q,int V[])
{
    int i,j;
    ArcNode *p;
    printf("%c",G.vertices[v].data);
    V[v]=1;
    EnQueue(Q,v);
    while(!IsNullQueue(Q))
    {
        //j=firstqueue(Q);
        DeQueue(Q,v);
        p=G.vertices[v].firstarc;
        while(p!=NULL)
        {
            if(V[p->adjvex]==0)
            {
                printf("%c",G.vertices[p->adjvex].data);
                V[p->adjvex]=1;
                EnQueue(Q,p->adjvex);
                
            }
            p=p->nextarc;
        }
    }
}

void BFSTraverse(ALGraph G,SqQueue Q,int V[])
{
    int i,v;char v1;
    for(i=0;i<G.vexnum;i++)
        V[i]=0;
    fflush(stdin);
    printf("请输入起点顶点\n");
    scanf("%c",&v1);
    v=Locate(G,v1);
    BFS(G,v,Q,V);
    for(i=0;i<G.vexnum;i++)
    {
        if(V[i]==0)
            BFS(G,i,Q,V);
    }
}

void TopologicalSort(ALGraph G)
{
    SqStack S;
    int i,count,k;
    ArcNode *p;
    InitStack(S);
    for(i=0;i<G.vexnum;i++)
    {
        if(G.vertices[i].in==0)
            Push(S,i);
    }
    count = 0;
    while(!IsNullStack(S))
    {
        Pop(S,&i);
        printf("%d,%c",i,G.vertices[i].data);
        ++count;
        for(p=G.vertices[i].firstarc;p;p=p->nextarc)
        {
            k=p->adjvex;
            if(!(--G.vertices[k].in))
            Push(S,k);
        }
        
    }
    if(count<G.vexnum)
            printf("此图不是有向无环图\n");
        else
            printf("此图是有向无环图\n");
}

void pro()
{
    printf("0.退出\n");
    printf("1.建立一个有向图\n");
    printf("2.建立一个无向图\n");
    printf("3.打印邻接表的样式\n");
    printf("4.深度优先遍历\n");
    printf("5.广度优先遍历\n");
    printf("6.拓扑排序判断是否为有向无环图\n");
}

void switchs(ALGraph G,SqQueue Q,int V[])
{
    int num;
    pro();
    printf("请输入功能数字\n");
    scanf("%d",&num);
    while(num)
    {
        switch(num)
        {
            case 0:
                num=0;
                break;
            case 1:
                CreatALGraphYouXiang(G);
            break;
            case 2:
                CreatALGraphWuXiang(G);
            break;
            case 3:
                showLinJieBiao(G);
            break;
            case 4:
                DFSTraverse(G,V);
            break;
            case 5:
                BFSTraverse(G,Q,V);
            break;
            case 6:
                TopologicalSort(G);
            break;
            default:
                printf("输入错误请重新输入\n");
        }
            printf("\n\n");
            pro();
            printf("请输入功能数字\n");
            scanf("%d",&num);
    }
}

//主函数
int main()
{
    ALGraph G;
    SqQueue Q;
    InitQueue(Q,G);
    int V[20];
    switchs(G,Q,V);
}