图的遍历问题
合集下载
相关主题
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
cout << "请输入顶点数和边数："; cin >> n>>m; Graph g(n); Queue Q(n*5); cout << "输入"<<n<<"个顶点:"<< endl; for (int i = 0; i < n; i++) {
cout << "请输入顶点" << i << ":" << endl; cin >> g.local[i]; } for (int i = 0; i < m; i++) { char v1, v2; int wt; cout << "\n 请输入顶点两条边和他们的权值:"; cin >> v1 >> v2 >> wt; g.setEdge(v1,v2,wt); } cout << "\n 输出：\n 深度遍历:\n"; g.DFS(0); cout << "\n"; cout << "\n 输出：\n 广度遍历:\n"; g.BFS(0,Q); cout << "\n"; system("pause"); } 运行结果如下：
setMark(w, VISITED); Q.enqueue(w);
}
}
} }; 源文件： #include "图.h" #include<iostream> using namespace std;
void main()
{ int n;//The num of Vertex int m;//The edge of it
return numVertex;/来自百度文库if it is none,return n; }
//set edge between v1 and v2 with wt（weight） void setEdge(char v1, char v2, int wt){
if (wt < 0){ cout << "It is an illegal weight value!\n"; system("pause"); exit(-1); } int p = LocalVer(v1); int q = LocalVer(v2); if (matrix[p][q] == 0)numEdge++;//if it is not the first setEdge,donnot add matrix[p][q] = wt; }
HUNAN UNIVERSITY
课程实验报告
题 目 图的遍历问题
学生姓名
王家威
学生学号
201308070217
专 业 班 级 智能科学与技术 1302 班
指导老师
朱宁波
背景
网络蜘蛛即 Web Spider，是一个很形象的名字。把互联网比喻成一个蜘蛛网，那么 Spider 就是在网上爬来爬去的蜘蛛。网络蜘蛛是通过网页的链接地址来寻找网页，从网站某一个页 面（通常是首页）开始，读取网页的内容，找到在网页中的其它链接地址，然后通过这些链 接地址寻找下一个网页，这样一直循环下去，直到把这个网站所有的网页都抓取完为止。如 果把整个互联网当成一个网站，那么网络蜘蛛就可以用这个原理把互联网上所有的网页都抓 取下来。这样看来，网络蜘蛛就是一个爬行程序，一个抓取网页的程序。 在抓取网页的时候，网络蜘蛛一般有两种策略：广度优先和深度优先（如下面这张简单化的 网页连接模型图所示，其中 A 为起点 也就是蜘蛛索引的起点）。
delete[] matrix[i]; delete[] matrix; } void Init(int n) { numVertex = n; numEdge = 0; mark = new int[n]; local = new char[n];
for (int i = 0; i < numVertex; i++) mark[i] = UNVISITED;
return numVertex;//if it is none,return n; }
//return the v's neihbor after w; int next(int v, int w){
for (int i = w + 1; i < numVertex; i++) if (matrix[v][i] != 0) return i;
深度优先顾名思义就是让网络蜘蛛尽量的在抓取网页时往网页更深层次的挖掘进去 讲究的 是深度!也泛指: 网络蜘蛛将会从起始页开始，一个链接一个链接跟踪下去，处理完这条线 路之后再转入下一个起始页，继续跟踪链接! 则访问的节点顺序为==> A --> B --> E --> H --> I --> C --> D --> F --> K --> L --> G。深度爬行的优点是:网络蜘蛛程序在设计的时候相对比较容 易些；缺点是每次爬行一层总要向"蜘蛛老家" 数据库访问一下。问问老总有必要还要爬下 一层吗! 爬一层 问一次.... 如果一个蜘蛛不管 3721 不断往下爬 很可能迷路更有可能爬到 国外的网站去，不仅增加了系统数据的复杂度更是增加的服务器的负担。 广度优先在这里的定义就是层爬行，即一层一层的爬行， 按照层的分布与布局去索引处理 与抓取网页。则访问的节点顺序为==> A --> B --> C --> D --> E --> F --> G --> H --> I--> K --> L。广 度爬行的优点是对数据抓取更容易控制些，对服务器的负栽相应也明显减轻了许多。
测试数据（以背景描述的图为例）
输入
输入顶点数和弧数:8 9 输入 8 个顶点. 输入顶点 0:a 输入顶点 1:b 输入顶点 2:c 输入顶点 3:d 输入顶点 4:e 输入顶点 5:f
输入顶点 6:g 输入顶点 7:h 输入 9 条弧. 输入弧 0:a b 1 输入弧 1:b d 1 输入弧 2:b e 1 输入弧 3:d h 1 输入弧 4:e h 1 输入弧 5:a c 1 输入弧 6:c f 1 输入弧 7:c g 1 输入弧 8:f g 1
}
int getMark(int v){ return mark[v]; }
void setMark(int v,int val){ mark[v] = val;
}
void print(int v){//print the vertex cout <<unLocalVer(v)<<" ";
}
//DFS void DFS(int v){
//del v1 v2 void delEdge(char v1, char v2) {
int p = LocalVer(v1); int q = LocalVer(v2); if (matrix[p][q] != 0)numEdge--;//if it is not the first delEdge,donnot delete matrix[p][q] = 0; }
bool isEdge(char v1, char v2){ int p = LocalVer(v1); int q = LocalVer(v2); return matrix[p][q] != 0;
}
int weight(char v1, char v2){ int p = LocalVer(v1); int q = LocalVer(v2); return matrix[p][q];
问题描述
若用有向网表示网页的链接网络，其中顶点表示某个网页，有向弧表示网页之间的链接关系。 试设计一个网络蜘蛛系统，分别以广度优先和深度优先的策略抓取网页。
基本要求
（1） （2）
首先输入顶点的数量，然后是各顶点对应的字母，再输入各条弧（权值都置 1）。 输出从首个顶点开始的广度优先遍历序列和深度先遍历序列。
print(v); setMark(v, VISITED); for (int w = first(v); w < n(); w = next(v, w)) {
if (getMark(w)==UNVISITED) DFS(w); } }
//BFS void BFS(int start,Queue Q){
return local[v]; } public: char *local; Graph(int _numVertex) {
Init(_numVertex); } ~Graph(){
delete[] mark; delete[] local; for (int i = 0; i < numVertex; i++)
输出
广度优先遍历: a b d h e c f g 深度优先遍历: a b c d e f g h
代码：
图的头文件： （队列头文件略） #include "队列.h" #include<iostream> using namespace std;
#define UNVISITED 0 #define VISITED 1
class Graph{ private:
int numVertex,numEdge; int **matrix; int *mark;
//find the location of vertex int LocalVer(char v) {
return (int)v-97; } //find the vertex char unLocalVer(int v) {
for (int i = 0; i < numVertex; i++) mark[i] = UNVISITED;
int v, w; Q.enqueue(start); setMark(start, VISITED); while (Q.length()!= 0) {
v = Q.dequeue(); print(v); for (w = first(v); w < n(); w = next(v, w)) if(getMark(w)==UNVISITED){
matrix[i][j] = 0; } int n(){ return numVertex; } int e(){ return numEdge; }
//return the neighbor of v int first(int v){
for (int i = 0; i < numVertex; i++) if (matrix[v][i] != 0) return i;
matrix = (int **) new int *[numVertex]; for (int i = 0; i < numVertex; i++)
matrix [i]= new int [numVertex];
for (int i = 0; i < numVertex; i++) for (int j = 0; j < numVertex; j++)
cout << "请输入顶点" << i << ":" << endl; cin >> g.local[i]; } for (int i = 0; i < m; i++) { char v1, v2; int wt; cout << "\n 请输入顶点两条边和他们的权值:"; cin >> v1 >> v2 >> wt; g.setEdge(v1,v2,wt); } cout << "\n 输出：\n 深度遍历:\n"; g.DFS(0); cout << "\n"; cout << "\n 输出：\n 广度遍历:\n"; g.BFS(0,Q); cout << "\n"; system("pause"); } 运行结果如下：
setMark(w, VISITED); Q.enqueue(w);
}
}
} }; 源文件： #include "图.h" #include<iostream> using namespace std;
void main()
{ int n;//The num of Vertex int m;//The edge of it
return numVertex;/来自百度文库if it is none,return n; }
//set edge between v1 and v2 with wt（weight） void setEdge(char v1, char v2, int wt){
if (wt < 0){ cout << "It is an illegal weight value!\n"; system("pause"); exit(-1); } int p = LocalVer(v1); int q = LocalVer(v2); if (matrix[p][q] == 0)numEdge++;//if it is not the first setEdge,donnot add matrix[p][q] = wt; }
HUNAN UNIVERSITY
课程实验报告
题 目 图的遍历问题
学生姓名
王家威
学生学号
201308070217
专 业 班 级 智能科学与技术 1302 班
指导老师
朱宁波
背景
网络蜘蛛即 Web Spider，是一个很形象的名字。把互联网比喻成一个蜘蛛网，那么 Spider 就是在网上爬来爬去的蜘蛛。网络蜘蛛是通过网页的链接地址来寻找网页，从网站某一个页 面（通常是首页）开始，读取网页的内容，找到在网页中的其它链接地址，然后通过这些链 接地址寻找下一个网页，这样一直循环下去，直到把这个网站所有的网页都抓取完为止。如 果把整个互联网当成一个网站，那么网络蜘蛛就可以用这个原理把互联网上所有的网页都抓 取下来。这样看来，网络蜘蛛就是一个爬行程序，一个抓取网页的程序。 在抓取网页的时候，网络蜘蛛一般有两种策略：广度优先和深度优先（如下面这张简单化的 网页连接模型图所示，其中 A 为起点 也就是蜘蛛索引的起点）。
delete[] matrix[i]; delete[] matrix; } void Init(int n) { numVertex = n; numEdge = 0; mark = new int[n]; local = new char[n];
for (int i = 0; i < numVertex; i++) mark[i] = UNVISITED;
return numVertex;//if it is none,return n; }
//return the v's neihbor after w; int next(int v, int w){
for (int i = w + 1; i < numVertex; i++) if (matrix[v][i] != 0) return i;
深度优先顾名思义就是让网络蜘蛛尽量的在抓取网页时往网页更深层次的挖掘进去 讲究的 是深度!也泛指: 网络蜘蛛将会从起始页开始，一个链接一个链接跟踪下去，处理完这条线 路之后再转入下一个起始页，继续跟踪链接! 则访问的节点顺序为==> A --> B --> E --> H --> I --> C --> D --> F --> K --> L --> G。深度爬行的优点是:网络蜘蛛程序在设计的时候相对比较容 易些；缺点是每次爬行一层总要向"蜘蛛老家" 数据库访问一下。问问老总有必要还要爬下 一层吗! 爬一层 问一次.... 如果一个蜘蛛不管 3721 不断往下爬 很可能迷路更有可能爬到 国外的网站去，不仅增加了系统数据的复杂度更是增加的服务器的负担。 广度优先在这里的定义就是层爬行，即一层一层的爬行， 按照层的分布与布局去索引处理 与抓取网页。则访问的节点顺序为==> A --> B --> C --> D --> E --> F --> G --> H --> I--> K --> L。广 度爬行的优点是对数据抓取更容易控制些，对服务器的负栽相应也明显减轻了许多。
测试数据（以背景描述的图为例）
输入
输入顶点数和弧数:8 9 输入 8 个顶点. 输入顶点 0:a 输入顶点 1:b 输入顶点 2:c 输入顶点 3:d 输入顶点 4:e 输入顶点 5:f
输入顶点 6:g 输入顶点 7:h 输入 9 条弧. 输入弧 0:a b 1 输入弧 1:b d 1 输入弧 2:b e 1 输入弧 3:d h 1 输入弧 4:e h 1 输入弧 5:a c 1 输入弧 6:c f 1 输入弧 7:c g 1 输入弧 8:f g 1
}
int getMark(int v){ return mark[v]; }
void setMark(int v,int val){ mark[v] = val;
}
void print(int v){//print the vertex cout <<unLocalVer(v)<<" ";
}
//DFS void DFS(int v){
//del v1 v2 void delEdge(char v1, char v2) {
int p = LocalVer(v1); int q = LocalVer(v2); if (matrix[p][q] != 0)numEdge--;//if it is not the first delEdge,donnot delete matrix[p][q] = 0; }
bool isEdge(char v1, char v2){ int p = LocalVer(v1); int q = LocalVer(v2); return matrix[p][q] != 0;
}
int weight(char v1, char v2){ int p = LocalVer(v1); int q = LocalVer(v2); return matrix[p][q];
问题描述
若用有向网表示网页的链接网络，其中顶点表示某个网页，有向弧表示网页之间的链接关系。 试设计一个网络蜘蛛系统，分别以广度优先和深度优先的策略抓取网页。
基本要求
（1） （2）
首先输入顶点的数量，然后是各顶点对应的字母，再输入各条弧（权值都置 1）。 输出从首个顶点开始的广度优先遍历序列和深度先遍历序列。
print(v); setMark(v, VISITED); for (int w = first(v); w < n(); w = next(v, w)) {
if (getMark(w)==UNVISITED) DFS(w); } }
//BFS void BFS(int start,Queue Q){
return local[v]; } public: char *local; Graph(int _numVertex) {
Init(_numVertex); } ~Graph(){
delete[] mark; delete[] local; for (int i = 0; i < numVertex; i++)
输出
广度优先遍历: a b d h e c f g 深度优先遍历: a b c d e f g h
代码：
图的头文件： （队列头文件略） #include "队列.h" #include<iostream> using namespace std;
#define UNVISITED 0 #define VISITED 1
class Graph{ private:
int numVertex,numEdge; int **matrix; int *mark;
//find the location of vertex int LocalVer(char v) {
return (int)v-97; } //find the vertex char unLocalVer(int v) {
for (int i = 0; i < numVertex; i++) mark[i] = UNVISITED;
int v, w; Q.enqueue(start); setMark(start, VISITED); while (Q.length()!= 0) {
v = Q.dequeue(); print(v); for (w = first(v); w < n(); w = next(v, w)) if(getMark(w)==UNVISITED){
matrix[i][j] = 0; } int n(){ return numVertex; } int e(){ return numEdge; }
//return the neighbor of v int first(int v){
for (int i = 0; i < numVertex; i++) if (matrix[v][i] != 0) return i;
matrix = (int **) new int *[numVertex]; for (int i = 0; i < numVertex; i++)
matrix [i]= new int [numVertex];
for (int i = 0; i < numVertex; i++) for (int j = 0; j < numVertex; j++)