图的链式存储以及遍历各种操作

CodeBlocks编写

#include<bits/stdc++.h>
using namespace std;

struct LinkNode
{
    int data;
    LinkNode *next;
};

struct node
{
   int num;
   LinkNode *first;
   int sum;
};
void chushihua(node* L,int n);                   //初始化
void creatY(node* L,int n,int m);               //创建有向图
void creatW(node* L,int n,int m);              //创建无向图
void add(node &LL,int to);                    //把节点添加到图中区
void out(node *L,int n);                     //输出图
void du(node *L,int n);                     // 有向图的度
void dfs(node *L,int i,int n,int *flag);   //深度优先搜索遍历无向图
void bfs(node *L,int n,int *flag);        //广搜遍历无向图
int main()
{

    printf("有向图及无向图的操作\n");
    int ny,my,nw,mw;
    printf("建立有向图，请输入节点个数n和边数m\n");
    scanf("%d%d",&ny,&my);
    printf("请输入m条边对应邻接点\n");
    node LY[ny+1];
    chushihua(LY,ny);
    creatY(LY,ny,my);

    printf("建立无向图，请输入节点个数n和边数m\n");
    scanf("%d%d",&nw,&mw);
    node LW[nw+1];
    printf("请输入m条边对应邻接点\n");
    chushihua(LW,nw);
    creatW(LW,nw,mw);

    printf("\n有向图邻接表为 \n");
    out(LY,ny);
    printf("有向图各个顶点的度为 \n");
    du(LY,ny);
    printf("\n");
    printf("有向图邻接表为 \n");
    out(LW,nw);

    int flag[nw+1];
    for(int i=1;i<=nw;i++)
        flag[i]=0;
    printf("无向图深度优先搜索遍历顺序如下\n");
    for(int i=1;i<=nw;i++)
    {
        if(!flag[i])
        {
            printf("%d ",i);
            flag[i]=1;
            dfs(LW,i,nw,flag);
        }
    }

    for(int i=1;i<=nw;i++)
        flag[i]=0;
    printf("\n无向图广度优先搜索遍历顺序如下\n");
    bfs(LW,nw,flag);
    free(flag);

    return 0;
}

void chushihua(node* L,int n)
{
  int i=0;
  for(i=1;i<=n;i++)
  {
    L[i].num=i;
    L[i].first=NULL;
    L[i].sum=0;
  }
}

void creatY(node* L,int n,int m)
{
    int i,from,to;
    for(i=1;i<=m;i++)
    {
        scanf("%d%d",&from,&to);
        add(L[from],to);
    }
}

void creatW(node* L,int n,int m)
{
    int i,from,to;
    for(i=1;i<=m;i++)
    {
        scanf("%d%d",&from,&to);
        if(from==to)
            add(L[from],to);
        else
        {
           add(L[from],to);
           add(L[to],from);
        }
    }
}

void add(node &LL,int to)
{
    LinkNode *p,*q;
    q = (LinkNode *)malloc(sizeof(LinkNode));
    q->data=to;
    q->next=NULL;
    p=LL.first;
    LL.sum++;
    if(LL.first==NULL)
    {
       LL.first=q;
       return;
    }
    while(p->next)
    {
        p=p->next;
    }
    p->next=q;
}

void out(node *L,int n)
{
   int i;
   for(i=1;i<=n;i++)
   {
       LinkNode *p=L[i].first;
       printf("与%d邻接的有   ",i);
       while(p)
       {
           printf("%d  ",p->data);
           p=p->next;
       }
       printf("\n");
   }
   printf("\n");
}

void du(node *L,int n)
{
    int i;
    for(i=1;i<=n;i++)
    {
        printf("%d的度为 %d\n",i,L[i].sum);
    }
}

void dfs(node *L,int i,int n,int *flag)
{
    LinkNode *p=L[i].first;
    if(p==NULL)
        return;
    while(p)
    {
        if(!flag[p->data])
        {
            printf("%d ",p->data);
            flag[p->data]=1;
            dfs(L,p->data,n,flag);
        }
        p=p->next;
    }
}

void bfs(node *L,int n,int *flag)
{
    int l,r;
    l=0;
    int Queue[2*n+1];
    Queue[0]=1;
    flag[1]=1;
    r=1;
    while(l<r)
    {
        LinkNode *p=L[Queue[l]].first;
        printf("%d ",Queue[l]);
        while(p)
        {
            if(!flag[ p->data ])
            {
                flag[p->data]=1;
                Queue[r++]=p->data;
            }
            p=p->next;
        }
        l++;
    }
}