邻接表存储无向图

adjacentList.h

#pragma once
//邻接表存储的无向图
# include<iostream>
# include"vertex.h"
typedef struct _listNode//表节点
{
    int iAdjaVeretex;//邻接点编号
    int info;//边上信息
    struct _listNode*next=NULL;
}listNode;
typedef struct _vertexNode//顶点节点
{
    int iVertex;//顶点编号
    listNode* fistEdge=NULL;//边表头指针
}vertexNode;

class undiGraph
{
public:
    undiGraph(int numOfVertex , int numOfEdge );
    ~undiGraph();
    void crete();
    void setVisitedFalse();//将访问标志设为flase，每次遍历前都需调用此函数
    void DFS(int i);//深度优先搜索 从第i+1个结点开始 
    void BFS(int i);//广度优先搜索
private:
    vertex* vertexElem;//顶点元素
    int iVertex;
    int iEdge;
    vertexNode *verNode;//顶点节点

    void addListNode(int a, int b, int _info);//给编号为a的顶点添加一个表节点
};

adjacentList.cpp

# include"adjacentList.h"
# include<iostream>
# include"myQuene.h"
using namespace std;

undiGraph::undiGraph(int numOfVertex = 0, int numOfEdge = 0):iVertex(numOfVertex),iEdge(numOfEdge)
{
    vertexElem = new vertex[numOfVertex];
    verNode = new vertexNode[numOfVertex];
}

undiGraph::~undiGraph()
{
    for (int i = 0;i < iVertex;++i)//销毁所有的表结点
        //每次循环，销毁第i+1个顶点结点的表结点
    {
        listNode *p = verNode[i].fistEdge;

        while (p)
        {
            listNode *p1 = p;
            p = p->next;
            delete p1;
        }
    }
    delete []vertexElem;
    delete[]verNode;
}

void undiGraph::crete()
{
    cout << "请依次输入顶点信息:" << endl;
    char elem;
    for (int i = 0;i < iVertex;i++)
    {
        cin >> elem;
        vertexElem[i].data = elem;
        verNode[i].iVertex = i;
    }

    cout << "请依次输入有向图中相关联的顶点(0表示第一个顶点)及弧的权值：" << endl;
    int a, b;
    double weight;
    for (int j = 0;j < iEdge;j++)
    {
        cin >> a >> b >> weight;
        addListNode(a, b, weight);
        addListNode(b, a, weight);
    }
}

void undiGraph::addListNode(int a, int b, int _info)//给编号为a的顶点添加一个表节点
{
    listNode*(&p) = verNode[a].fistEdge;//第一次添加时，需要改变firstEdge, 这里打错字了就不改了
    if (p == NULL)//第一次添加，为NULL
    {
        p= new listNode;
        p->iAdjaVeretex = b;
        p->info = _info;
        return;
    }

    listNode*p1 = verNode[a].fistEdge;
    while (p1->next!= NULL)
    {
        p1 = p1->next;
    }
    listNode *p2 = new listNode;
    p2->iAdjaVeretex = b;
    p2->info = _info;
    p1->next = p2;
}

void undiGraph::setVisitedFalse()
{
    for (int i = 0;i < iVertex;++i)
        vertexElem[i].isVisited = false;
}

void undiGraph::DFS(int i)//深度优先搜索 从第i+1个结点开始  
{
    if (!vertexElem[i].isVisited)//如果第i+1个节点未被访问，则访问该节点
    {
        vertexElem[i].visited();
        vertexElem[i].isVisited = true;
    }
    else return;

    //在第i+1个顶点的所有邻接点中调用DFS

    listNode*p = verNode[i].fistEdge;
    while (p)//第i+1个节点
    {
        DFS(p->iAdjaVeretex);
        p = p->next;
    }
}   

void undiGraph::BFS(int i)//广度优先搜索
{
    if (!vertexElem[i].isVisited)//如果第i+1个节点未被访问，则访问该节点
    {
        vertexElem[i].visited();
        vertexElem[i].isVisited = true;
    }
    else return;

    myQuene<int> q(30);
    q.in(i);
    int x;

    while (!q.empty())//只要队列不为空
    {
        q.out(x);

        listNode*p = verNode[x].fistEdge;
        while (p)
        {
            if (!vertexElem[p->iAdjaVeretex].isVisited)//如果节点未被访问，则访问该节点
            {
                vertexElem[p->iAdjaVeretex].visited();
                vertexElem[p->iAdjaVeretex].isVisited = true;
                q.in(p->iAdjaVeretex);
            }
            p = p->next;
        }
    }
}

main.cpp

# include<iostream>
# include"adjacentList.h"

using namespace std;

int main()
{
    undiGraph myUndiGraph(8, 9);
    myUndiGraph.crete();
    myUndiGraph.setVisitedFalse();

    cout << "深度优先遍历：" << endl;
    myUndiGraph.setVisitedFalse();
    myUndiGraph.DFS(0);
    cout << endl;

    cout << "广度优先遍历：" << endl;
    myUndiGraph.setVisitedFalse();
    myUndiGraph.BFS(0);
    cout << endl;

    system("pause");
    return 0;
}