数据结构：图（存储结构：邻接矩阵，邻接表）

图的概念

图是由两个集合V和E组成，记为G=(V,E)，其中V是顶点的有穷非空集合，E是V中顶点偶对的有穷集合，这些顶点偶对称为边。

图可分为有向图和无向图，有向图中顶点对是有序的，每条边都有起点和终点，称为从Vi到Vj的一条有向边；无向图的顶点对是无序的。

图的存储结构

图的存储结构有主要有邻接矩阵、邻接表、十字链表和邻接多重表，这里介绍邻接矩阵和邻接表两种方法。

邻接矩阵表示法：

邻接矩阵使用一个二维数组来表示顶点之间相邻关系的矩阵，若(Vi,Vj)之间有边，则A[i][j]=1,反之A[i][j]=0；若顶点之间有权值，则A[i][j]等于边的权值，无向图中A[i][j] = A[j][i];于是邻接矩阵的存储结构可以定义为:

class Graph_Form1{//邻接矩阵
    public:
    string *vex;//顶点表
    int **Form;
    int vexnum,arcnum;//vexnum代表顶点数，arcnum代表边数    
};

邻接矩阵的初始化算法步骤为：

1：输入总顶点数和总边数

2：依次输入顶点信息

3：初始化邻接矩阵，将每个权值初始化为-1

4：构造邻接矩阵，依次输入每条边依附的顶点以及边的权值

具体代码：

void CreateGraph1(Graph_Form1 &form){
    cout<<"请输入边的数量:"<<endl;
    cin>>form.arcnum;
    cout<<"请输入图的顶点数量:"<<endl;
    cin>>form.vexnum;
    form.vex = new string[form.vexnum];
    for(int i = 0; i < form.vexnum; i++){
        cin>>form.vex[i];//依次输入顶点
    }
    form.Form = new int*[form.vexnum];//定义二维数组存储图
    for(int i = 0; i < form.vexnum; i++){
        form.Form[i] = new int[form.vexnum];
        for(int j = 0; j < form.vexnum; j++){
            form.Form[i][j] = -1;
        }
    }
    string vex1, vex2;
    int w;
    for(int a = 0; a < form.arcnum; a++){//无向图的创建方法
        cout<<"请输入两个顶点以及他们之间的权值:"<<endl;
        cin>>vex1;
        cin>>vex2;
        cin>>w;
        int i = Locate_Vex1(form,vex1), j = Locate_Vex1(form,vex2);
        form.Form[i][j] = w;
        form.Form[j][i] = w;//要创建有向图将这句删除即可
    }
    for(int i = 0; i < form.vexnum; i++){
        for(int j = 0; j < form.vexnum; j++){
            cout<<form.Form[i][j]<<"  ";
        }
        cout<<endl;
    }
}

邻接矩阵表示法的优缺点：

优点：便于判断两个顶点之间是否有边，便于计算各个顶点的度，对于无向图，邻接矩阵第i行元素之和就是顶点i的度；对于有向图，第i行元素之和就是顶点i的出度，第i列元素之和就是顶点i的入度。

缺点：不便于增加和删除顶点；不便于统计边的数目；空间复杂度高

邻接表表示法

邻接表是图的一种链式存储结构，建立一个顶点表，每个顶点有数据域和指针域，若(Vi,Vj)顶点之间存在一条边，则Vi顶点指针域指向的结点数据域存储的数据为Vj顶点在顶点表中的位置与该条边的权值。

存储结构为：

class Arc_Node{//边结点
public:
    int state,weight;//state表示位置，weight为权值
    Arc_Node *next;
};
class Vex_Node{//顶点结点
public:
    string vex;
    Arc_Node *next;
};
class Graph_Form2{//邻接表
public:
    Vex_Node *Form;
    int vexnum, arcnum;//vexnum为顶点数量，arcnum为边的数量
};

初始化算法为:

void Create_Graph2(Graph_Form2 &form){//创建邻接表
    cout<<"请输入边的数量:"<<endl;
    cin>>form.arcnum;
    cout<<"请输入顶点数量:"<<endl;
    cin>>form.vexnum;
    form.Form = new Vex_Node[form.vexnum];
    for(int i = 0; i < form.vexnum; i++){//输入顶点
        form.Form[i].next = NULL;
        cout<<"请输入顶点:"<<endl;
        cin>>form.Form[i].vex;
    }
    string vex1,vex2;
    int weight;
    for(int a = 0; a < form.arcnum; a++){
        cout<<"请输入一条边依附的两个顶点及边的权值（有向图注意输入顺序）:"<<endl;
        cin>>vex1;
        cin>>vex2;
        cin>>weight;
        int i = Locate_Vex2(form,vex1), j = Locate_Vex2(form,vex2);
        Arc_Node *p1 = new Arc_Node();
        p1->state = j;
        p1->weight = weight;
        p1->next = form.Form[i].next;
        form.Form[i].next = p1;
        //下面为无向图需要的步骤
        Arc_Node *p2 = new Arc_Node();
        p2->state = i;
        p2->weight = weight;
        p2->next = form.Form[j].next;
        form.Form[j].next = p2;
    }
}

邻接表表示的优缺点：

优点：便于增加和删除结点；便于统计边的数目；空间效率高。

缺点：不便于判断顶点之间是否有边；不便于计算有向图各个顶点的度。

总代码：

#include<stdio.h>
#include<iostream>
#include<string.h>


using namespace std;


class Graph_Form1{//邻接矩阵
    public:
    string *vex;//顶点表
    int **Form;
    int vexnum,arcnum;//vexnum代表顶点数，arcnum代表边数    
};

int Locate_Vex1(Graph_Form1 form,string s){
    for(int i = 0; i < form.vexnum; i++){
        if(form.vex[i] == s) return i;
    }
    return -1;
}

void CreateGraph1(Graph_Form1 &form){
    cout<<"请输入边的数量:"<<endl;
    cin>>form.arcnum;
    cout<<"请输入图的顶点数量:"<<endl;
    cin>>form.vexnum;
    form.vex = new string[form.vexnum];
    for(int i = 0; i < form.vexnum; i++){
        cin>>form.vex[i];//依次输入顶点
    }
    form.Form = new int*[form.vexnum];//定义二维数组存储图
    for(int i = 0; i < form.vexnum; i++){
        form.Form[i] = new int[form.vexnum];
        for(int j = 0; j < form.vexnum; j++){
            form.Form[i][j] = -1;
        }
    }
    string vex1, vex2;
    int w;
    for(int a = 0; a < form.arcnum; a++){//无向图的创建方法
        cout<<"请输入两个顶点以及他们之间的权值:"<<endl;
        cin>>vex1;
        cin>>vex2;
        cin>>w;
        int i = Locate_Vex1(form,vex1), j = Locate_Vex1(form,vex2);
        form.Form[i][j] = w;
        form.Form[j][i] = w;//要创建有向图将这句删除即可
    }
    for(int i = 0; i < form.vexnum; i++){
        for(int j = 0; j < form.vexnum; j++){
            cout<<form.Form[i][j]<<"  ";
        }
        cout<<endl;
    }
}
//上述是邻接矩阵方式创建并存储图的方式


class Arc_Node{//边结点
public:
    int state,weight;//state表示位置，weight为权值
    Arc_Node *next;
};
class Vex_Node{//顶点结点
public:
    string vex;
    Arc_Node *next;
};
class Graph_Form2{//邻接表
public:
    Vex_Node *Form;
    int vexnum, arcnum;//vexnum为顶点数量，arcnum为边的数量
};

int Locate_Vex2(Graph_Form2 form,string s){
    for(int i = 0; i < form.vexnum; i++){
        if(form.Form[i].vex == s) return i;
    }
    return -1;
}

void Create_Graph2(Graph_Form2 &form){//创建邻接表
    cout<<"请输入边的数量:"<<endl;
    cin>>form.arcnum;
    cout<<"请输入顶点数量:"<<endl;
    cin>>form.vexnum;
    form.Form = new Vex_Node[form.vexnum];
    for(int i = 0; i < form.vexnum; i++){//输入顶点
        form.Form[i].next = NULL;
        cout<<"请输入顶点:"<<endl;
        cin>>form.Form[i].vex;
    }
    string vex1,vex2;
    int weight;
    for(int a = 0; a < form.arcnum; a++){
        cout<<"请输入一条边依附的两个顶点及边的权值（有向图注意输入顺序）:"<<endl;
        cin>>vex1;
        cin>>vex2;
        cin>>weight;
        int i = Locate_Vex2(form,vex1), j = Locate_Vex2(form,vex2);
        Arc_Node *p1 = new Arc_Node();
        p1->state = j;
        p1->weight = weight;
        p1->next = form.Form[i].next;
        form.Form[i].next = p1;
        //下面为无向图需要的步骤
        Arc_Node *p2 = new Arc_Node();
        p2->state = i;
        p2->weight = weight;
        p2->next = form.Form[j].next;
        form.Form[j].next = p2;
    }
}

int main(){
    Graph_Form1 form1;
    CreateGraph1(form1);
    Graph_Form2 form2;
    Create_Graph2(form2);
}