无向图的邻接表算法

来源：互联网发布：成都java培训编辑：程序博客网时间：2024/05/16 17:40

#include<iostream>
#define MAX_VEXS_NUM 20
using namespace std;
typedef struct Graph
{
    int vexs[MAX_VEXS_NUM];
    int edgs[MAX_VEXS_NUM][MAX_VEXS_NUM];
    int n;
    int e;
}MyGraphm,*MyGraph;
//用邻接表的形式来创建图
void createGraph(MyGraph &g)
{
     int i=0,j=0,k=0,w=0,vexnum,arcnum;
     g=new MyGraphm();
     cout<<"请输入图的节点数和边数：/n";
     cin>>g->n;
     cin>>g->e;
     vexnum=g->n;
     arcnum=g->e;

     cout<<"请输入各个节点："<<endl;
     for(i=0;i<vexnum;i++)
        cin>>g->vexs[i];
     for(i=0;i<vexnum;i++)
        for(j=0;j<vexnum;j++)
        {
            g->edgs[i][j]=0;
        }
     cout<<"请输入无向图的各个边："<<endl;
     for(i=0;i<arcnum;i++)
     {
                        scanf("%d",&j);
                        scanf("%d",&k);
                        scanf("%d",&w);
                        g->edgs[j][k]=w;
                        g->edgs[k][j]=w;
     }
     cout<<"无向图建立完毕"<<endl;
}
//标识节点是否被访问过的数组
bool visit[MAX_VEXS_NUM];
//定义了队列，方便广度优先遍历时使用
typedef struct Queue
{
        int data[300];
        int front;
        int rear;
}MyQ,*MyQueue;
void initQueue(MyQueue &my)
{
     MyQ *q=new MyQ();
     my=q;
     my->front=-1;
     my->rear=-1;
     cout<<"队列建立完毕/n";
}
void EnQueue(MyQueue &myQ,int i)
{
     myQ->data[++(myQ->front)]=i;
}
bool IsEmpty(MyQueue &myQ)
{
     if(myQ->front==myQ->rear)
     {
          return true;
     }
     else
          return false;
}
int DeQueue(MyQueue &myQ)
{
     int i=-1;
     if(!IsEmpty(myQ))
     {
           i=myQ->data[++(myQ->rear)];
     }
     return i;
}
//返回某个节点的邻接节点
int nextVext(MyGraph &g,int k)
{
    for(int i=0;i<g->n;i++)
    {
            if(g->edgs[k][i]!=0&&k!=i&&visit[i]==false)
            {
                  return i;
            }
    }
    return -1;
}
//深度遍历算法
void DFS(MyGraph &g,int i)
{
     cout<<i<<" ";
     visit[i]=true;
     int w;
     for(w=nextVext(g,i);w>0;w=nextVext(g,i))
     {
          //cout<<"w="<<w<<endl;
          DFS(g,w);
     }
}
void DFSTraverse(MyGraph &g)
{
     for(int i=0;i<g->n;i++)
     {
             visit[i]=false;
     }
     for(int i2=0;i2<g->n;i2++)
     {
             if(visit[i2]==false)
                       DFS(g,i2);
     }
}
//广度遍历算法
void BFSTraverse(MyGraph &g)
{
     for(int i=0;i<MAX_VEXS_NUM;i++)
     {
             visit[i]=false;
     }
     MyQueue myQ;
     initQueue(myQ);
     for(int i=0;i<g->n;i++)
     {
             if(visit[i]==false)
             {
                                cout<<i<<" ";
                                visit[i]=true;
                                EnQueue(myQ,i);
                                while(IsEmpty(myQ)==false)
                                {
                                                  int k=DeQueue(myQ);
                                                  for(int w=nextVext(g,k);w>0;w=nextVext(g,k))
                                                  {
                                                               cout<<w<<" ";
                                                               visit[w]=true;
                                                               EnQueue(myQ,w);
                                                  }
                                }
             }
     }
}
int main()
{
    MyGraph my;
    createGraph(my);
    int i,j;
    cout<<"此图的邻接矩阵表示法为："<<endl;
    for(i=0;i<my->n;i++)
     {
                        for(j=0;j<my->n;j++)
                        {
                                            cout<<my->edgs[i][j]<<" ";
                        }
                        cout<<endl;
     }
     cout<<"深度遍历的结果为：/n";
     DFSTraverse(my);
     cout<<endl;
     cout<<"广度遍历的结果为：/n";
     BFSTraverse(my);
     system("pause");
     return 1;
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/rongyongfeikai2/archive/2010/10/21/5957392.aspx