图的相关操作

假设图结构具有n个元素（顶点），数据元素为字符，如果是加权图，权值为整数。请编码实现图ADT。

存储结构的选择：   1: 邻接矩阵      2: 邻接表

执行的操作：1：创建图

                      2：输出图的存储结构（邻接矩阵或邻接表，格式见后面说明）  

                      3：计算各个顶点的度（有向图时，分为入度和出度）

                      4：深度遍历(需要输入遍历开始顶点)

                      5：广度遍历(需要输入遍历开始顶点)

                      0：退出

注：（1）图的类型分为4种，

                  1：无向，不加权

                  2：有向，不加权

                  3：无向，加权

                  4：有向，加权

        （2）边用一对顶点元素表示，权值为整数，例如非加权图边  ab，加权图ab6

操作相关说明：

运行时首先选择存储结构，输入1或2

然后选择要执行的操作，输入0-5中的一个，第1个操作必须是0或1

（1）创建图：

输入有多行，包括：

第一行，一个整数，指出图的类型，见前面说明。

第二行，一个整数，输入图的顶点个数

第三行，输入各个顶点元素字符

后面多行，输入两个字符表示顶点的各条边，如果是加权图，后面还有一个整数权值。当输入**字符时（需要权值时，任意）表示边的输入结束。

最后是要执行的操作

顶点按输入顺序存储；如果采用邻接表存储，输入边时邻接点采用插入到前面（所在链表头）

例如：

1    //邻接矩阵存储结构

1    //创建图

1    //无向，不加权图

6    //顶点个数

abcdef      //顶点元素

ab    // 边(a,b)，下同

ad

ae

bc

ce

df

ef

**    //输入两个*表示边输入结束

（2）输出图存储结构

如果是邻接矩阵，就按矩阵形式输出，有行、列元素标题。行标题占位4，元素占位6。如：

Adjacency Matrix is:

 

          a     b     c     d     e     f

 

 

   a     0     1     0     1     1     0

   b     1     0     1     0     0     0

   c     0     1     0     0     1     0

   d     1     0     0     0     0     1

   e     1     0     1     0     0     1

   f      0     0     0     1     1     0   

如果是邻接表，先输出顶点元素，再输出各个邻接点，如果有权值则用括号把权值括起来。例如输出：

Adjacency List is:

a:-->e-->d-->b

b:-->c-->a

c:-->e-->b

d:-->f-->a

e:-->f-->c-->a

f:-->e-->d

对于有权值图，输出为 a:-->e(3)-->d(10)

(3) 计算各个顶点的度并输出，对有向图要分别计算出度和入度

无向图输出形式为：

Degree of Vertex:

Degree(a)=3

Degree(b)=2

......

有向图输出形式为：

Degree of Vertex:

Degree(a)=6

Out_Degree(a)=2;In_Degree(a)=4

 

Degree(b)=2

Out_Degree(b)=2;In_Degree(b)=0

 

......

(4) 深度遍历

输入：遍历开始的顶点

输出： Depth-First Traversal order: ......

(5) 广度遍历

 

输入：遍历开始的顶点

输出： Breadth-First Traversal order: ......

 

例如，下面是一个测试用例：

1      //选择存储结构，邻接矩阵

1      //选择操作，创建图

1      //图类型，无向无权图

6      //顶点个数

abcdef      //输入顶点元素

ab      //输入一条边(a,b)

ad

ae

bc

ce

df

ef

**      //边输入结束

2      //输出存储结构

3      //计算图顶点的度

0      //结束

例如:

#include <bits/stdc++.h>

using namespace std;

///邻接矩阵的操作
int dis[100][100];///邻接矩阵
int n;///顶点
int deg[3][100];///记录节点度
char s[100];///顶点元素
bool vis[100];
int jiegou,leixing;///定义的结构类型和图类型
void create1(int nn)///创建邻接矩阵
{
    char ch1,ch2;
    int a1,a2,a;
    switch (nn)
    {
    case 1:///无向不加权
        while(1)
        {
            getchar();///消除回车
            scanf("%c%c",&ch1,&ch2);
            if(ch1=='*'&&ch2=='*')
                return;
            for(int i=0; i<n; i++)
            {
                if(ch1==s[i])
                    a1=i;
                if(ch2==s[i])
                    a2=i;
            }
            deg[0][a1]++;
            deg[0][a2]++;
            dis[a1][a2]=1;
            dis[a2][a1]=1;
        }
        break;
    case 2: ///有向不加权
        while(1)
        {
            getchar();///消除回车
            scanf("%c%c",&ch1,&ch2);
            if(ch1=='*'&&ch2=='*')
                return;
            for(int i=0; i<n; i++)
            {
                if(ch1==s[i])
                    a1=i;
                if(ch2==s[i])
                    a2=i;
            }
            deg[0][a1]++;
            deg[0][a2]++;
            deg[1][a1]++;///出度
            deg[2][a2]++;///入度
            dis[a1][a2]=1;

        }
        break;
    case 3:///无向加权
        while(1)
        {
            getchar();///消除回车
            scanf("%c%c%d",&ch1,&ch2,&a);
            if(ch1=='*'&&ch2=='*')
                return;
            for(int i=0; i<n; i++)
            {
                if(ch1==s[i])
                    a1=i;
                if(ch2==s[i])
                    a2=i;
            }
            deg[0][a1]++;
            deg[0][a2]++;
            dis[a1][a2]=a;
            dis[a2][a1]=a;
        }

        break;
    case 4:///有向加权
        while(1)
        {
            getchar();///消除回车
            scanf("%c%c%d",&ch1,&ch2,&a);
            if(ch1=='*'&&ch2=='*')
                return;
            for(int i=0; i<n; i++)
            {
                if(ch1==s[i])
                    a1=i;
                if(ch2==s[i])
                    a2=i;
            }
            deg[0][a1]++;
            deg[0][a2]++;
            deg[1][a1]++;///出度
            deg[2][a2]++;///入度
            dis[a1][a2]=a;
        }
        break;
    }
}

void print1()///输出邻接矩阵
{
    cout<<"Adjacency Matrix is:"<<endl;
    cout<<"    ";
    for(int i=0; i<n; i++)
        printf("%6c",s[i]);
    cout<<endl;
    if(leixing==1||leixing==2)///无向图
    for(int i=0; i<n; i++)
    {
        printf("%4c",s[i]);
        for(int j=0; j<n; j++)
        {
            printf("%6d",dis[i][j]);
        }
        cout<<endl;
    }
    else{
    for(int i=0; i<n; i++)
    {
        printf("%4c",s[i]);
        for(int j=0; j<n; j++)
        {
            if(i!=j&&dis[i][j]==0)
            {
                printf("     ∞");
            }
            else
            {
                printf("%6d",dis[i][j]);
            }
        }
        cout<<endl;
    }
    }
}
void print2()///输出邻接表
{
    cout<<"Adjacency List is:"<<endl;
    for(int i=0; i<n; i++)
    {
        cout<<s[i]<<":";
        for(int j=n-1; j>=0; j--)
        {
            if(dis[i][j]!=0)
            {
                cout<<"-->"<<s[j];
                if(leixing==3||leixing==4)
                {
                    cout<<"("<<dis[i][j]<<")";
                }
            }
        }
        cout<<endl;
    }

    //cout<<endl;
}
void DFS1(int v)///深搜
{
    if(jiegou==1)///邻接矩阵
    {
        vis[v]=true;
        cout<<s[v];
        for(int i=0; i<n; i++)
        {
            if(dis[v][i]!=0&&vis[i]==false)
            {
                DFS1(i);
            }
        }
    }
    else///邻接表
    {
        vis[v]=true;
        cout<<s[v];
        for(int i=n-1; i>=0; i--)
        {
            if(dis[v][i]!=0&&vis[i]==false)
            {
                DFS1(i);
            }
        }
    }
}
void BFS1(char ch)
{
    for(int i=0;i<n;i++)
    {
        vis[i]=false;
    }
    queue<int> Q;
    int flag;
    for(int i=0;i<n;i++)
    {
        if(ch==s[i])
        {
            flag=i;
            break;
        }
    }
    if(jiegou==1)
    {
        for(int i=flag; i<n; i++)
        {
            if(vis[i]==false)
            {
                Q.push(i);
                vis[i]=true;
                while(!Q.empty())
                {
                    int t=Q.front();
                    Q.pop();
                    cout<<s[t];
                    for(int j=0; j<n; j++)
                    {
                        if(dis[t][j]!=0&&vis[j]==false)
                        {
                            Q.push(j);
                            vis[j]=true;
                        }
                    }
                }

            }
        }
        for(int i=0; i<flag; i++)
        {
            if(vis[i]==false)
            {
                Q.push(i);
                vis[i]=true;
                while(!Q.empty())
                {
                    int t=Q.front();
                    Q.pop();
                    cout<<s[t];
                    for(int j=0; j<n; j++)
                    {
                        if(dis[t][j]!=0&&vis[j]==false)
                        {
                            Q.push(j);
                            vis[j]=true;
                        }
                    }
                }

            }
        }
    }
    else{
        for(int i=flag; i<n; i++)
        {
            if(vis[i]==false)
            {
                Q.push(i);
                vis[i]=true;
                while(!Q.empty())
                {
                    int t=Q.front();
                    Q.pop();
                    cout<<s[t];
                    for(int j=n-1; j>=0; j--)
                    {
                        if(dis[t][j]!=0&&vis[j]==false)
                        {
                            Q.push(j);
                            vis[j]=true;
                        }
                    }
                }

            }
        }
        for(int i=0; i<=flag; i++)
        {
            if(vis[i]==false)
            {
                Q.push(i);
                vis[i]=true;
                while(!Q.empty())
                {
                    int t=Q.front();
                    Q.pop();
                    cout<<s[t];
                    for(int j=n-1; j>=0; j--)
                    {
                        if(dis[t][j]!=0&&vis[j]==false)
                        {
                            Q.push(j);
                            vis[j]=true;
                        }
                    }
                }

            }
        }
    }
    cout<<endl;
}

int main()
{
    cin>>jiegou;
    while(1)
    {
        int m;
        cin>>m;
        if(m==0) return 0;
        switch (m)
        {
        case 1:///创建图
            memset(dis,0,sizeof(dis));///矩阵置零
            cin>>leixing>>n;
            cin>>s;
            if(jiegou==1)
            {
                create1(leixing);
            }
            else if (jiegou==2)
            {
                create1(leixing);
            }
            break;
        case 2:///输出图的存储结构
            cout<<endl;
            if(jiegou==1)
            {
                print1();///邻接矩阵输出
            }
            else{
                print2();
            }
            break;
        case 3:///计算定点度
            cout<<endl;
            cout<<"Degree of Vertex:"<<endl;
            if(leixing==1||leixing==3)///无向图
            {
                for(int i=0;i<n;i++)
                {
                    cout<<"Degree("<<s[i]<<")="<<deg[0][i]<<endl;
                }
            }
            else{
                if(jiegou==1)
                for(int i=0;i<n;i++)
                {
                    cout<<"Degree("<<s[i]<<")="<<deg[0][i]<<endl;
                    cout<<"Out_Degree("<<s[i]<<")="<<deg[1][i];
                    cout<<";In_Degree("<<s[i]<<")="<<deg[2][i]<<endl<<endl;
                }
                else
                {
                    for(int i=0; i<n; i++)
                    {
                        cout<<"Degree("<<s[i]<<")="<<deg[0][i]<<endl;
                        cout<<"Out_Degree("<<s[i]<<")="<<deg[1][i];
                        cout<<";In_Degree("<<s[i]<<")="<<deg[2][i]<<endl<<endl;;
                    }
                }
            }
            break;
        case 4:///深度遍历
            char ch;
            cin>>ch;
            cout<<endl;
            cout<<"Depth-First Traversal order:";
            for(int i=0;i<n;i++)
            {
                vis[i]=false;
            }
            int flag;
            for(int i=0;i<n;i++)
            {
                if(ch==s[i])
                {
                    flag=i;
                    break;
                }
            }
            for(int i=flag;i<n;i++)
            {
                if(vis[i]==false)
                    DFS1(i);
            }
            for(int j=0;j<=flag;j++)
            {
             if(vis[j]==false)
                    DFS1(j);
            }
            cout<<endl;
            break;
        case 5:///广度遍历
            cout<<endl;
            char ch11;
            cin>>ch11;
            cout<<"Breadth-First Traversal order:";
            BFS1(ch11);
            //cout<<endl;
           // if(leixing==2||leixing==4)
               // cout<<endl<<endl;
            break;
        }

    }

    return 0;
}

（题目描述欠佳但是凑活看吧，。能看懂我是直接用邻接矩阵写了邻接表的输出）