南邮数据结构实验三图的基本运算及飞机换乘次数最少问题

实验报告

（ 2015 / 2016 学年第 2学期）

课程名称数据结构A

实验名称图的基本运算及飞行换乘次数最少问题实验时间年月日指导单位计算机科学与技术系

指导教师

学生姓名班级学号学院(系) 专业

试验一图的基本运算

一、问题描述

（1）验证教材中关于在邻接矩阵和邻接表两种不同存储结构上实现图的基本运算的算法（见程序9.1~程序9.8）；

（2）在邻接矩阵存储结构上实现图的深度和广度优先遍历算法；

（3）设计主函数，测试上述运算；

（4）提示：扩充MGraph类，在扩充类上增加DFS和BFS函数；

二、概要设计

图如下所示，显示了名为operation_of_map的（默认文件名）工程，实现了Graph,SeqQueue,结点类ENode,邻接矩阵类MGraph,邻接表LGraph类，包括几种为不同传入类型准备的构造函数。声明所要求的函数，并在后续过程中实现函数功能，最后通过一个main函数求解。

三、详细设计

1.类与类的层次结构

四、程序代码

#include"stdafx.h"

#include

using namespace std;

const int INFTY = 2147483640;

enum ResultCode { Underflow, Duplicate, Failure, Success, NotPresent }; template

class Graph

{

public:

virtual ResultCode Insert(int u, int v, T&w) = 0;

virtual ResultCode Remove(int u, int v) = 0;

virtual bool Exist(int u, int v)const = 0;

protected:

int n, e;

};

template

class SeqQueue

{

public:

SeqQueue(int mSize);

~SeqQueue() { delete[]q; }

bool IsEmpty() const { return front == rear; }

bool IsFull() const { return (rear + 1) % maxSize == front; }

bool Front(T &x)const;

bool EnQueue(T x);

bool DeQueue();

void Clear() { front = rear = 0; }

private:

int front, rear;

int maxSize;

T*q;

};

template

SeqQueue::SeqQueue(int mSize)

{

maxSize = mSize;

q = new T[maxSize];

front = rear = 0;

}

template

bool SeqQueue::Front(T &x)const

{

if (IsEmpty())

{

return false;

}

x = q[(front + 1) % maxSize];

return true;

}

template

bool SeqQueue::EnQueue(T x)//在队尾插入x {

if (IsFull())

{

cout <<"Full"<< endl;

return false;

}

q[rear = (rear + 1) % maxSize] = x;

return true;

}

template

bool SeqQueue::DeQueue()//删除队头元素{

if (IsEmpty())

{

cout <<"Underflow"<< endl;

return false;

}

front = (front + 1) % maxSize;

return true;

}

template

class MGraph :public Graph//邻接矩阵类{

public:

MGraph(int mSize, const T& noedg);

~MGraph();

ResultCode Insert(int u, int v, T&w);

ResultCode Remove(int u, int v);

bool Exist(int u, int v)const;

void DFS();

void BFS();

protected:

T**a;

T noEdge;

void DFS(int v, bool*visited);

void BFS(int v, bool*visited);

};

template

MGraph::MGraph(int mSize, const T&noedg)//构造函数{

n = mSize;

e = 0;

noEdge = noedg;

a = new T*[n];

for (int i = 0;i

{

a[i] = new T[n];

int j = 0;

for (j;j

a[i][j] = noEdge;

a[i][j] = 0;

}

}

template

MGraph::~MGraph()//析构函数

{

for (int i = 0;i

delete[]a[i];

delete[]a;

}

template

ResultCode MGraph::Insert(int u, int v, T&w)//插入函数{

if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v) return Failure;

if (a[u][v] != noEdge)

return Duplicate;

a[u][v] = w;

e++;

return Success;

}

template

ResultCode MGraph::Remove(int u, int v)//删除函数

{

if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v)

return Failure;

if (a[u][v] == noEdge)

return NotPresent;

a[u][v] = noEdge;

e--;

return Success;

}

template

bool MGraph::Exist(int u, int v)const//判断边是否存在

{

if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v || a[u][v] == noEdge) return false;

return true;

}

template

void MGraph::DFS()//深度遍历

{

bool *visited = new bool[n];

for (int i = 0;i

visited[i] = false;

for (int i = 0;i

if (!visited[i])

DFS(i, visited);

delete[]visited;

}

template

void MGraph::DFS(int v, bool *visited)

{

visited[v] = true;

cout <<" "<

for (int i = 0;i

if (a[v][i] != noEdge&&a[v][i] != 0 && !visited[i])

DFS(i, visited);

}

template

void MGraph::BFS() //广度遍历

{

bool *visited = new bool[n];

for (int i = 0;i

visited[i] = false;

for (int i = 0;i

if (!visited[i])

BFS(i, visited);

delete[]visited;

}

template

void MGraph::BFS(int v, bool *visited)

{

SeqQueue q(n);

visited[v] = true;

cout <<" "<

q.EnQueue(v);

while (!q.IsEmpty())

{

q.Front(v);

q.DeQueue();

for (int i = 0;i

if (a[v][i] != noEdge&&a[v][i] != 0 && !visited[i])

{

visited[i] = true;

cout <<" "<< i;

q.EnQueue(i);

}

}

}

template //结点类

class ENode

{

public:

ENode() { nextArc = NULL; }

ENode(int vertex, T weight, ENode *next)

{

adjVex = vertex;

w = weight;

nextArc = next;

}

int adjVex;

T w;

ENode *nextArc;

};

template

class LGraph :public Graph //邻接表类

{

public:

LGraph(int mSize);

~LGraph();

ResultCode Insert(int u, int v, T&w);

ResultCode Remove(int u, int v);

bool Exist(int u, int v)const;

protected:

ENode**a;

};

template

LGraph::LGraph(int mSize)//构造函数

{

n = mSize;

e = 0;

a = new ENode*[n];

for (int i = 0;i

a[i] = NULL;

}

template

LGraph::~LGraph()

{

ENode *p, *q;

for (int i = 0;i

{

p = a[i];

q = p;

while (p)

{

p = p->nextArc;

delete q;

q = p;

}

}

delete[]a;

}

template

bool LGraph::Exist(int u, int v)const//判断边是否存在{

if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v) return false;

ENode*p = a[u];

while (p&&p->adjVex != v)

p = p->nextArc;

if (!p)

return false;

else return true;

}

template

ResultCode LGraph::Insert(int u, int v, T&w)//插入{

if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v) return Failure;

if (Exist(u, v))

return Duplicate;

ENode*p = new ENode(v, w, a[u]);

a[u] = p;

e++;

return Success;

}

template

ResultCode LGraph::Remove(int u, int v) //删除{

if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v) return Failure;

ENode*p = a[u], *q;

q = NULL;

while (p&&p->adjVex != v)

{

q = p;

p = p->nextArc;

}

if (!p)

return NotPresent;

if (q)

q->nextArc = p->nextArc;

else

a[u] = p->nextArc;

delete p;

e--;

return Success;

}

int main() //主函数

{

int n, g;

cout <<"请输入元素的个数：";

cin >> n;

MGraphA(n, INFTY);

LGraphB(n);

cout <<"请输入边的条数:";

cin >> g;

int*a = new i nt[g];

int*b = new i nt[g];

int*w = new i nt[g];

for (int i = 0;i

{

cout <<"请输入边及权值：";

cin >> a[i] >> b[i] >> w[i];

A.Insert(a[i], b[i], w[i]);

B.Insert(a[i], b[i], w[i]);

}

cout <<"该图的深度优先遍历为:"<< endl;

A.DFS();

cout << endl;

cout <<"该图的广度优先遍历为："<< endl;

A.BFS();

cout << endl;

cout <<"请输入要搜索的边：";

int c, d;

cin >> c >> d;

if (A.Exist(c, d))

cout <<"邻接矩阵中该边存在！"<< endl;

else

cout <<"邻接矩阵中该边不存在！"<< endl;

if (B.Exist(c, d))

cout <<"邻接表中该边存在！"<< endl;

else

cout <<"邻接表中该边不存在！"<< endl;

cout <<"请输入要删除的边：";

int e, f;

cin >> e >> f;

if (A.Remove(e, f) == Success)

cout <<"邻接矩阵中删除该边成功！"<< endl;

else if (A.Remove(e, f) == NotPresent)

cout <<"邻接矩阵中该边不存在！"<< endl;

else

cout <<"输入错误！"<< endl;

if (B.Remove(e, f) == Success)

cout <<"邻接表中删除该边成功！"<< endl;

else if (B.Remove(e, f) == NotPresent)

cout <<"邻接表中该边不存在！"<< endl;

else

cout <<"邻接表中输入错误！"<< endl;

cout <<"删除该边后该图的深度优先遍历为："<< endl;

A.DFS();

cout << endl;

cout <<"删除该边后该图的广度优先遍历为："<< endl;

A.BFS();

cout << endl;

return 0;

}

四、测试和调试

试验二飞机最少换乘次数问题

一、问题描述

(1)设有n个城市，编号为0~n-1，m条航线的起点和终点由用户输入提供。寻找一条换乘次数最少的线路方案。

(2)提示：可以使用有向图表示城市间的航线；只要两城市间有航班，则图中这两点间存在一条权为1的边；可以使用Dijkstra算法实现。

(3)思考：如果是城市公交车的最少换乘问题，将如何解决？假如希望使用类似的算法，则图中的边如何设置？

二、概要设计

首先创建抽象类Graph与邻接表类 MGraph，首先创建结点与边也就是城市与航向条数，之后调用邻接表类的迪杰斯特拉算法实现计算

三、详细设计

1.类与类的层次结构：

Graph类MGraph类

四、程序代码

#include"stdafx.h"

#include

#include

using namespace std;

const int INF = 2147483647;

enum ResultCode { Underflow, Duplicate, Failure, Success, NotPresent, OutOfBounds }; template

class Graph//抽象类

{

public:

virtual ResultCode Insert(int u, int v, T w) = 0;

virtual ResultCode Remove(int u, int v) = 0;

virtual bool Exist(int u, int v)const = 0;

protected:

int n, e;

};

template

class MGraph :public Graph //邻接矩阵类

{

public:

MGraph(int mSize, const T noedg);

~MGraph();

ResultCode Insert(int u, int v, T w);

ResultCode Remove(int u, int v);

bool Exist(int u, int v)const;

int Choose(int* d, bool* s);

void Dijkstra(int v, T* d, int* path);

protected:

T**a;

T noEdge;

};

template

MGraph::MGraph(int mSize, const T noedg)

{

n = mSize;

e = 0;

noEdge = noedg;

a = new T*[n];

for (int i = 0;i

{

a[i] = new T[n];

for (int j = 0;j

a[i][j] = noEdge;

a[i][i] = 0;

}

}

template

MGraph::~MGraph()

{

for (int i = 0;i

delete[]a[i];

delete[]a;

}

template

ResultCode MGraph::Insert(int u, int v, T w)

{

if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v) return Failure;

if (a[u][v] != noEdge)

return Duplicate;

a[u][v] = w;

e++;

return Success;

}

template

ResultCode MGraph::Remove(int u, int v)

{

if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v) return Failure;

if (a[u][v] == noEdge)

return NotPresent;

a[u][v] = noEdge;

e--;

return Success;

}

template

bool MGraph::Exist(int u, int v)const

{

if (u<0 || v<0 || u>n - 1 || v>n - 1 || u == v || a[u][v] == noEdge) return false;

return true;

}

template

int MGraph::Choose(int* d, bool* s) //求最小d[i]

{

int i, minpos;

T min;

min = INF;

minpos = -1;

for (i = 0;i

if (d[i] <= min&&!s[i])

{

min = d[i];

minpos = i;

}

return minpos;

}

template

void MGraph::Dijkstra(int v, T* d, int* path)//迪杰斯特拉算法

{

int i, k, w;

if (v<0 || v>n - 1)

throw OutOfBounds;

bool* s = new bool[n];

for (i = 0;i

{

s[i] = false;

d[i] = a[v][i];

if (i != v&&d[i]

path[i] = v;

else

path[i] = -1;

}

s[v] = true;

d[v] = 0;

for (i = 1;i

{

k = Choose(d, s);

s[k] = true;

for (w = 0;w

if (!s[w] && (d[k] + a[k][w])

{

d[w] = d[k] + a[k][w];

path[w] = k;

}

}

}

int main()

{

int n, m;

cout <<"请输入城市个数：";

cin >> n;

cout <<"请输入航线条数：";

cin >> m;

MGraphA(n, INF);

int c, f;

cout <<"请输入每条航线的起点和终点："<< endl;

int i = 0;

for (i;i

{

cout <<"航线"<< i + 1 <<":";

cin >> c >> f;

A.Insert(c, f, 1);

}

char s;

do {

int v, w;

cout <<"请输入你的起点和终点：";

cin >> v >> w;

while (v<0 || w<0 || w>n - 1 || v>n - 1)

{

cout <<"输入错误！请重新输入：";

cin >> v >> w;

}

int* b = new i nt[n];

int* d = new i nt[n];

int* path = new i nt[n];

A.Dijkstra(v, d, path);

int e = n - 1;

int j = 0;

for (j;j

b[j] = -2;

if (w != v)

{

j = w;

while (path[j] != -1)

{

b[e] = path[j];

e--;

j = path[j];

}

if (e == n - 1 || d[j] == INF)

cout <<"该路间无线路！"<< endl;

else

{

cout <<"从"<< v <<"到"<< w <<"的换乘次数最小的线路方案为：";

for (int k = 0;k

{

if (b[k] != -2)

cout << b[k] <<",";

}

cout << w << endl;

}

}

if (w == v)

cout <<"从"<< v <<"到"<< i <<"该路间无需乘飞机！"<< endl;

delete[]b;

delete[]d;

delete[]path;

cout <<"请问是否继续查询路线？请输入Y/N:";

cin >> s;

while (s != 'Y'&&s != 'y'&&s != 'n'&&s != 'N')

{

cout <<"输入错误！请重新输入：";

cin >> s;

}

} while (s == 'Y' || s == 'y');

return 0;

}

五、测试和调试