数据结构学习（五）图

图

ADT

邻接矩阵

#include <iomanip>
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

template <class TypeOfVer, class TypeOfEdge>
class adjmatrix_graph{
    private:
       int Vers;        //顶点数 
       int Edges;       //边数 
       vector< vector<TypeOfEdge> > edge;  //存放邻接矩阵（TypeOfEdge表示顶点关系类型。对于无权图，用1或0，表示相邻否；对于带权图，则为权值类型） 
       vector<TypeOfVer> ver;    //存放结点值 
       TypeOfEdge noEdge;  //邻接矩阵中的∞的表示值，没有边的标记
       string GraphKind;   //图的种类标志,DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网）
        
       bool DFS(int u, int &num, int* visited,void (*visit)(TypeOfVer ele,int num)){ //DFS遍历（递归部分）
        for(int i=0;i<Vers;i++){
          if(!visited[i] && edge[u][i]!=noEdge){
            visited[i]=1;
            visit(ver[i],num);
            num++;
            if(num==Vers) return 1;
            if(DFS(i,num,visited,visit)) return 1;
          }
        }
        return 0;
       }
      bool CheckRoute_Cursive(int u, int v, int* visited){ //检查两个结点之间是否有路径存在（递归部分）
        for(int i=0;i<Vers;i++){
          if(!visited[i] && edge[u][i]!=noEdge){
            visited[i]==1;  //不用撤销
            if(i==v) return 1;
            if(CheckRoute_Cursive(i,v,visited)) return 1;
          }
        }
        return 0;
      }


    public:
        //构造函数构造一个只有结点没有边的图。4个参数的含义：图的类型、结点数、结点值和邻接矩阵中表示结点间没有边的标记（无权图：0，有权图：输入参数定） 
       adjmatrix_graph( const string &kd, int vSize, const TypeOfVer* d, const TypeOfEdge noEdgeFlag):GraphKind(kd),Vers(vSize),ver(d,d+vSize),noEdge(noEdgeFlag){
        edge.resize(vSize);
        for(int i=0;i<vSize;i++){
          edge[i].resize(vSize,noEdgeFlag);
        }
       }
      
        //构造函数构造一个无权图。5个参数的含义：图的类型、结点数、边数、结点集和边集,无边默认为0
       adjmatrix_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e):GraphKind(kd),Vers(vSize),ver(d,d+vSize),Edges(eSize){
        noEdge=0;
        edge.resize(vSize);
        for(int i=0;i<vSize;i++){
          edge[i].resize(vSize,0);
        }
        for(int i=0;i<eSize;i++){
          int a=e[i][0],b=e[i][1];
          edge[a][b]=1;
          if(kd=="UDG" || kd=="UDN"){
            edge[b][a]=1;
          }
        }
       }  
      
       //构造函数构造一个有权图。7个参数的含义：图的类型、结点数、边数、无边标记、结点集、边集、权集
       adjmatrix_graph( const string &kd, int vSize, int eSize, const TypeOfEdge noEdgeFlag, const TypeOfVer d[], int **e, const TypeOfEdge* w):GraphKind(kd),Vers(vSize),ver(d,d+vSize),Edges(eSize),noEdge(noEdgeFlag)
       {
        edge.resize(vSize);
        for(int i=0;i<vSize;i++){
          edge[i].resize(vSize,noEdgeFlag);
        }
        for(int i=0;i<eSize;i++){
          int a=e[i][0],b=e[i][1];
          edge[a][b]=w[i];
          if(kd=="UDG" || kd=="UDN"){
            edge[b][a]=w[i];
          }
        }
       }
       bool GraphisEmpty() { return Vers == 0; }  //判断图空否
       string GetGraphKind(){ return GraphKind; } //图的类型
       int getVers(){ return Vers; }  //返回顶点数量
       bool GetVer(int u, TypeOfVer &data); //取得G中指定顶点的值 
       int GetFirstAdjVex(int u){ //返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1 
        for(int i=0;i<Vers;i++){
          if(edge[u][i]!=noEdge) return i;
        }
        return -1;
       }
       int GetNextAdjVex(int u, int v){ //返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1
        for(int i=v+1;i<Vers;i++){
          if(edge[u][i]!=noEdge) return i;
        }
        return -1;
       }
       bool PutVer(int u, TypeOfVer data){
        if(u>=Vers || u<0) return 0;
        ver[u]=data;
        return 1;
       } //对G中指定顶点赋值 
       int LocateVer(TypeOfVer data){ //返回G中指定顶点的位置,-1表示未找到
        for(int i=0;i<Vers;i++){
          if(ver[i]==data) return i;
        }
        return -1;
       } 
      
       bool hasDirection(){ //是否有向
        if(GraphKind=="DG" || GraphKind=="DN") return 1;
        return 0;
       }
       bool hasWeight(){  //是否有权
        if(GraphKind=="DN" || GraphKind=="UDN") return 1;
        return 0;
       }
       bool PrintMatrix(){  //输出邻接矩阵,默认占位两格
        for(int i=0;i<Vers;i++){
          if(i) cout<<endl;
          for(int j=0;j<Vers;j++){
            // if(j) cout<<" ";
            // cout.flags(ios::left);
            cout<<edge[i][j]<<"\t";   //可以控制输出格式
          }
        }
        return 1;
       }
       int GetVerNum(){ return Vers;}    //取得当前顶点数 
       int GetEdgeNum(){ return Edges;}  //取得当前边数 
       bool Insert_Edge(int u, int v){ //无权图插入一条边
        if(u<0 || u>=Vers || v<0 || v>=Vers || edge[u][v]!=noEdge) return 0;  //已经有边了则插入失败
        edge[u][v]=1;
        Edges++;
        if(!hasDirection()) edge[v][u]=1;
        return 1;
       }
       bool Insert_Edge(int u, int v, TypeOfEdge w){ //有权图插入一条边
        if(u<0 || u>=Vers || v<0 || v>=Vers || edge[u][v]!=noEdge) return 0;
        edge[u][v]=w;
        Edges++;
        if(!hasDirection()) edge[v][u]=w;
        return 1;
       }
       bool InsertVer(const TypeOfVer &data){ //往G中添加一个顶点 
        ver.push_back(data);
        for(int i=0;i<Vers;i++){
          edge[i].push_back(noEdge);
        }
        edge.push_back(vector<TypeOfEdge>(Vers+1,0));
        Vers++;
        return 1;
       }
       bool DeleteVer(const TypeOfVer &data){ //往G中删除一个顶点
        int i;
        for(i=0;i<Vers && ver[i]!=data;i++) ;
        if(i==Vers) return 0;

        Edges=Edges-Get_Degree(i);
        if(hasDirection()) Edges=Edges-Get_InDegree(i);   //更新边数

        for(int j=i;j<Vers-1;j++){
          ver[j]=ver[j+1];
          edge[j]=edge[j+1];
        }
        ver.pop_back();
        edge.pop_back();
        Vers--;
        for(int j=0;j<Vers;j++){
          for(int k=i;k<Vers;k++){
            edge[j][k]=edge[j][k+1];
          }
          edge[j].pop_back();
        }
        return 1;
       }
       bool Delete_Edge(int u, int v){ //无权图删除一条边 
        if(u<0 || u>=Vers || v<0 || v>=Vers || Edges==0 || edge[u][v]==noEdge) return 0;
        Edges--;
        edge[u][v]=noEdge;
        if(!hasDirection()) edge[v][u]=noEdge;
        return 1;
       }
       bool Delete_Edge(int u, int v, TypeOfEdge w){ //有权图删除一条边
        return 1;
       } 
       void DFS_Traverse(int u,void (*visit)(TypeOfVer ele,int num)){ //DFS遍历（外壳部分）,u表示起点,只遍历起点开始往后且联通的结点
        int *visited=new int[Vers];
        for(int i=0;i<Vers;i++){
          visited[i]=0;
        }
        int num=0;

        for(int i=u;i<Vers;i++){
          if(!visited[i]){
            visited[i]=1;
            visit(ver[i],num);
            num++;
            if(num==Vers) break;
            if(DFS(i,num,visited,visit)) break;
          }
        }
        delete[] visited;
        return ;
       }
       void BFS_Traverse(int u,void (*visit)(TypeOfVer ele,int num)){ //BFS遍历
        int *visited=new int[Vers];
        for(int i=0;i<Vers;i++){
          visited[i]=0;
        }
        int num=0;
        queue<int> Q;
        Q.push(u);
        visited[u]=1;
        visit(ver[u],num);
        num++;
        if(num==Vers){
          delete[] visited;
          return ;
        }

        while(!Q.empty()){
          int k=Q.front();
          Q.pop();
          for(int i=0;i<Vers;i++){
            if(!visited[i] && edge[k][i]!=noEdge){
              visited[i]=1;
              visit(ver[i],num);
              num++;
              if(num==Vers){
                delete[] visited;
                return ;
              }
              Q.push(i);
            }
          }
        }
        delete[] visited;
        return ;
       }
       void printVers(){  //打印结点
        for(int i=0;i<Vers;i++){
          if(i) cout<<" ";
          cout<<ver[i];
        }
       }
       bool CheckRoute(int u, int v){ //检查两个结点之间是否有路径存在（外壳部分）
        int *visited=new int[Vers];
        for(int i=0;i<Vers;i++){
          visited[i]=0;
        }
        visited[u]=1;
        if(u==v){
          delete[] visited;
          return 1;
        }
        if(CheckRoute_Cursive(u,v,visited)){
          delete[] visited; //先释放空间再返回
          return 1;
        } else {
          delete[] visited; //先释放空间再返回
          return 0;
        }
       }
       int Get_InDegree(int u){ //求有向图指定顶点的入度,只存在于有向图中
        if(u<0 || u>=Vers || !hasDirection()) return -1;
        int cnt=0;
        for(int i=0;i<Vers;i++){
          if(edge[i][u]!=noEdge) cnt++;
        }
        return cnt;
       }
       int Get_Degree(int u){ //求指定顶点的（出）度（无向图/网：度； 有向图/网：出度 ）
        if(u<0 || u>=Vers) return -1;
        int cnt=0;
        for(int i=0;i<Vers;i++){
          if(edge[u][i]!=noEdge) cnt++;
        }
        return cnt;
       }
       bool ExistEdge(int u, int v){ //检查指定2个顶点是否是邻接顶点
        if(u<0 || u>=Vers || v<0 || v>=Vers || u==v) return 0;
        if(edge[u][v]!=noEdge || edge[v][u]!=noEdge) return 1;
        return 0;
       }
       bool TopSort_Pure(vector<int> &topsort){ //无输出的拓扑排序
        int *inDgree=new int[Vers];
        topsort.resize(0);
        int cnt=0;
        queue<int> Q;
        for(int i=0;i<Vers;i++){
          inDgree[i]=Get_InDegree(i);
          if(!inDgree[i]){
            Q.push(i);
            topsort.push_back(i);
            cnt++;
            if(cnt==Vers) return 1;
          }
        }
        while(!Q.empty()){
          int tmp=Q.front();
          Q.pop();
          for(int i=0;i<Vers;i++){
            if(edge[tmp][i]!=noEdge){
              inDgree[i]--;
              if(!inDgree[i]){
                Q.push(i);
                topsort.push_back(i);
                cnt++;
                if(cnt==Vers) return 1;
              }
            }
          }
        }
        return 0;
       }
       bool TopSort(vector<int> &topsort,void (*visit)(TypeOfVer ele,int num)){ //拓扑排序
        int *inDgree=new int[Vers];
        topsort.resize(0);
        int cnt=0;
        queue<int> Q;
        for(int i=0;i<Vers;i++){
          inDgree[i]=Get_InDegree(i);
          if(!inDgree[i]){
            Q.push(i);
            topsort.push_back(i);
            visit(ver[i],cnt);
            cnt++;
            if(cnt==Vers) return 1;
          }
        }
        while(!Q.empty()){
          int tmp=Q.front();
          Q.pop();
          for(int i=0;i<Vers;i++){
            if(edge[tmp][i]!=noEdge){
              inDgree[i]--;
              if(!inDgree[i]){
                Q.push(i);
                topsort.push_back(i);
                visit(ver[i],cnt);
                cnt++;
                if(cnt==Vers) return 1;
              }
            }
          }
        }
        return 0;
       }
       bool isDAG(){ //判定有向无环图
        vector<int> tps;
        if(TopSort_Pure(tps)) return 1;
        return 0;
       }
       bool U_Judge_Cir(){  //判定无向图有无环,0表示未入队，1表示在队伍中，2表示已出队
        int *flag=new int[Vers];
        for(int i=0;i<Vers;i++){
          flag[i]=0;
        }
        queue<int> Q;
        for(int i=0;i<Vers;i++){
          if(flag[i]) continue;
          Q.push(i);
          flag[i]=1;
          while(!Q.empty()){
            int tmp=Q.front();
            Q.pop();
            flag[tmp]=2;
            for(int i=0;i<Vers;i++){
              if(edge[tmp][i]!=noEdge){
                if(flag[i]==1) return 1;
                if(flag[i]==2) continue;
                flag[i]=1;
                Q.push(i);
              }
            }
          }
        }
        return 0;
       }
       bool Prim(int u, int adjvex[], TypeOfEdge lowcost[]){
        if(hasDirection()) return 0;  //有向网不行
        int cnt=0,*flag=new int[Vers];
        for(int i=0;i<Vers;i++){
          flag[i]=0;
          adjvex[i]=-1;
          lowcost[i]=-1;
        }
        cnt++;
        flag[u]=1;
        while(cnt<Vers){
          int min=-1,min_adjvex1=-1,min_adjvex2=-1;
          for(int i=0;i<Vers;i++){
            if(flag[i]){
              int eg=GetFirstAdjVex(i);
              while(eg!=-1){
                if(!flag[eg]){
                  if(min==-1 || edge[i][eg]<min){
                    min=edge[i][eg];
                    min_adjvex2=eg;
                    min_adjvex1=i;
                  }
                }
                eg=GetNextAdjVex(i,eg);
              }
            }
          }
          if(min==-1){  // 图不连通
            cout<<"Not related";
            return 0;
          }
          cnt++;
          lowcost[min_adjvex2]=min;
          adjvex[min_adjvex2]=min_adjvex1;    // 新链接的结点为被指向的结点
          flag[min_adjvex2]=1;
        }
        return 1;
       }
       void printPrim(int u){
        int adjvex[Vers],lowcost[Vers],cnt=0;
        Prim(u,adjvex,lowcost);
        for(int i=0;i<Vers;i++){
          if(i==u) continue;
          if(cnt) cout<<",";
          cnt++;
          cout<<"("<<ver[adjvex[i]]<<","<<ver[i]<<","<<lowcost[i]<<")";
        }
       }
};

template<class TypeOfVer>
void visit(TypeOfVer ele,int num){
  if(!num){
    cout<<ele;
  } else {
    cout<<"->"<<ele;
  }
  return ;
}

template<class TypeOfVer>
// 依次输入图类型，结点数，结点集，有权图则输入NEflag，无权图则不输入NEflag，
void inputAdjmatrix_Graph(string &kind,int &vers,TypeOfVer* &ver,int &NEflag){
  cin>>kind>>vers;
  cin.get();
  ver=new TypeOfVer[vers];
  TypeOfVer tmp;
  string s;
  getline(cin,s);
  stringstream ss(s);
  for(int i=0;i<vers;i++){
    ss>>tmp;
    ver[i]=tmp;
  }
  if(kind=="DN" || kind=="UDN") //有权重则输入NEflag
    cin>>NEflag;
  else NEflag=0;
  return ;
}

// 输入边数和边集
void inputAdjmatrix_Graph_Edges(int &edges,int** &edge){
  cin>>edges;
  edge=new int*[edges];
  int a,b;
  for(int i=0;i<edges;i++){
    cin>>a>>b;
    edge[i]=new int[2];
    edge[i][0]=a;
    edge[i][1]=b;
  }
  return ;
}

// 输入权集
void inputAdjmatrix_Graph_Weights(int &edges,int* &w){
  string s;
  getline(cin,s);
  stringstream ss(s);
  w=new int[edges];
  int tmp;
  for(int i=0;i<edges;i++){
    ss>>tmp;
    w[i]=tmp;
  }
  return ;
}

邻接表

#include <iomanip>
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int MAXN=1000;

/* 边表的结点定义 */
template<class TypeOfEdge>
struct edgeNode{
    int data;
    bool hasWeight;
    TypeOfEdge weight;
    edgeNode<TypeOfEdge> *next;
    // 构造函数，用于构造其他结点（无权图）,函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    edgeNode(const int &d, edgeNode<TypeOfEdge> *ptr = NULL){
      next = ptr;
      data = d;
      hasWeight=0;
    }
    // 构造函数，用于构造其他结点（带权图）,函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    edgeNode(const int &d, const TypeOfEdge &w, edgeNode<TypeOfEdge> *ptr = NULL){
      next = ptr;
      data = d;
      weight = w;   //权值默认为0
      hasWeight=1;
    }
    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(){ head=NULL; }
    verNode(TypeOfVer e,edgeNode<TypeOfEdge> *h = NULL){
      head = h;
      ver=e;
    } 
    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;          //边数
      verNode<TypeOfVer,TypeOfEdge> *verList; //顶点表
      string GraphKind;     //图的种类标志
      bool Delete_Edge( int u, int v ); 
      bool DFS(int u, int &num, int* visited,bool (*visit)(TypeOfVer data,int num)){ //DFS遍历（递归部分）
        int p=GetFirstAdjVex(u);
        while(p!=-1){
          if(visited[p]){
            p=GetNextAdjVex(u,p);
            continue;
          }
          visited[p]=1;
          visit(verList[p].getVer(),num);
          num++;
          if(num==Vers) return 1;
          if(DFS(p,num,visited,visit)) return 1;
          p=GetNextAdjVex(u,p);
        }
        return 0;
      }
      bool CheckRoute_Cursive(int u, int v,int *visited){
        int p=GetFirstAdjVex(u);
        while(p!=-1){
          if(p==v) return 1;
          if(visited[p]){
            p=GetNextAdjVex(u,p);
            continue;
          }
          visited[p]=1;
          if(CheckRoute_Cursive(p,v,visited)) return 1;
          p=GetNextAdjVex(u,p);
        }
        return 0;
      }
    public:
      adjlist_graph( const string &kd, int vSize, const TypeOfVer* d):GraphKind(kd),Vers(vSize){ //构造函数构造一个只有结点没有边的图。
        verList=new verNode<TypeOfVer,TypeOfEdge>[MAXN];
        for(int i=0;i<Vers;i++){
          verList[i].setVer(d[i]);
        }
        Edges=0;
      } 
      adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer *d, int **e):GraphKind(kd),Vers(vSize){ //构造函数构造一个无权图。5个参数的含义：图的类型、结点数、边数、结点集和边集 
        verList=new verNode<TypeOfVer,TypeOfEdge>[MAXN];
        Edges=0;
        for(int i=0;i<Vers;i++){
          verList[i].setVer(d[i]);
        }
        for(int i=0;i<eSize;i++){
          int a=e[i][0],b=e[i][1];
          Insert_Edge(a,b);
        }
      }
      adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer* d, int **e, const TypeOfEdge *w):GraphKind(kd),Vers(vSize){ //构造函数构造一个有权图。
        verList=new verNode<TypeOfVer,TypeOfEdge>[MAXN];
        Edges=0;
        for(int i=0;i<Vers;i++){
          verList[i].setVer(d[i]);
        }
        for(int i=0;i<eSize;i++){
          int a=e[i][0],b=e[i][1];
          Insert_Edge(a,b,w[i]);
        }
      }
      bool GraphisEmpty() { return Vers == 0; }  //判断图空否
      string GetGraphKind(){ return GraphKind; }

      bool GetVer(int u, TypeOfVer &data){ //取得G中指定顶点的值 
        if(u<0 || u>=Vers) return 0;
        data=verList[u].getVer();
        return 1;
      }

      bool GetWeight(int u, int v, int &w){
        if(!ExistEdge(u,v) || !hasWeight()) return 0;
        edgeNode<TypeOfEdge> *p=verList[u].getHead();
        while(p){
          if(p->getData()==v){
            w=p->getWeight();
            return 1;
          }
          p=p->next;
        }
        return 0;
      }

      int GetFirstAdjVex(int u){ //返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1
        if(u<0 || u>=Vers) return -1;
        edgeNode<TypeOfEdge> *p=verList[u].getHead();
        if(!p) return -1;
        return p->getData();
      }

      int GetNextAdjVex(int u, int v){ //返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。若顶点在G中没有邻接顶点，则返回false
        if(u<0 || u>=Vers) return -1;
        edgeNode<TypeOfEdge> *p=verList[u].getHead();
        while(p && p->getData()!=v) p=p->next;
        if(!p || !(p->next)) return -1;
        return p->next->getData();
      }

      bool PutVer(int u, TypeOfVer data){ //对G中指定顶点赋值
        if(u<0 || u>=Vers) return -1;
        verList[u].setVer(data);
        return 1;
      } 

      bool InsertVer(const TypeOfVer &data){ //往G中添加一个顶点 
        if(Vers==MAXN) return 0;  // 超量了
        verList[Vers].setVer(data);
        Vers++;
        return 1;
      }

      int LocateVer(TypeOfVer data){ //返回G中指定顶点的位置，-1表示未找到
        for(int i=0;i<Vers;i++){
          if(verList[i].getVer()==data) return i;
        }
        return -1;
      }

      bool ExistEdge(int u, int v){ // 两边是否相邻
      if(u<0 || u>=Vers || v<0 || v>=Vers) return 0;
        edgeNode<TypeOfEdge> *p=verList[u].getHead();
        while(p){
          if(p->getData()==v) return 1;
          p=p->next;
        }
        return 0;
      }

      bool PrintVer(){  //输出顶点集
        if(GraphisEmpty()) return 0;
        for(int i=0;i<Vers;i++){
          if(i) cout<<" ";
          cout<<verList[i].getVer();
        }
        return 1;
      } 

      bool PrintTable(){  // 输出邻接表
        if(GraphisEmpty()) return 0;
        for(int i=0;i<Vers;i++){
          if(i) cout<<endl;
          cout<<verList[i].getVer();
          edgeNode<TypeOfEdge> *p=verList[i].getHead();
          while(p){
            cout<<"->"<<p->getData();
            if(hasWeight()) cout<<"("<<p->getWeight()<<")";
            p=p->next;
          }
          cout<<"->"<<"nullptr";
        }
        return 1;
      }

      bool PrintAdjList();  //输出邻接矩阵 

      int GetVerNum(){ return Vers;}    //取得当前顶点数 

      int GetEdgeNum(){ return Edges;}  //取得当前边数 

      bool Insert_Edge(int u, int v){ //无权图插入一条边,边表位序从大到小
        if(u<0 || u>=Vers || v<0 || v>=Vers || ExistEdge(u,v)) return 0;
        Edges++;
        edgeNode<TypeOfEdge> *p=verList[u].getHead(),*p1=new edgeNode<TypeOfEdge>(v);
        verList[u].setHead(p1);
        p1->SetLink(p);
        if(!hasDirection()){
          p=verList[v].getHead();
          p1=new edgeNode<TypeOfEdge>(u);
          verList[v].setHead(p1);
          p1->SetLink(p);
        }
        return 1;
      }

      bool Insert_Edge(int u, int v, TypeOfEdge w){ //有权图插入一条边
        if(u<0 || u>=Vers || v<0 || v>=Vers || ExistEdge(u,v)) return 0;
        Edges++;
        edgeNode<TypeOfEdge> *p=verList[u].getHead(),*p1=new edgeNode<TypeOfEdge>(v,w);
        verList[u].setHead(p1);
        p1->SetLink(p);
        if(!hasDirection()){
          p=verList[v].getHead();
          p1=new edgeNode<TypeOfEdge>(u,w);
          verList[v].setHead(p1);
          p1->SetLink(p);
        }
        return 1;
      }

      bool DeleteVer(const int num){ //往G中删除一个顶点 
        if(num<0 || num >=Vers) return 0;
        int i=num;
        edgeNode<TypeOfEdge> *p=verList[i].getHead(),*p1;
        while(p){
          p1=p->next;
          delete p;
          p=p1;
          Edges--;
        }
        for(int j=i;j<Vers-1;j++){
          verList[j]=verList[j+1];
        }
        verList[Vers-1].setHead(NULL);
        Vers--;
        for(int j=0;j<Vers;j++){    // 清除以i为目标的边
          p=verList[j].getHead();
          while(p && p->getData()==i){
            p1=p->next;
            delete p;
            verList[j].setHead(p1);
            p=p1;
            if(hasDirection()) Edges--;
          }
          if(!p) continue;
          if(p->getData()>i) p->SetData(p->getData()-1);
          p1=p;
          p=p->next;
          while(p){
            if(p->getData()==i){
              p1->SetLink(p->next);
              delete p;
              p=p1->next;
              if(hasDirection()) Edges--;
              continue;
            } else if(p->getData()>i){
              p->SetData(p->getData()-1);
            }
            p1=p;
            p=p->next;
          }
        }
        return 1;
      }

      bool DeleteEdge( int u, int v ){ //删除边 (外壳：有向（删除1条边）， 无向（删除2条边））
        if(!ExistEdge(u,v)) return 0;
        edgeNode<TypeOfEdge> *p=verList[u].getHead(),*p1;
        if(p->getData()==v){
          verList[u].setHead(p->next);
          delete p;
          Edges--;
          if(hasDirection()) return 1;
          p=verList[v].getHead();
          if(p->getData()==u){
            verList[v].setHead(p->next);
            delete p;
            return 1;
          } else {
            p1=p;
            p=p->next;
            while(p){
              if(p->getData()==u){
                p1->SetLink(p->next);
                delete p;
                return 1;
              } else {
                p1=p;
                p=p->next;
              }
            }
          }
        } else {
          p1=p;
          p=p->next;
          while(p){
            if(p->getData()==v){
              p1->SetLink(p->next);
              delete p;
              Edges--;
              if(hasDirection()) return 1;
              p=verList[v].getHead();
              if(p->getData()==u){
                verList[v].setHead(p->next);
                delete p;
                return 1;
              } else {
                p1=p;
                p=p->next;
                while(p){
                  if(p->getData()==u){
                    p1->SetLink(p->next);
                    delete p;
                    return 1;
                  } else {
                    p1=p;
                    p=p->next;
                  }
                }
                break;
              }
            } else {
              p1=p;
              p=p->next;
            }
          }
        }
        return 0;
      }
      bool hasDirection(){    // 判断有无向
        if(GraphKind=="DG" || GraphKind=="DN") return 1;
        return 0;
      }
      bool hasWeight(){    // 判断有无权
        if(GraphKind=="UDN" || GraphKind=="DN") return 1;
        return 0;
      }
      void DFS_Traverse(int u,bool (*visit)(TypeOfVer data,int num)){ //DFS遍历（外壳部分）遍历时，仅从该点出发遍历整个图，如果图不连通，则只遍历一个子图
        int *visited=new int[Vers];
        for(int i=0;i<Vers;i++){
          visited[i]=0;
        }
        int cnt=0;
        visited[u]=1;
        visit(verList[u].getVer(),cnt);
        cnt++;
        DFS(u,cnt,visited,visit);
        delete[] visited;
        return ;
      }

      void BFS_Traverse(int u,bool (*visit)(TypeOfVer data,int num)){ //BFS遍历
        int cnt=0,*visited=new int[Vers];
        for(int i=0;i<Vers;i++){
          visited[i]=0;
        }
        visited[u]=1;
        visit(verList[u].getVer(),cnt);
        cnt++;
        queue<int> Q;
        Q.push(u);
        while(!Q.empty()){
          int p,tmp=Q.front();
          Q.pop();
          p=GetFirstAdjVex(tmp);
          while(p!=-1){
            if(visited[p]){
              p=GetNextAdjVex(tmp,p);
              continue;
            }
            visited[p]=1;
            visit(verList[p].getVer(),cnt);
            cnt++;
            if(cnt==Vers) return ;
            Q.push(p);
          }
        }
        delete[] visited;
        return ;
      }

      ~adjlist_graph(){ //析构函数 
        edgeNode<TypeOfEdge> *p,*p1;
        for(int i=0;i<Vers;i++){
          p=verList[i].getHead();
          while(p){
            p1=p->next;
            delete p;
            p=p1;
          }
        }
        delete[] verList;
      }
      int Get_Degree(int u){  // 出度或度,-1表示出错
        if(u<0 || u>=Vers) return -1;
        edgeNode<TypeOfEdge> *p=verList[u].getHead();
        int cnt=0;
        while(p){
          cnt++;
          p=p->next;
        }
        return cnt;
      }
      int Get_InDegree(int u){  // 入度,-1表示出错
        if(!hasDirection() || u<0 || u>=Vers) return -1;
        edgeNode<TypeOfEdge> *p;
        int cnt=0;
        for(int i=0;i<Vers;i++){
          if(i==u) continue;
          p=verList[i].getHead();
          while(p){
            if(p->getData()==u) cnt++;  // 考虑多条边
            p=p->next;
          }

        }
        return cnt;
      }
      bool CheckRoute(int u, int v){  // 检查有无路径
        int *visited=new int[Vers];
        for(int i=0;i<Vers;i++){
          visited[i]=0;
        }
        visited[u]=1;
        if(CheckRoute_Cursive(u,v,visited)){
          delete[] visited;
          return 1;
        } else {
          delete[] visited;
          return 0;
        }
      }
      bool TopSort(int &num, vector<int> &topsort,bool (*visit)(TypeOfVer data,int num)){  //拓扑排序,num统计排序的数量,仅限有向图
        if(!hasDirection()) return 0;
        topsort.resize(0);
        num=0;
        int *idg=new int[Vers];
        queue<int> Q;
        for(int i=0;i<Vers;i++) idg[i]=0;
        edgeNode<TypeOfEdge> *p;
        for(int i=0;i<Vers;i++){
          p=verList[i].getHead();
          while(p){
            idg[p->getData()]++;
            p=p->next;
          }
        }
        for(int i=0;i<Vers;i++){
          if(!idg[i]){
            Q.push(i);
            topsort.push_back(i);
            visit(verList[i].getVer(),num);
            num++;
            if(num==Vers) return 1;
          }
        }
        while(!Q.empty()){
          int pt,tmp=Q.front();
          Q.pop();
          pt=GetFirstAdjVex(tmp);
          p=verList[tmp].getHead();
          while(p){
            idg[p->getData()]--;
            p=p->next;
          }
          while(pt!=-1){
            if(!idg[pt]){
              visit(verList[pt].getVer(),num);
              num++;
              topsort.push_back(pt);
              if(num==Vers) return 1;
              Q.push(pt);
            }
            pt=GetNextAdjVex(tmp,pt);
          }
        }
        return 0;
      }
      bool TopSort_Pure(int &num, vector<int> &topsort){  //拓扑排序,num统计排序的数量,仅限有向图
        if(!hasDirection()) return 0;
        topsort.resize(0);
        num=0;
        int *idg=new int[Vers];
        queue<int> Q;
        for(int i=0;i<Vers;i++) idg[i]=0;
        edgeNode<TypeOfEdge> *p;
        for(int i=0;i<Vers;i++){
          p=verList[i].getHead();
          while(p){
            idg[p->getData()]++;
            p=p->next;
          }
        }
        for(int i=0;i<Vers;i++){
          if(!idg[i]){
            Q.push(i);
            topsort.push_back(i);
            num++;
            if(num==Vers) return 1;
          }
        }
        while(!Q.empty()){
          int pt,tmp=Q.front();
          Q.pop();
          pt=GetFirstAdjVex(tmp);
          p=verList[tmp].getHead();
          while(p){
            idg[p->getData()]--;
            p=p->next;
          }
          while(pt!=-1){
            if(!idg[pt]){
              num++;
              topsort.push_back(pt);
              if(num==Vers) return 1;
              Q.push(pt);
            }
            pt=GetNextAdjVex(tmp,pt);
          }
        }
        return 0;
      }
      bool isDAG(){ //有向图判断有无回路
        int num=0;
        vector<int> tps;
        if(TopSort_Pure(num,tps)) return 1;
        return 0;
      }
      bool U_Judge_Cir(){ // 无向网有无回路,0表示未访问,1表示已在队列中,2表示已经出列
        int *flag=new int[Vers];
        for(int i=0;i<Vers;i++){
          flag[i]=0;
        }
        queue<int> Q;
        for(int i=0;i<Vers;i++){
          if(flag[i]) continue;
          Q.push(i);
          flag[i]=1;
          while(!Q.empty()){
            int p,tmp=Q.front();
            Q.pop();
            flag[tmp]=2;
            p=GetFirstAdjVex(tmp);
            while(p!=-1){
              if(flag[p]==2){
                p=GetNextAdjVex(tmp,p);
                continue;
              }
              if(flag[p]==1){
                return 1;
              }
              flag[p]=1;
              Q.push(p);
              p=GetNextAdjVex(tmp,p);
            }
          }
        }
        return 0;
      }
};

template<class TypeOfVer>
bool visit(TypeOfVer data,int num){
  if(num) cout<<"->";
  cout<<data;
  return 1;
}

// 依次输入图类型，结点数，结点集
template<class TypeOfVer>
void inputAdjlist_Graph(string &kind,int &vers,TypeOfVer* &ver){
  cin>>kind>>vers;
  cin.get();
  ver=new TypeOfVer[vers];
  TypeOfVer tmp;
  string s;
  getline(cin,s);
  stringstream ss(s);
  for(int i=0;i<vers;i++){
    ss>>tmp;
    ver[i]=tmp;
  }
  return ;
}

// 输入边数和边集
void inputAdjlist_Graph_Edges(int &edges,int** &edge){
  cin>>edges;
  edge=new int*[edges];
  int a,b;
  for(int i=0;i<edges;i++){
    cin>>a>>b;
    edge[i]=new int[2];
    edge[i][0]=a;
    edge[i][1]=b;
  }
  return ;
}

// 输入权集
void inputAdjlist_Graph_Weights(int &edges,int* &w){
  string s;
  getline(cin,s);
  stringstream ss(s);
  w=new int[edges];
  int tmp;
  for(int i=0;i<edges;i++){
    ss>>tmp;
    w[i]=tmp;
  }
  return ;
}

iostream格式控制

需要包含头文件"iomanip"

setw(5) 默认用空格填充，只对下一个输出生效，填充默认在左边，提前设置 cout.flags(ios::left) 可以填充在右侧，flags设置对后面的输出流一直生效，

参考:[

C++的cin/cout高阶格式化操作

]

邻接矩阵应用

以下主函数部分声明的二维数组 **edge 也要记得释放内存

1-邻接矩阵：构造只有结点没有边的图

// 依次输入图类型，结点数，结点集，有权图则输入NEflag，无权图则不输入NEflag，
void inputAdjmatrix_Graph(string &kind,int &vers,int* &ver,int &NEflag){
  cin>>kind>>vers;
  cin.get();
  ver=new int[vers];
  int tmp;
  string s;
  getline(cin,s);
  stringstream ss(s);
  for(int i=0;i<vers;i++){
    ss>>tmp;
    ver[i]=tmp;
  }
  if(kind=="DN" || kind=="UDN") //有权重则输入NEflag
    cin>>NEflag;
  else NEflag=0;
  return ;
}

int main(){
  string kind;
  int vers,*ver,NEflag;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  adjmatrix_graph<int,int> AG(kind,vers,ver,NEflag);
  cout<<AG.GetGraphKind()<<endl;
  AG.printVers();
  cout<<endl<<endl;
  AG.PrintMatrix();
  delete[] ver;
  return 0;
}

2-邻接矩阵：构造无权图

// 依次输入图类型，结点数，结点集，有权图则输入NEflag，无权图则不输入NEflag，
void inputAdjmatrix_Graph(string &kind,int &vers,int* &ver,int &NEflag){
  cin>>kind>>vers;
  cin.get();
  ver=new int[vers];
  int tmp;
  string s;
  getline(cin,s);
  stringstream ss(s);
  for(int i=0;i<vers;i++){
    ss>>tmp;
    ver[i]=tmp;
  }
  if(kind=="DN" || kind=="UDN") //有权重则输入NEflag
    cin>>NEflag;
  else NEflag=0;
  return ;
}

// 输入边数和边集
void inputAdjmatrix_Graph_Edges(int &edges,int** &edge){
  cin>>edges;
  edge=new int*[edges];
  int a,b;
  for(int i=0;i<edges;i++){
    cin>>a>>b;
    edge[i]=new int[2];
    edge[i][0]=a;
    edge[i][1]=b;
  }
  return ;
}

int main(){
  string kind;
  int vers,*ver,NEflag,edges,**edge;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  adjmatrix_graph<int,int> AG(kind,vers,edges,ver,edge);
  cout<<AG.GetGraphKind()<<endl;
  AG.printVers();
  cout<<endl<<endl;
  AG.PrintMatrix();
  delete[] ver;
  return 0;
}

3-邻接矩阵：构造有权图

// 依次输入图类型，结点数，结点集，有权图则输入NEflag，无权图则不输入NEflag，
void inputAdjmatrix_Graph(string &kind,int &vers,int* &ver,int &NEflag){
  cin>>kind>>vers;
  cin.get();
  ver=new int[vers];
  int tmp;
  string s;
  getline(cin,s);
  stringstream ss(s);
  for(int i=0;i<vers;i++){
    ss>>tmp;
    ver[i]=tmp;
  }
  if(kind=="DN" || kind=="UDN") //有权重则输入NEflag
    cin>>NEflag;
  else NEflag=0;
  return ;
}

// 输入边数和边集
void inputAdjmatrix_Graph_Edges(int &edges,int** &edge){
  cin>>edges;
  edge=new int*[edges];
  int a,b;
  for(int i=0;i<edges;i++){
    cin>>a>>b;
    edge[i]=new int[2];
    edge[i][0]=a;
    edge[i][1]=b;
  }
  return ;
}

// 输入权集
void inputAdjmatrix_Graph_Weights(int &edges,int* &w){
  string s;
  getline(cin,s);
  stringstream ss(s);
  w=new int[edges];
  int tmp;
  for(int i=0;i<edges;i++){
    ss>>tmp;
    w[i]=tmp;
  }
  return ;
}


int main(){
  adjmatrix_graph<int,int> *AG;
  string kind;
  int vers,*ver,NEflag,edges,**edge,*w;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<int,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<int,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cout<<AG->GetGraphKind()<<endl;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  delete[] ver;
  delete AG;
  return 0;
}

4-邻接矩阵：添加一个顶点

template<class TypeOfVer>
// 依次输入图类型，结点数，结点集，有权图则输入NEflag，无权图则不输入NEflag，
void inputAdjmatrix_Graph(string &kind,int &vers,TypeOfVer* &ver,int &NEflag){
  cin>>kind>>vers;
  cin.get();
  ver=new TypeOfVer[vers];
  TypeOfVer tmp;
  string s;
  getline(cin,s);
  stringstream ss(s);
  for(int i=0;i<vers;i++){
    ss>>tmp;
    ver[i]=tmp;
  }
  if(kind=="DN" || kind=="UDN") //有权重则输入NEflag
    cin>>NEflag;
  else NEflag=0;
  return ;
}

// 输入边数和边集
void inputAdjmatrix_Graph_Edges(int &edges,int** &edge){
  cin>>edges;
  edge=new int*[edges];
  int a,b;
  for(int i=0;i<edges;i++){
    cin>>a>>b;
    edge[i]=new int[2];
    edge[i][0]=a;
    edge[i][1]=b;
  }
  return ;
}

// 输入权集
void inputAdjmatrix_Graph_Weights(int &edges,int* &w){
  string s;
  getline(cin,s);
  stringstream ss(s);
  w=new int[edges];
  int tmp;
  for(int i=0;i<edges;i++){
    ss>>tmp;
    w[i]=tmp;
  }
  return ;
}


int main(){
  adjmatrix_graph<char,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  char *ver,tmp;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<char,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<char,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp;
  cout<<AG->GetGraphKind()<<endl;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  AG->InsertVer(tmp);
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  delete[] ver;
  delete AG;
  return 0;
}

5-邻接矩阵：指定顶点的位置

int main(){
  adjmatrix_graph<char,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  char *ver,tmp;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<char,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<char,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp;
  AG->printVers();
  cout<<endl<<AG->LocateVer(tmp);
  delete[] ver;
  delete AG;
  return 0;
}

6-邻接矩阵：顶点u的第一个邻接顶点

int main(){
  adjmatrix_graph<char,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  char *ver;
  int tmp;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<char,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<char,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  cout<<AG->GetFirstAdjVex(tmp);
  delete[] ver;
  delete AG;
  return 0;
}

7-邻接矩阵：顶点u的下一个邻接点

int main(){
  adjmatrix_graph<char,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  char *ver;
  int tmp1,tmp2;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<char,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<char,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1>>tmp2;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  cout<<AG->GetNextAdjVex(tmp1,tmp2);
  delete[] ver;
  delete AG;
  return 0;
}

8-图的邻接矩阵：深度优先遍历

template<class TypeOfVer>
void visit(TypeOfVer ele,int num){
  if(!num){
    cout<<ele;
  } else {
    cout<<"->"<<ele;
  }
  return ;
}
int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  AG->DFS_Traverse(tmp1,visit);
  delete[] ver;
  delete AG;
  return 0;
}

9-图的邻接矩阵：广度优先遍历

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  AG->BFS_Traverse(tmp1,visit);
  delete[] ver;
  delete AG;
  return 0;
}

10-邻接矩阵：无权图删除边

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1>>tmp2;
  AG->printVers();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  if(AG->Delete_Edge(tmp1,tmp2)){
    cout<<"true"<<endl<<AG->GetEdgeNum()<<endl;
    AG->PrintMatrix();
  } else {
    cout<<"false"<<endl<<AG->GetEdgeNum()<<endl;
    AG->PrintMatrix();
  }
  delete[] ver;
  delete AG;
  return 0;
}

11-邻接矩阵：有权图删除边

因为删除边的时候也不用权值，因此与无权图完全一致

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1>>tmp2;
  cout<<AG->GetGraphKind()<<endl;
  AG->printVers();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  if(AG->Delete_Edge(tmp1,tmp2)){
    cout<<"true"<<endl<<AG->GetEdgeNum()<<endl;
    AG->PrintMatrix();
  } else {
    cout<<"false"<<endl<<AG->GetEdgeNum()<<endl;
    AG->PrintMatrix();
  }
  delete[] ver;
  delete AG;
  return 0;
}

12-邻接矩阵：是否有路径

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1>>tmp2;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  if(AG->CheckRoute(tmp1,tmp2)) cout<<"true";
  else cout<<"false";
  delete[] ver;
  delete AG;
  return 0;
}

13-邻接矩阵：有向图顶点的入度

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl<<AG->Get_InDegree(tmp1);
  delete[] ver;
  delete AG;
  return 0;
}

14-邻接矩阵：求指定顶点的（出）度

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl<<AG->Get_Degree(tmp1);
  delete[] ver;
  delete AG;
  return 0;
}

15-邻接矩阵：顶点是否相邻

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1>>tmp2;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  if(AG->ExistEdge(tmp1,tmp2)) cout<<"true";
  else cout<<"false";
  delete[] ver;
  delete AG;
  return 0;
}

16-图的邻接矩阵ADT模板设计：有权图插入一条边

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2,tmp3;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1>>tmp2>>tmp3;
  cout<<AG->GetGraphKind()<<endl;
  AG->printVers();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  if(AG->Insert_Edge(tmp1,tmp2,tmp3)){
    cout<<"true"<<endl<<AG->GetEdgeNum()<<endl;
    AG->PrintMatrix();
  } else {
    cout<<"false"<<endl<<AG->GetEdgeNum()<<endl;
    AG->PrintMatrix();
  }

  delete[] ver;
  delete AG;
  return 0;
}

17-图的邻接矩阵ADT模板设计：无权图插入一条边

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2,tmp3;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp1>>tmp2;
  cout<<AG->GetGraphKind()<<endl;
  AG->printVers();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  if(AG->Insert_Edge(tmp1,tmp2)){
    cout<<"true"<<endl<<AG->GetEdgeNum()<<endl;
    AG->PrintMatrix();
  } else {
    cout<<"false"<<endl<<AG->GetEdgeNum()<<endl;
    AG->PrintMatrix();
  }

  delete[] ver;
  delete AG;
  return 0;
}

18-邻接矩阵：BFS实现拓扑排序

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2,tmp3;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  // cin>>tmp1>>tmp2;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  vector<int> topsort;
  if(AG->TopSort(topsort,visit)){
    cout<<endl<<"true";
  } else {  //拓扑排序为零个则减少换行
    if(!topsort.size()) cout<<"false";
    else
      cout<<endl<<"false";
  }

  delete[] ver;
  delete AG;
  return 0;
}

19-邻接矩阵：有向无环图（DAG）的判断

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2,tmp3;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  // cin>>tmp1>>tmp2;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  vector<int> topsort;
  if(AG->isDAG()){
    cout<<"true";
  } else {  //拓扑排序为零个则减少换行
    cout<<"false";
  }

  delete[] ver;
  delete AG;
  return 0;
}

20-邻接矩阵：无向图回路的判断

int main(){
  adjmatrix_graph<string,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  string *ver;
  int tmp1,tmp2,tmp3;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<string,int>(kind,vers,edges,ver,edge);  //不带权
  }
  // cin>>tmp1>>tmp2;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  vector<int> topsort;
  if(AG->U_Judge_Cir()){
    cout<<"true";
  } else {  //拓扑排序为零个则减少换行
    cout<<"false";
  }

  delete[] ver;
  delete AG;
  return 0;
}

21-邻接矩阵：删除一个顶点

int main(){
  adjmatrix_graph<char,int> *AG;
  string kind;
  int vers,NEflag,edges,**edge,*w;
  char *ver,tmp;
  inputAdjmatrix_Graph(kind,vers,ver,NEflag);
  inputAdjmatrix_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjmatrix_Graph_Weights(edges,w);
    AG=new adjmatrix_graph<char,int>(kind,vers,edges,NEflag,ver,edge,w); //带权
  } else {
    AG=new adjmatrix_graph<char,int>(kind,vers,edges,ver,edge);  //不带权
  }
  cin>>tmp;
  cout<<AG->GetGraphKind()<<endl;
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  cout<<endl<<endl;
  AG->DeleteVer(tmp);
  AG->printVers();
  cout<<endl<<endl;
  AG->PrintMatrix();
  delete[] ver;
  delete AG;
  return 0;
}

邻接表应用

1-邻接表：构造只有顶点没有边的图

// 依次输入图类型，结点数，结点集
template<class TypeOfVer>
void inputAdjlist_Graph(string &kind,int &vers,TypeOfVer* &ver){
  cin>>kind>>vers;
  cin.get();
  ver=new TypeOfVer[vers];
  char tmp;
  string s;
  getline(cin,s);
  stringstream ss(s);
  for(int i=0;i<vers;i++){
    ss>>tmp;
    ver[i]=tmp;
  }
  return ;
}

int main(){
  string kind;
  int vers;
  char *ver;
  inputAdjlist_Graph(kind,vers,ver);
  adjlist_graph<char,int> AG(kind,vers,ver);
  cout<<AG.GetGraphKind()<<endl;
  AG.PrintVer();
  cout<<endl;
  AG.PrintTable();
  delete[] ver;
  return 0;
}

2-邻接表：构造无权图

// 输入边数和边集
void inputAdjlist_Graph_Edges(int &edges,int** &edge){
  cin>>edges;
  edge=new int*[edges];
  int a,b;
  for(int i=0;i<edges;i++){
    cin>>a>>b;
    edge[i]=new int[2];
    edge[i][0]=a;
    edge[i][1]=b;
  }
  return ;
}

int main(){
  string kind;
  int vers,edges,** edge;
  char *ver;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  adjlist_graph<char,int> AG(kind,vers,edges,ver,edge);
  cout<<AG.GetGraphKind()<<endl;
  AG.PrintVer();
  cout<<endl;
  AG.PrintTable();

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

3-邻接表：构造有权图

// 依次输入图类型，结点数，结点集
template<class TypeOfVer>
void inputAdjlist_Graph(string &kind,int &vers,TypeOfVer* &ver){
  cin>>kind>>vers;
  cin.get();
  ver=new TypeOfVer[vers];
  char tmp;
  string s;
  getline(cin,s);
  stringstream ss(s);
  for(int i=0;i<vers;i++){
    ss>>tmp;
    ver[i]=tmp;
  }
  return ;
}

// 输入边数和边集
void inputAdjlist_Graph_Edges(int &edges,int** &edge){
  cin>>edges;
  edge=new int*[edges];
  int a,b;
  for(int i=0;i<edges;i++){
    cin>>a>>b;
    edge[i]=new int[2];
    edge[i][0]=a;
    edge[i][1]=b;
  }
  return ;
}

// 输入权集
void inputAdjlist_Graph_Weights(int &edges,int* &w){
  string s;
  getline(cin,s);
  stringstream ss(s);
  w=new int[edges];
  int tmp;
  for(int i=0;i<edges;i++){
    ss>>tmp;
    w[i]=tmp;
  }
  return ;
}

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cout<<AG->GetGraphKind()<<endl;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

4-邻接表：添加一个顶点

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  char tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1;
  cout<<AG->GetGraphKind()<<endl;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl;
  AG->InsertVer(tmp1);
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

5-邻接表：指定顶点的位置

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  char tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1;
  cout<<AG->GetGraphKind()<<endl;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl;
  cout<<AG->LocateVer(tmp1);

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

6-邻接表：删除一个顶点

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1;
  cout<<AG->GetGraphKind()<<endl;
  AG->PrintVer();
  cout<<endl<<AG->GetVerNum()<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintTable();
  cout<<endl<<endl;

  AG->DeleteVer(tmp1);

  AG->PrintVer();
  cout<<endl<<AG->GetVerNum()<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintTable();

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

删个顶点有一堆参数要跟着调整，不是一般的麻烦，要注意如果是有向图删除指向 i 的边时也要边数也要减一

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

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl;

  cout<<AG->GetFirstAdjVex(tmp1);

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

8-邻接表：顶点u的下一个邻接点

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1>>tmp2;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl;

  cout<<AG->GetNextAdjVex(tmp1,tmp2);

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

9-邻接表：无权图插入边

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1>>tmp2;
  AG->PrintVer();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintTable();
  cout<<endl<<endl;

  if(AG->Insert_Edge(tmp1,tmp2))
    cout<<"true"<<endl;
  else cout<<"false"<<endl;
  AG->PrintVer();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintTable();

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

10-邻接表：有权图插入边

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1>>tmp2>>tmp3;
  AG->PrintVer();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintTable();
  cout<<endl<<endl;

  if(AG->Insert_Edge(tmp1,tmp2,tmp3))
    cout<<"true"<<endl;
  else cout<<"false"<<endl;
  AG->PrintVer();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintTable();

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

11-邻接表：删除边

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1>>tmp2;
  AG->PrintVer();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintTable();
  cout<<endl<<endl;

  if(AG->DeleteEdge(tmp1,tmp2))
    cout<<"true"<<endl;
  else cout<<"false"<<endl;
  AG->PrintVer();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintTable();

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

12-邻接表：两个顶点是否相邻

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1>>tmp2;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl;
  if(AG->ExistEdge(tmp1,tmp2)){
    cout<<"true";
  } else cout<<"false";

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

13-邻接表：求指定顶点的（出）度

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl<<AG->Get_Degree(tmp1);

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

14-邻接表：有向图指定顶点的入度

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl<<AG->Get_InDegree(tmp1);

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

15-邻接表：是否有路径

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1>>tmp2;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl;
  if(AG->CheckRoute(tmp1,tmp2)) cout<<"true";
  else cout<<"false";

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

16-图的邻接表：深度优先遍历

int main(){
  string kind;
  int vers,edges,** edge,* w;
  string *ver;
  adjlist_graph<string,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<string,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<string,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl;
  AG->DFS_Traverse(tmp1,visit);

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

17-图的邻接表：广度优先遍历

int main(){
  string kind;
  int vers,edges,** edge,* w;
  string *ver;
  adjlist_graph<string,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<string,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<string,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl;
  AG->BFS_Traverse(tmp1,visit);

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

18-邻接表：BFS实现拓扑排序

int main(){
  string kind;
  int vers,edges,** edge,* w;
  string *ver;
  adjlist_graph<string,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<string,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<string,int>(kind,vers,edges,ver,edge);
  }
  // cin>>tmp1;
  AG->PrintVer();
  cout<<endl<<endl;
  AG->PrintTable();
  cout<<endl<<endl;
  vector<int> tps;
  int cn=0;
  if(AG->TopSort(cn,tps,visit)){
    cout<<endl<<"true";
  } else {
    if(cn) cout<<endl;
    cout<<"false";
  }

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

19-邻接表：有权图获取边的权值

int main(){
  string kind;
  int vers,edges,** edge,* w;
  char *ver;
  adjlist_graph<char,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<char,int>(kind,vers,edges,ver,edge);
  }
  cin>>tmp1>>tmp2;
  AG->PrintVer();
  cout<<endl<<AG->GetEdgeNum()<<endl;
  AG->PrintTable();
  cout<<endl<<endl;

  int wNum;
  if(AG->GetWeight(tmp1,tmp2,wNum))
    cout<<"true"<<endl<<wNum;
  else cout<<"false"<<endl;

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

20-邻接表：无向图（网）回路

int main(){
  string kind;
  int vers,edges,** edge,* w;
  string *ver;
  adjlist_graph<string,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<string,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<string,int>(kind,vers,edges,ver,edge);
  }
  // cin>>tmp1;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl;
  if(AG->isDAG()) cout<<"true";
  else cout<<"false";

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}

21-邻接表：无向图（网）回路

int main(){
  string kind;
  int vers,edges,** edge,* w;
  string *ver;
  adjlist_graph<string,int> *AG;
  int tmp1;
  int tmp2,tmp3;
  inputAdjlist_Graph(kind,vers,ver);
  inputAdjlist_Graph_Edges(edges,edge);
  if(kind=="DN" || kind=="UDN"){
    cin.get();
    inputAdjlist_Graph_Weights(edges,w);
    AG=new adjlist_graph<string,int>(kind,vers,edges,ver,edge,w);
  } else {
    AG=new adjlist_graph<string,int>(kind,vers,edges,ver,edge);
  }
  // cin>>tmp1;
  AG->PrintVer();
  cout<<endl;
  AG->PrintTable();
  cout<<endl<<endl;
  if(AG->U_Judge_Cir()) cout<<"true";
  else cout<<"false";

  for(int i=0;i<edges;i++){
    delete[] edge[i];
  }
  delete[] edge;
  delete[] ver;
  return 0;
}