图的封装（C++）

一. 问题说明

    1.问题的简单描述

        将图和网的的创建和基本操作分封装到class

        用来熟悉此种数据结构和基于这种数据结构上的基本算法

       采用VS2010编译环境

     2.工作安排

  

二. 源代码

  1.文件stdafx.h

 

#pragma once
#include "targetver.h"
#include <stdio.h>
#include <tchar.h>
#include<iostream>
#include<string>
#include<string.h>
using namespace std;
/*
    以下完成图的存储结构
    (
        关键在于结构体的组合
    )
*/
#define INFINITY   INT_MAX // 用整形最大值代替∞
const int MAX_VERTEX_NUM=26;// 最大顶点个数
#define VRType  int  //顶点关系类型
#define InfoType  string//弧相关信息
#define VertexType string//顶点类型
enum GraphKind{DG,DN,UDG,UDN};// 有向图，有向网，无向图，无向网
typedef struct 
{
    VRType  adj; //adjacency  邻接
                 // 对图来说1(是)，0(否)表示相邻关系
                 // 对网来说为权值
    InfoType info;   //Info 信息
                      //该弧相关信息的指针
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
      //Arc  弧（边）
struct MGraph
{
    VertexType vex[MAX_VERTEX_NUM];   //顶点向量
    AdjMatrix arcs;   //邻接矩阵
    int vexnum,arcnum ;
    GraphKind kind;   //图的种类
};
class Graph
{  
private:
    MGraph G;
public:
    Graph();
    void CreateUDG();//创建无向图
    void CreateUDN();//创建无向网
    void CreateDG(); //创建有向图
    void CreateDN(); //创建有向网
    void CreateUDG_BYFile();//创建无向图,通过文件
    void CreateUDN_BYFile();//创建无向网,通过文件
    void CreateDG_BYFile(); //创建有向图,通过文件
    void CreateDN_BYFile(); //创建有向网,通过文件
    int LocateVex(VertexType u); //以顶点名称确定其邻接矩阵中的位置
    void  Display();//展示图或网的顶点向量，和邻接矩阵
};

   2.文件Graph_Matrix.cpp

    

#include "stdafx.h"
Graph::Graph()
{   
    cout<<"请输入图G的类型（ 有向图：0； 有向网：1； 无向图 ：2； 无向网 3；）"<<endl;
    scanf("%d",&G.kind);
    switch(G.kind)
    {
        case UDG: CreateUDG();
                  break;
        case UDN: CreateUDN();
                  break;
        case DG: CreateDG();
                  break;
        case DN: CreateDN();
                  break;
    }
}
void Graph::CreateUDG()
{
    /*采用数组（邻接矩阵）表示法，构造无向图G
      以边为输入单位，即输入边的俩个顶点
      关键在于判断输入顶点是否存在，返回其位置
    */
    int i,j,IncInfo;//是否包含边或弧的相关信息
    VertexType  va,vb;
    cout<<"请输入无向图的顶点数，边数，变是否包含其他信息（是：1； 否；0；）"<<endl;
    cin>>G.vexnum;//顶点数
    cin>>G.arcnum;//边数
    cin>>IncInfo;//是否具有相关信息的判断条件
    cout<<"请输入"<<G.vexnum<<"个顶点的的值"<<endl;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cin>>G.vex[i];
    }
    for(i=0; i<G.vexnum; i++)//初始化邻接矩阵
    {
        for(j=0; j<G.vexnum; j++)
        {
            G.arcs[i][j].adj=0;//图
            G.arcs[i][j].info="NULL";//初始化为空串
        }
    }
    cout<<"请输入"<<G.arcnum<<"条边的顶点1，顶点2："<<endl;
    for(int k=0; k<G.arcnum; k++)//按边录入信息
    {
        cin>>va;
        i=LocateVex(va);//查询下标,va所在的行坐标
        cin>>vb;
        j=LocateVex(vb);//查询下标,vb所在的行坐标
        G.arcs[i][j].adj=1;  //表示va 与 vb 相连  无向图
        G.arcs[j][i].adj=1;  //表示va与vb相连     无向图
        if(IncInfo)
        {
            cout<<"请输入该边相关信息"<<endl;
            cin>>G.arcs[i][j].info;  //输入字符串
            G.arcs[j][i].info=G.arcs[i][j].info;//对称阵
        }
    }
    G.kind=UDG;  //创建成功
}
void Graph::CreateUDN()
{
    /*
        原理和UDG相同，只是增加了权值的输入
    */
    int i,j,IncInfo;//是否包含边或弧的相关信息
    VertexType  va,vb;
    cout<<"请输入无向网的顶点数，边数，变是否包含其他信息（是：1； 否；0；）"<<endl;
    cin>>G.vexnum;//顶点数
    cin>>G.arcnum;//边数
    cin>>IncInfo;//是否具有相关信息的判断条件
    cout<<"请输入"<<G.vexnum<<"个顶点的的值"<<endl;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cin>>G.vex[i];
    }
    for(i=0; i<G.vexnum; i++)//初始化邻接矩阵
    {
        for(j=0; j<G.vexnum; j++)
        {
            G.arcs[i][j].adj=INFINITY;//网，无穷大表示不连接
            G.arcs[i][j].info="NULL";//初始化为空串
        }
    }
    for(int k=0; k<G.arcnum; k++)//按边录入信息
    {
        cout<<"请输入第"<<k+1<<"条边的顶点1，顶点2："<<endl;
        cin>>va;
        i=LocateVex(va);//查询下标,va所在的行坐标
        cin>>vb;
        j=LocateVex(vb);//查询下标,vb所在的行坐标
        cout<<"请输入权值"<<endl;
        cin>>G.arcs[i][j].adj;
        G.arcs[j][i].adj=G.arcs[i][j].adj;
        if(IncInfo)
        {
            cout<<"请输入该边相关信息"<<endl;
            cin>>G.arcs[i][j].info;  //输入字符串
            G.arcs[j][i].info=G.arcs[i][j].info;//对称阵
        }
    }
    G.kind=UDN;  //创建成功
}
void Graph::CreateDG()
{
    /*
        原理与UDG相同，邻接矩阵略有区别
    */
    int i,j,IncInfo;//是否包含边或弧的相关信息
    VertexType  va,vb;
    cout<<"请输入有向图的顶点数，边数，变是否包含其他信息（是：1； 否；0；）"<<endl;
    cin>>G.vexnum;//顶点数
    cin>>G.arcnum;//边数
    cin>>IncInfo;//是否具有相关信息的判断条件
    cout<<"请输入"<<G.vexnum<<"个顶点的的值"<<endl;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cin>>G.vex[i];
    }
    for(i=0; i<G.vexnum; i++)//初始化邻接矩阵
    {
        for(j=0; j<G.vexnum; j++)
        {
            G.arcs[i][j].adj=0;//图
            G.arcs[i][j].info="NULL";//初始化为空串
        }
    }
    cout<<"请输入"<<G.arcnum<<"条弧的弧头，弧尾："<<endl;
    for(int k=0; k<G.arcnum; k++)//按边录入信息
    {
        cin>>va;
        i=LocateVex(va);//查询下标,va所在的行坐标
        cin>>vb;
        j=LocateVex(vb);//查询下标,vb所在的行坐标
        G.arcs[j][i].adj=1;  //表示vb(弧尾) 与 vb（弧头） 相连,也就是说vb可以到达va，反之不一定  有向图 vb——>va
        if(IncInfo)
        {
            cout<<"请输入该弧相关信息"<<endl;
            cin>>G.arcs[i][j].info;  //输入字符串
            G.arcs[j][i].info=G.arcs[i][j].info;//对称阵
        }
    }
    G.kind=DG; //创建成功
}
void Graph::CreateDN()
{
    /*
        原理和DG相同，只是增加了权值的输入
    */
    int i,j,IncInfo;//是否包含边或弧的相关信息
    VertexType  va,vb;
    cout<<"请输入有向网的顶点数，边数，变是否包含其他信息（是：1； 否；0；）"<<endl;
    cin>>G.vexnum;//顶点数
    cin>>G.arcnum;//边数
    cin>>IncInfo;//是否具有相关信息的判断条件
    cout<<"请输入"<<G.vexnum<<"个顶点的的值"<<endl;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cin>>G.vex[i];
    }
    for(i=0; i<G.vexnum; i++)//初始化邻接矩阵
    {
        for(j=0; j<G.vexnum; j++)
        {
            G.arcs[i][j].adj=INFINITY;//网，无穷大表示不连接
            G.arcs[i][j].info="NULL";//初始化为空串
        }
    }
    for(int k=0; k<G.arcnum; k++)//按边录入信息
    {
        cout<<"请输入第"<<k+1<<"条弧的弧头，弧尾："<<endl;
        cin>>va;
        i=LocateVex(va);//查询下标,va所在的行坐标
        cin>>vb;
        j=LocateVex(vb);//查询下标,vb所在的行坐标
        cout<<"请输入权值"<<endl;
        cin>>G.arcs[j][i].adj;
        if(IncInfo)
        {
            cout<<"请输入该弧相关信息"<<endl;
            cin>>G.arcs[i][j].info;  //输入字符串
            G.arcs[j][i].info=G.arcs[i][j].info;//对称阵
        }
    }
    G.kind=DN;  //创建成功
}
int  Graph::LocateVex(VertexType u)//给定顶点值，返回顶点在顶点数组中的下标，方便按边录入信息
{
    for(int i=0; i<G.vexnum; i++)
    {
        if(G.vex[i]==u)
        {
            return i;
        }
    }
    return -1;
}
void Graph::Display()
{
    cout<<"顶点向量"<<endl;
    for(int i=0; i<G.vexnum; i++)
    {
        cout<<"顶点"<<G.vex[i]<<endl;
    }
    cout<<"邻接矩阵"<<endl;
    for(int i=0; i<G.vexnum; i++)
    {
        for(int j=0;j<G.vexnum;j++)
        {
            cout<<G.arcs[i][j].adj<<"	";
        }
        cout<<endl;
    }
    cout<<"顶点1  顶点2    信息"<<endl;
    if(G.kind>1) //对于无向图或者无向网来说，邻接矩阵是对称的
    {
        for(int i=0; i<G.vexnum; i++)
        {
            for(int j=0;j<i;j++)
            {
                if(G.arcs[i][j].adj!=0&&G.arcs[i][j].adj!=INFINITY)
                {
                    cout<<G.vex[i]<<"	";
                    cout<<G.vex[j]<<"	";
                    cout<<G.arcs[i][j].info<<endl;
                }
            }
        }
    }
    else//对于有向图或者有向网来说，邻接矩阵必须要全部输出
    {
        for(int i=0; i<G.vexnum; i++)
        {
            for(int j=0;j<G.vexnum;j++)
            {
                if(G.arcs[i][j].adj!=0&&G.arcs[i][j].adj!=INFINITY)
                {
                    cout<<G.vex[i]<<"	";
                    cout<<G.vex[j]<<"	";
                    cout<<G.arcs[i][j].info<<endl;
                }
            }
        }
    }
}
int _tmain(int argc, _TCHAR* argv[])
{   
    Graph g;
    g.Display();
    return 0;
}