基于邻接表的无向图实现

存储结构：

ArcNode 边表节点数据结构（包含索引值vertex和next）

VertexNode 顶点表节点数据结构（包含顶点数据和第一个边表节点firstEnde）
adjlist[] 顶点表节点数组
vertexNum 顶点数
arcNum 边数
visited[] 标志数组

功能：
1.构建基于邻接表的无向图
2.深度优先遍历
3.广度优先遍历

伪代码：
构建
1.标志数组初始化
2.顶点表节点数组初始化赋值
3.重复arcNum次下列操作
  3.1 输入边的两顶点
  3.2 new一个边表节点i，j
  3.3 将索引值赋为j
  3.4 将该节点用头插法插入i的链表
  3.5 i,j互换，重复上述操作

深度遍历
1.输出一个顶点v的数据并将v的firstEdge赋给p
2.重复下列操作直到p==NULL
  2.1 将p的索引值赋给j
  2.2 如果该索引值对应的顶点节点未被访问深度遍历j
  2.3 p指向p->next

广度遍历
1.初始化visited数组
2.重复下列操作vertexNum次
  2.1 初始化队列
  2.2 输出该顶点数据并将其入队
  2.3 当队列不为空时重复下列操作
     2.3.1 队首出队（++front）并赋给i
     2.3.2 将i对应的顶点的firstEdge赋给p
     2.3.3 重复下列擦欧洲哦直到p==NULL
           2.3.3.1 获得p的下标
           2.3.3.2 如果p的下标对应的顶点未被访问输出该顶点数据并标志其已访问，并将其入队

           2.3.3.3 p=p->next;

#include

using namespace std;

#define MaxSize 100

//边表节点
struct ArcNode
{
    int adjvex;                //下标，索引值
    ArcNode *next;             //指向下一个边表节点
};

//顶点表表节点（最开始的那批数据）
template
struct VertexNode
{
    T vertexData;               //顶点数据
    ArcNode *firstEdge;         //指向第一个边表节点
};

/**基于邻接表的无向图*/
template
class ALGraph
{
private:
    void DFS(int v);
public:
    ALGraph();
    ~ALGraph() {}
    void DFSTraverse();
    void BFSTraverse();
private:
    VertexNode adjlist[MaxSize];        //储存顶点表节点的数组
    int VertexNum,arcNum;
    int visited[MaxSize];
};

template
ALGraph::ALGraph()
{
    int i,j,k;
    cout<<"依次输入顶点数n、边数e、及n个顶点的编号和顶点之间的连通关系的两个顶点的编号:"<>VertexNum;
    cin>>arcNum;

    //把标志数组初始化
    //虽然两个遍历都会初始化，但是先行初始化总是好的，避免还未遍历便要用vidited的情况
    for(i=0; i>adjlist[i].vertexData;
        adjlist[i].firstEdge=NULL;
    }

    //边关系
    for(k=0; k>i>>j;
        ArcNode *s1=new ArcNode;
        s1->adjvex=j;
        s1->next=adjlist[i].firstEdge;
        adjlist[i].firstEdge=s1;

        ArcNode *s2=new ArcNode;
        s2->adjvex=i;
        s2->next=adjlist[j].firstEdge;
        adjlist[j].firstEdge=s2;
    }
}

template
void ALGraph::DFS(int v)
{
    int j;
    ArcNode *p;

    cout<adjvex;

        if(visited[j]==0)
            DFS(j);         //中途抢占，深度遍历

        p=p->next;
    }
}


template
void ALGraph::DFSTraverse()
{
    int i,v;
    //标记数组初始化
    for(i=0; i
void ALGraph::BFSTraverse()
{
    int front,rear,i,j,v;
    int Q[MaxSize];
    ArcNode *p;

    //把标志数组初始化
    for(i=0; iadjvex;        //获得下标
                    if(visited[j]==0)
                    {
                        cout<next;
                }
            }
        }
    }

    cout< G;

    G.DFSTraverse();
    G.BFSTraverse();

    return 0;
}

测试数据:

输入:
6 5
0 1 2 3 4 5
0 1
0 3
1 2
2 3
4 5


输出:
深度优先遍历的结果为：0 3 2 1 4 5

广度优先遍历的结果为：0 3 1 2 4 5

该图为数据的图示