int MaxSize;//这是H1。H
#define MaxSize 100
typedef struct
{
    int list[MaxSize];
    int size;
}SeqList;

void ListInitiate(SeqList *l)
{
    l -> size = 0;
}

int ListLength(SeqList l)
{
    return l.size;
}

int ListInsert(SeqList *l, int i, int x)
{
    int j;
    if(l -> size >= MaxSize)
    {
        printf("error");
        return 0;
    }
    else
    {
        for(j = l -> size; j > i; j --)
        {
            l -> list[j] = l -> list[j - 1];
        }
        l -> list[i] = x;
        l -> size ++;
    }
    return 1;
}

int ListDelete(SeqList *l, int i, int *x)
{
    int j;
    *x = l -> list[i];
    for(j = i + 1; j <= l -> size - 1; j ++)
        l -> list[j - 1] = l -> list[j];
    l -> size --;
    return 1;
}

#include"H1.h"//这是H2。H
int MaxVertice;
typedef struct
{
    SeqList Vertices;
    int edge[MaxVertice][MaxVertice];
    int numOfEdge;
}AdjMGraph;

void Initiate(AdjMGraph *G, int n)
{
    int i, j;
    for(i = 0; i < n; i ++)
    {
        for(j = 0; j < n; j ++)
        {
            if(i == j)
            {
                G -> edge[i][j] = 0;
            }
            else
            {
                G -> edge[i][j] = MaxSize;
            }
        }
    }
    ListInitiate(&G -> Vertices);
    G -> numOfEdge = 0;
}

void InsertVertices(AdjMGraph *G, int vertice)
{
    ListInsert(&G -> Vertices, G -> Vertices.size, vertice);// ->错了
}

void InsertEdge(AdjMGraph *G, int v1, int v2, int weight)
{
    G -> edge[v1][v2] = weight;
    G -> numOfEdge ++;
}

void DeleteEdge(AdjMGraph *G, int v1, int v2)
{
    G -> edge[v1][v2] = MaxSize;
    G -> numOfEdge --;
}

void DeleteVertice(AdjMGraph *G, int v)
{
    int x, n, i, j;
    n = ListLength(G -> Vertices);
    for(i = v; i < n; i ++)
    {
        for(j = 0; j < n; j ++)
        {
            G -> edge[i][j] = G -> edge[i + 1][j];
        }
    }//删除第V行
    for(i = 0; i < n; i ++)
    {
        for(j = v; j < n; j ++)
        {
            G -> edge[i][j] = G -> edge[i][j + 1];
        }
    }//删除第V列
    ListDelete(&G -> Vertices, v, &x);
}

int GetFirstVex(AdjMGraph G, int v)//在图G中寻找序号为V的结点的第一个邻接结点
{
    int col;//列下标
    for(col = 0; col < G.Vertices.size; col ++)
    {
        if(G.edge[v][col] > 0 && G.edge[v][col] < MaxSize)
            return col;
        else 
            return -1;
    }
}

int GetNextVetice(AdjMGraph G, int v1, int v2)//在图G中寻找V1的邻接结点V2的下一个邻接结点
{
    int col;
    for(col = v2 + 1; col < G.Vertices.size; col ++)
    {
        if(G.edge[v1][col] > 0 && G.edge[v1][col] < MaxSize)
            return col;
        else 
            return -1;
    }
}

#include<stdio.h>
#include"h2.h"

#define MaxVertice 10
#define MaxEdge 100
#define MaxWeight 10000
typedef struct
{
    int row;
    int col;
    int weight;
}RowColWeight;

void CreatGraph(AdjMGraph *G, char v[], int n, RowColWeight E[], int e)
{
    int i, k;
    Initiate(G, n);
    for(i = 0; i < n; i ++)
    {
        InsertVertices(G, v[i]);
    }
    for(k = 0; k < e; k ++)
    {
        InsertEdge(G, E[k].row, E[k].col, E[k].weight);
    }

}

main()
{
    AdjMGraph gl;
    int i;
    char a[5] = {'a', 'b', 'c', 'd', 'e'}; 
    RowColWeight rcw[5] = {{0, 1, 10}, {0, 4, 20}, {1, 3, 30}, {2, 1, 40}, {3, 2, 50}};
    int n = 5, e = 5;
    CreatGraph(&gl, a, n, rcw, e);
    DeleteEdge(&gl, 0, 4);
    DeleteVertice(&gl, 3);
    printf("结点集合：");
    for(i = 0; i < gl.Vertices.size; i ++)
    {
        printf("%c", gl.Vertices.list[i]);
    }
    printf("\n");
    printf("权值集合");
    int j;
    for(i = 0; i < gl.Vertices.size; i ++)
    {
        for(j = 0; j < gl.Vertices.size; j ++)
        {
            printf("%d", gl.edge[i][j]);
        }
        printf("\n");
    }
}