选择合适的存储结构存储无向图

选择合适的存储结构存储无向图，要求完成如下功能：

①创建：输入顶点和边的信息，创建图；

②查询：输入顶点，所有与其关联的其余顶点；

③深度优先遍历：指定起点，输出深度优先序列；

④广度优先遍历：指定起点，输出广度优先序列；

⑤叶子结点信息：输出每个叶子结点的值，并统计叶子结点总数；

⑥二叉树深度：输出二叉树的深度值。

#include<iostream>
#include<queue>
using namespace std;
bool DFSvisited[50];//bool型数组，用来标记已经遍历过的
bool BFSvisited[50];
typedef struct EdgeNode//边结点
{
    int adjvex;//整型数据
    struct EdgeNode * next;//指向下一个节点
} EdgeNode;
typedef struct//顶点表节点结构
{
    string data;
    EdgeNode * firstedge;//指向边表的第一个节点
} AdjList;
typedef struct//图的邻接表结构
{
    AdjList adjList[20];//定义数组用于储存顶点
    int numVertex,numEdge;
} GraphAdjList;
int local(GraphAdjList G,string val)//确定边所在的位置
{
    for(int i=0; i<G.numVertex; i++)
    {
        if(G.adjList[i].data==val)
            return i;
    }
    return -1;
}
 void CreateGraph(GraphAdjList & G)//创建无向图
{
    int i,j,k;
    string v1,v2;
    EdgeNode * e,* p,*q;
    cout<<"请输入顶点数和边数，并以空格隔开:"<<endl;
    cin>>G.numVertex>>G.numEdge;
    cout<<"请输入顶点的信息："<<endl;
    for(i=0; i<(G.numVertex); i++)
    {
        cout<<"第"<<i+1<<"个顶点："<<endl;
        cin>>G.adjList[i].data;
        G.adjList[i].firstedge=NULL;
    }
    for(k=0; k<(G.numEdge); k++)
    {
        cout<<"请输入边上的顶点信息:"<<endl;
        cin>>v1>>v2;
        i=local(G,v1);
        j=local(G,v2);

        if(G.adjList[i].firstedge==NULL)
        {
            e= new EdgeNode;
            e->adjvex=j;
            e->next=NULL;
            G.adjList[i].firstedge=e;
        }
        else
        {
            p=G.adjList[i].firstedge;
            while(p->next!=NULL)
            {
                p=p->next;
            }
            e = new EdgeNode;//申请新空间
            e->adjvex=j;
            e->next=NULL;
            p->next=e;
        }
        if(G.adjList[j].firstedge==NULL)
        {
            e= new EdgeNode;
            e->adjvex=i;
            e->next=NULL;
            G.adjList[j].firstedge=e;
        }
        else
        {
            p=G.adjList[j].firstedge;
            while(p->next!=NULL)
            {
                p=p->next;
            }
            e = new EdgeNode;
            e->adjvex=i;
            e->next=NULL;
            p->next=e;
        }
    }
}
void Prin(GraphAdjList G)//输出邻接表
{
    cout<<"所建立的邻接表如以下所示："<<endl;
    for(int i=0; i<G.numVertex; i++)
    {
        cout<<G.adjList[i].data;             //先输出顶点信息
        EdgeNode * e = G.adjList[i].firstedge;
        while(e)                              //然后就开始遍历输出每个边表所存储的邻接点的下标
        {
            cout<<"-->"<<e->adjvex;
            e=e->next;
        }
        cout<<endl;
    }
}
void DFS(GraphAdjList  G,int i)//深度优先遍历
{

    EdgeNode * p;
    DFSvisited[i]=true;
    cout<<G.adjList[i].data<<"  ";
    p=G.adjList[i].firstedge;
    while(p)
    {
        if(!DFSvisited[p->adjvex])
            DFS(G,p->adjvex);
        p=p->next;
    }
}
 void DFSTraverse(GraphAdjList  G)
{
    for(int i=0; i<G.numVertex; i++)
        DFSvisited[i]=false;
    for(int i=0; i<G.numVertex; i++)
    {
        if(!DFSvisited[i])
            DFS(G,i);
    }
}
void BFSTraverse(GraphAdjList  G)//广度优先遍历
{
    EdgeNode * p;
    queue<int>q;//C++STL队列
    for(int i=0; i<G.numVertex; i++)
        BFSvisited[i]=false;
    for(int i=0; i<G.numVertex; i++)
    {
        if(!BFSvisited[i])
        {
            BFSvisited[i]=true;
            cout<<G.adjList[i].data<<"  ";
            q.push(i);
            while(!q.empty())
            {
                int count =q.front();
                q.pop();
                p=G.adjList[count].firstedge;
                while(p)
                {
                    if(!BFSvisited[p->adjvex])
                    {
                        BFSvisited[p->adjvex]=true;
                        cout<<G.adjList[p->adjvex].data<<"  ";
                        q.push(p->adjvex);
                    }
                    p=p->next;
                }
            }
        }
    }
}
int main()
{
    GraphAdjList G;
    cout<<"创建无向图："<<endl;
    CreateGraph(G);
    cout<<"输出无向图的邻接表信息:"<<endl;
    Prin(G);
    cout<<"深度优先遍历："<<endl;
    DFSTraverse(G);
    cout<<"\n广度优先遍历："<<endl;
    BFSTraverse(G);
    return 0;

}