《数据结构与算法A》实验5：图的基本操作的实现

《数据结构与算法A》实验5：图的基本操作的实现

---

Description

---

掌握图的两种表示方法：

（1）邻接矩阵表示法；

（2）邻接表表示法。

在本实验中，无向图采用邻接矩阵表示，有向图采用邻接表表示。

实现图的如下基本操作：统计图中每个顶点的度数。说明：有向图中顶点度数为该顶点入度和出度之和。

Input

---

本题目包含多组测试数据。

输入数据的第一行是一个正整数Y（Y=1表示接下来输入的图是无向图，Y=2表示接下来输入的图是有向图，当Y取其他值时，表示输入结束）。

第二行包含两个正整数N和M（1<N<20，0<M<100），分别代表图中顶点和边（或者弧）的数目。

接下来输入M行数据，每一行有两个以空格间隔的整数a和b（0≤a,b≤N-1），表示顶点a与顶点b之间有一条边（或者弧）。

例如输入：

1 —无向图

4 3 —4个顶点，3条边

0 1 —第1条边的信息

0 2 —第2条边的信息

1 2 —第3条边的信息

例如输入：

2 —有向图

5 4 —5个顶点，4条弧

0 2 —第1条弧的信息，顶点0为起点，顶点2为终点

2 1 —第2条弧的信息，顶点2为起点，顶点1为终点

1 2 —第3条弧的信息，顶点1为起点，顶点2为终点

3 4 —第4条弧的信息，顶点3为起点，顶点4为终点

Output

---

对每个图，按其顶点编号从小到大的次序，依次输出每个顶点编号及该顶点的度（以空格间隔），每个顶点的相关信息占一行。

例如对于上面的无向图，其输出如下：

0 2

1 2

2 2

3 0

Sample Input

---

1
4 3
0 1
0 2
1 2
2
5 8
0 1
0 3
1 0
1 2
1 3
2 1
4 1
4 2
-1

Sample Output

---

0 2
1 2
2 2
3 0
0 3
1 6
2 3
3 2
4 2

代码

---

#include<iostream>
 
int Max = 1 << 30;
 
int n, m;
 
using namespace std;
 
class Undirected_graph 
{
private:
    int num;
 
    int *node;
 
    int **map;
public:
    Undirected_graph();
 
    ~Undirected_graph();
 
    void init();
 
    void show();
};
 
Undirected_graph::Undirected_graph()
{
    num = n;
 
    node = new int[num + 1];
 
    map = new int*[num + 1];
 
    for (int i = 0; i < num + 1; i++)
    {
        map[i] = new int[num + 1];
    }
 
    for (int i = 0; i < num + 1; i++)
    {
        node[i] = 0;
 
        for (int j = 0; j < num + 1; j++)
        {
            if (i == j) map[i][j] = 0;
 
            else map[i][j] = Max;
        }
    }
}
 
Undirected_graph::~Undirected_graph()
{
    delete[]node;
 
    for (int i = 0; i < num + 1; i++)
    {
        delete[] map[i];
    }
    delete[] map;
}
 
void Undirected_graph::init()
{
 
    for (int i = 0; i < m; i++)
    {
        int j, k;
 
        cin >> j >> k;
 
        if (map[j][k] != 1)
        {
            node[j]++;
 
            node[k]++;
        }
 
        map[j][k] = map[k][j] = 1;
    }
}
 
void Undirected_graph::show()
{
    for (int i = 0; i < num; i++)
        cout << i << ' ' << node[i] << endl;
}
 
class Node
{
private:
    int id;
 
    Node *next;
public:
    Node(int = -1);
 
    friend class Nlink;
};
 
Node::Node(int id)
{
    this->id = id;
    next = NULL;
}
 
class Nlink
{
private:
    int id;
 
    int degree;
 
    Node *head;
public:
    Nlink(int = -1);
 
    ~Nlink();
 
    void addNode(int);
 
    friend class Digraph;
};
 
Nlink::Nlink(int id)
{
    degree = 0;
    head = NULL;
}
 
Nlink::~Nlink()
{
    degree = 0;
 
    delete head;
 
    head = NULL;
}
 
void Nlink::addNode(int num)
{
    Node *n = new Node(num);
 
    if (head == NULL)
    {
        head = n;
        return;
    }
 
    Node *p = head;
 
    while (p->next)
    {
        p = p->next;
    }
 
    p->next = n;
 
    degree++;
}
 
class Digraph {
private:
    int num;
 
    Nlink *map;
public:
    Digraph();
 
    void init();
 
    void show();
};
 
Digraph::Digraph()
{
    num = n;
 
    map = new Nlink[num + 1];
 
    for (int i = 0; i < num + 1; i++)
    {
        map[i].id = i;
 
        map[i].addNode(i);
    }
}
 
void Digraph::init()
{
    for (int i = 0; i < m; i++)
    {
        int j, k;
 
        cin >> j >> k;
 
        map[j].addNode(k);
         
        map[k].degree++;
    }
}
 
void Digraph::show()
{
    for (int i = 0; i < num; i++)
    {
        cout << map[i].id << ' ' << map[i].degree << endl;
    }
}
 
int main()
{
    int flag;
 
    while (cin >> flag)
    {
        if (flag == 1)
        {
            cin >> n >> m;
            Undirected_graph ug;
            ug.init();
            ug.show();
        }
        else if (flag == 2)
        {
            cin >> n >> m;
            Digraph dg;
            dg.init();
            dg.show();
        }
        else break;
    }
}