邻接表：顶点u的第一个邻接点

题目描述：
目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。
内容：
（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）
（2）设计并实现一个算法，在已存在的图中返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1。图的存储结构采用邻接表。将其加入到ADT中。
注意：DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网）
参考函数原型：
//返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回false
template<class TypeOfVer, class TypeOfEdge>
int adjlist_graph<TypeOfVer, TypeOfEdge>::GetFirstAdjVex(int u, int &v);

输入说明 :
建图的输入数据格式参见建图的算法说明。
第一行：图的类型
第二行：结点数
第三行：结点集
第四行：边数
第五行：边集
第六行：指定顶点的位序

输出说明 :
第一行：顶点集
第二行：邻接表
空行
第三行：第一个邻接顶点的位序（如无邻接顶点，则输出-1）

输入范例 :
DG
6
A B C D E F
6
0 1
0 2
0 3
1 4
2 4
3 5
0

输出范例 :
A B C D E F
A->3->2->1->nullptr
B->4->nullptr
C->4->nullptr
D->5->nullptr
E->nullptr
F->nullptr
(空行）
3

#include<iostream>
#include<vector>
#include<string>
#include<sstream>
#include<queue>
#include<stack>
#include<cmath>
using namespace std;
string b[10001];//用来存放顶点集
//DG（有向图）  DN（有向网）  UDG（无向图） UDN（无向网）

//图的邻接表模板类原型参考如下：
//边表的顶点定义
template<class TypeOfEdge>//这个就是在边上的顶点定义
struct edgeNode{
    int data;
    TypeOfEdge weight;
    edgeNode<TypeOfEdge> *next;
    //构造函数，用于构造其他顶点（无权图）
    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    edgeNode(int d,edgeNode<TypeOfEdge> *ptr=NULL){ data=d;next=ptr; }
    //构造函数，用于构造其他顶点（带权图）
    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    edgeNode(int d,TypeOfEdge w,edgeNode<TypeOfEdge> *ptr=NULL){
        data=d; weight=w; next=ptr;
    }
    int getData(){ return data; }//取得顶点的序号（顶点集）
    TypeOfEdge getWeight(){ return weight; }//取得边集中对应边的权值
    void SetLink(edgeNode<TypeOfEdge> *link ){ next=link; }//修改顶点的next域
    void SetData(int value){ data=value; }//修改顶点的序号（顶点集）
    void SetWeight(TypeOfEdge value){ weight=value; }//修改边集中对应边的权值
};

//图的邻接表类   这个结构体是存储顶点的结构体，里面包括顶点和它的下一个指针
template<class TypeOfVer,class TypeOfEdge>
struct verNode{
    TypeOfVer ver;//存放顶点名称
    edgeNode<TypeOfEdge> *head;//顶点的指针
    verNode(edgeNode<TypeOfEdge> *h=NULL){ head=h; }
    TypeOfVer getVer(){ return ver; }//取得顶点值（顶点集）
    edgeNode<TypeOfEdge> *getHead(){ return head; }//取得对应的边表的头指针
    void setVer(TypeOfVer value){ ver=value; }//设置顶点值（顶点集）
    void setHead(edgeNode<TypeOfEdge> *value){ head=value; }//设置对应的边表的头指针
};

template<class TypeOfVer,class TypeOfEdge>//顶点类型  边的类型
class adjlist_graph{
    private:
       int Vers;//顶点数
       int Edges;//边数
       string GraphKind;//图的种类标志
       verNode<TypeOfVer,TypeOfEdge> *verList;//按顺序存储结构存储顶点集
       bool Delete_Edge(int u,int v);
       bool DFS(int u,int num,int visited[]);//DFS遍历（递归部分）
    public:
       //构造函数构造一个只有顶点没有边的图
       //3个参数的含义：图的类型、顶点数、顶点值
       adjlist_graph(string kd,int vSize,TypeOfVer d[]){
            GraphKind=kd;
            Vers=vSize;
            verList=new verNode<TypeOfVer,TypeOfEdge> [Vers];//建立顶点值
            for(int i=0;i<Vers;++i){
                verList[i].ver=d[i];
                verList[i].head=NULL;//一开始构造的时候顶点还没有相邻的顶点
            }
       }
       //构造函数构造一个无权图
       //5个参数的含义：图的类型、顶点数、顶点集、  边数和边集
       adjlist_graph(string kd,int vSize,TypeOfVer d[],int eSize,int **e){
            GraphKind=kd;
            Vers=vSize;
            Edges=eSize;
            verList=new verNode<TypeOfVer,TypeOfEdge> [Vers];//建立顶点值
            for(int i=0;i<Vers;++i){
                verList[i].ver=d[i];
                verList[i].head=NULL;//一开始构造的时候顶点还没有相邻的顶点
            }
            for(int i=0;i<Edges;++i){//从边开始构造顶点
                for(int j=0;j<Vers;++j){
                    if(e[i][0]==j){
                        if(Insert_Edge(e[i][0],e[i][1]))
                            break;
                    }
                }
            }
       }
       //构造函数构造一个有权图
       adjlist_graph(string kd,int vSize,int eSize,TypeOfVer d[],int **e,TypeOfEdge w[]);
       bool GraphisEmpty(){ return Vers==0; }//判断图空否
       string GetGraphKind(){ return GraphKind; }//返回图的类型
       int GetVerNum(){ return Vers; }//取得当前顶点数
       int GetEdgeNum(){ return Edges; }  //取得当前边数
       bool GetVer(int u,TypeOfVer &data){//取得G中指定顶点的值
            return true;
       }
       //返回G中指定顶点u的第一个邻接顶点的位序（顶点集）
       //若顶点在G中没有邻接顶点，则返回-1
       int GetFirstAdjVex(int u,int &v){
            if(verList[u].head!=NULL){
                v=verList[u].head->data;
                return v;
            }
            v=-1;
            return -1;
       }
       int GetNextAdjVex(int u,int v,int w); //返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。若顶点在G中没有邻接顶点，则返回false
       bool PutVer(int u, TypeOfVer data); //对G中指定顶点赋值
       bool InsertVer(const TypeOfVer data); //往G中添加一个顶点
       int LocateVer(TypeOfVer data); //返回G中指定顶点的位置
       bool ExistEdge(int u,int v);
       //输出顶点集
       void PrintVer(){
           for(int i=0;i<Vers;++i){
                if(i==0)
                    cout<<verList[i].ver;
                else
                    cout<<" "<<verList[i].ver;
           }
           cout<<endl;
       }
       //输出邻接表
       void PrintAdjList(){
            for(int i=0;i<Vers;++i){
                cout<<verList[i].ver;
                if(verList[i].head!=NULL){
                    edgeNode<TypeOfEdge> *p=verList[i].head;//从顶点开始遍历
                    while(p){
                        cout<<"->"<<p->data;
                        p=p->next;
                    }
                    cout<<"->nullptr"<<endl;
                }
                else
                    cout<<"->nullptr"<<endl;
            }
       }
       //无权图插入一条边
       bool Insert_Edge(int u,int v){//u是起点，v是终点
            edgeNode<TypeOfEdge> *x=new edgeNode<TypeOfEdge>(v);//直接使用构造函数赋值
            //x.data=v;不要这么写
            x->next=verList[u].head;//这里面都没有->next  这个指针！！！！！！！
            verList[u].head=x;
            return true;
       }
       bool Insert_Edge(int u,int v,TypeOfEdge w);//有权图插入一条边
       bool DeleteVer(const TypeOfVer data);//往G中删除一个顶点
       bool DeleteEdge(int u,int v);//删除边 (外壳：有向（删除1条边）， 无向（删除2条边））
       void DFS_Traverse(int u);//DFS遍历（外壳部分）
       void BFS_Traverse(int u);//BFS遍历
       //~adjlist_graph(); //析构函数
};

template<class TypeOfVer,class TypeOfEdge>
void shuchu(adjlist_graph<TypeOfVer,TypeOfEdge> &tu,int n){
    //cout<<tu.GetGraphKind()<<endl;
    TypeOfVer x;
    //TypeOfEdge we;
    //we=tu.GetEdgeNum();//返回第一个边数
    tu.PrintVer();
    //cout<<endl<<we<<endl;
    tu.PrintAdjList();//输出邻接表
}


int main(){
    string str;//图的类型
    int n,m;//顶点数和边数
    getline(cin,str);
    cin>>n;//输入顶点个数
    for(int i=0;i<n;++i)
        cin>>b[i];//输入顶点集合
    cin>>m;//输入边数
    int **e;
    e=new int* [m];
    for(int i=0;i<m;++i)
        e[i]=new int [2];
    for(int i=0;i<m;++i)
        cin>>e[i][0]>>e[i][1];//输入边集
    adjlist_graph<string,int> tu(str,n,b,m,e);
    int no;//指定的顶点
    cin>>no;
    shuchu(tu,n);
    cout<<endl;
    int we;
    tu.GetFirstAdjVex(no,we);
    cout<<we<<endl;
    return 0;
}

好了，在上一道题的基础上我又补充了一些函数的实现。

表是由2个部分组成的：

1.表头顶点表
2.边表

首先我们要知道：用模板和ADT写这个题其中一共有2个结构体和1个类。

2个结构体分别是struct verNode和struct edgeNode
第一个 结构体表示顶点的结点，第二个结点表示边的结点。
顶点结构体我们用到的就是这两个成员：

 TypeOfVer ver;//存放顶点名称
 edgeNode<TypeOfEdge> *head;//顶点的指针

比如说ver就是A，而红色箭头就是名为head的指针！！！！
所以使用head指针的时候不需要再写head->next这样的语句，因为它本身就是指针了，如果这样写的话，程序肯定会崩的，空指针不能指向某个地方。
（估计是因为我蠢才以为错的）

第二个结构体就是表示边上的结点了，有值data权值weight和指向下一个的结点next指针。
类中的成员都很容易理解，就忽略了。

表头顶点表是用顺序存储结构储存的，就是adjlist_graph类中的verNode<TypeOfVer,TypeOfEdge> * verList;
然后这个顺序存储结构它是储存verNode<TypeOfVer,TypeOfEdge>顶点的。

边表是储存head指针开始由结点连接成的链表。