数据结构实训

最新推荐文章于 2022-04-04 10:00:21 发布
最新推荐文章于 2022-04-04 10:00:21 发布
阅读量1.4k 收藏 6
点赞数 3
分类专栏： 作业 文章标签： 数据结构 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46002826/article/details/120101496
版权

6-1 两顶点之前有路径吗？ (20 分)

对于给定的无向图及两个图中的顶点，请实现一个函数，分别打印包含这两个顶点的连通分量中的顶点数，并判断这两个顶点之间是否有路径。
函数接口定义：

int hasPath(struct Graph *g, int v, int w);

其中v和w是顶点
图定义如下:

#define MaxVertexNum 20   /* 最大顶点数 */
struct Graph{
    int v;    /*  顶点数量 */
    int Adj[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
};

题目保证图至少有一个顶点
函数分别在第一行和第二行打印包含v和w的连通分量中顶点的数量。
如果 v和w之间有路径，函数返回1, 否则返回0.
提示:

  1. 你可以定义多个函数，也可以定义全局变量.
  2. 当v和w是同一个顶点时，认为v和w之间是有路径的。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>
#define MaxVertexNum 20   /* 最大顶点数设为20 */
struct Graph{
    int v;  // amount of vertices
    int Adj[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
};
int visited[MaxVertexNum]; /* 顶点的访问标记 */
struct Graph* CreateGraph(){
    int v;
    scanf("%d",&v);
    struct Graph* g;
    g = malloc(sizeof(struct Graph));
    if(!g) return NULL;
    g->v = v;
    for(int i=0; i<v; i++){
        visited[i] = 0;
        for(int j=0; j<v; j++)
            scanf("%d",&(g->Adj[i][j]));
    }
    return g;
}
int hasPath(struct Graph *g, int v, int w);
int main(){
    struct Graph* g;
    g = CreateGraph();
    int v,w;
    scanf("%d%d", &v, &w);
    printf("%s\n", hasPath(g,v,w) ? "Yes" : "No");
    return 0;
}
/* 你的代码将被嵌在这里 */

输入样例：在这里插入图片描述
对于此图及样例测试程序规定的输入格式：

8
0 1 1 0 0 0 0 1
1 0 0 0 1 0 0 0
1 0 0 0 1 0 0 0
0 0 0 0 0 1 0 0
0 1 1 0 0 0 0 0
0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0
1 3

Sample Output：

5
2
No

代码：

int hasPath(struct Graph *g, int v, int w){
	int cnt1=0,cnt2=0;
	int first=-1,last=-1;
	int Q[MaxVertexNum];
	for(int i=0;i<MaxVertexNum;i++){
		visited[i]=0;
	}
	Q[++last]=v;
	visited[v]=1;
    cnt1++;
	while(first!=last){
		v=Q[++first];
		for(int i=0;i<g->v;i++){
			if(g->Adj[v][i]==1&&visited[i]==0){
				Q[++last]=i;
				visited[i]=1;
				cnt1++;
			}
		}
	}
	printf("%d\n",cnt1);
	for(int i=0;i<MaxVertexNum;i++){
		visited[i]=0;
		Q[i]=0;
	}
	first=-1,last=-1;
	Q[++last]=w;
	visited[w]=1;
    cnt2++;
	while(first!=last){
		w=Q[++first];
		for(int i=0;i<g->v;i++){
			if(g->Adj[w][i]==1&&visited[i]==0){
				Q[++last]=i;
				visited[i]=1;
				cnt2++;
			}
		}
	}
	printf("%d\n",cnt2);
	if(g->Adj[v][w]==1||v==w){
		return 1;
	}
	return 0;
	
}

7-1 多项式的加法 (20 分)

用链表表示多项式，并实现多项式的加法运算
输入格式：

输入在第一行给出第一个多项式POLYA的系数和指数，并以0,0 结束第一个多项式的输入；在第二行出第一个多项式POLYB的系数和指数，并以0,0 结束第一个多项式的输入。

输出格式：
对每一组输入，在一行中输出POLYA+POLYB和多项式的系数和指数。
输入样例:

5,0 2,1 1,6 8,15 0,0
-2,1 3,6 4,8 0,0

输出样例：

5,0 4,6 4,8 8,15

偷懒代码：

#include<iostream>
#include<map>
using namespace std;
map<int,int>mp;
map<int,int>::iterator it;
int main(){
	int a,b;
	char c;
	while(cin>>a>>c>>b){
		if(a==0&&b==0){
			break;
		}
		mp[b]=a;
	}
	while(cin>>a>>c>>b){
		if(a==0&&b==0){
			break;
		}
		mp[b]+=a;
	}
	for(it=mp.begin();it!=mp.end();it++){
		if(it->second!=0){
			cout<<it->second<<","<<it->first<<" ";
		}
	}
	cout<<endl;
    return 0;
}

7-2 括号配对 (20 分)

设表达式中允许包含3种括号：圆括号、方括号和大括号。即小括号、中括号和大括号。 编写一个算法来判断表达式中的括号是否正确配对，要求利用栈的结构实现。
输入格式：
输入一行带圆括号、方括号和大括号的字符串。
输出格式：
若匹配，输出yes。若不匹配，输出no。
输入样例1：

([1+2])

输出样例1：

yes

输入样例2：

([

输出样例2：

no

代码：

#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<stack>
#include<cstdio>
using namespace std;
#define MAXN 10100
stack<char>st;
int main(){
	string s;
	cin>>s;
	int flag=0;
	for(int i=0;i<s.length();i++){
		if(s[i]=='('||s[i]=='{'||s[i]=='['){
			st.push(s[i]);
		}else if(s[i]==')'){
			if(st.top()=='('){
				st.pop();
			}else{
				flag=1;
				break;
			}
		}else if(s[i]==']'){
			if(st.top()=='['){
				st.pop();
			}else{
				flag=1;
				break;
			}
		}else if(s[i]=='}'){
			if(st.top()=='{'){
				st.pop();
			}else{
				flag=1;
				break;
			}
		}
	}
	if(st.size()==0&&flag==0){
		cout<<"yes"<<endl;
	}else{
		cout<<"no"<<endl;
	}
	return 0;
}

7-3 串的模式匹配 (20 分)

给定两个由英文字母组成的字符串 String 和 Pattern，要求找到 Pattern 在 String 中第一次出现的位置，并将此位置后的 String 的子串输出。如果找不到，则输出“Not Found”。

本题旨在测试各种不同的匹配算法在各种数据情况下的表现。各组测试数据特点如下：

数据0：小规模字符串，测试基本正确性；
数据1：随机数据，String 长度为 105，Pattern 长度为 10；
数据2：随机数据，String 长度为 105，Pattern 长度为 102；
数据3：随机数据，String 长度为 105，Pattern 长度为 103；
数据4：随机数据，String 长度为 105，Pattern 长度为 104；
数据5：String 长度为106，Pattern 长度为 105；测试尾字符不匹配的情形；
数据6：String 长度为 106，Pattern 长度为 105；测试首字符不匹配的情形。
输入格式：
输入第一行给出 String，为由英文字母组成的、长度不超过 106 的字符串。第二行给出一个正整数 N（≤10），为待匹配的模式串的个数。随后 N 行，每行给出一个 Pattern，为由英文字母组成的、长度不超过 105 的字符串。每个字符串都非空，以回车结束。
输出格式：
对每个 Pattern，按照题面要求输出匹配结果。
输入样例：

abcabcabcabcacabxy
3
abcabcacab
cabcabcd
abcabcabcabcacabxyz

输出样例：

abcabcacabxy
Not Found
Not Found

代码：

#include<iostream>
#include<cstring>
#include<string>
#include<cstdio>
using namespace std;
#define MAXN 1000010
int main(){
	char s[MAXN],t[MAXN];
	cin>>s;
	int n;
	cin>>n;
	char *p;
	for(int i=0;i<n;i++){
		cin>>t;
		p=strstr(s,t);
		if(p){
			cout<<p<<endl;
		}else{
			cout<<"Not Found"<<endl;
		}
	}
	return 0;
}

7-4 找鞍点 (20 分)

一个矩阵元素的“鞍点”是指该位置上的元素值在该行上最大、在该列上最小。
本题要求编写程序，求一个给定的n阶方阵的鞍点。
输入格式：
输入第一行给出一个正整数n（1≤n≤6）。随后n行，每行给出n个整数，其间以空格分隔。
输出格式：
输出在一行中按照“行下标 列下标”（下标从0开始）的格式输出鞍点的位置。如果鞍点不存在，则输出“NONE”。题目保证给出的矩阵至多存在一个鞍点。
输入样例1：

4
1 7 4 1
4 8 3 6
1 6 1 2
0 7 8 9

输出样例1：

2 1

输入样例2：

2
1 7
4 1

输出样例2：

NONE

代码：

#include<iostream>
#include<cstring>
#include<string>
#include<cstdio>
using namespace std;
#define MAXN 10
int a[MAXN][MAXN];
int hang[MAXN],lie[MAXN];
int main(){
	int n;
	cin>>n;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			cin>>a[i][j];
		}
	}
	memset(hang,0,sizeof(hang));
	memset(lie,1000000,sizeof(lie));
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			hang[i]=max(hang[i],a[i][j]);
			lie[i]=min(lie[i],a[j][i]);
		}
	}	
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(a[i][j]==hang[i]&&a[i][j]==lie[j]){
				cout<<i<<" "<<j<<endl;
				return 0;
			}
		}
	}
	cout<<"NONE"<<endl;
	return 0;
}

7-5 哈夫曼编码 (20 分)

给定一段文字，如果我们统计出字母出现的频率，是可以根据哈夫曼算法给出一套编码，使得用此编码压缩原文可以得到最短的编码总长。然而哈夫曼编码并不是唯一的。例如对字符串"aaaxuaxz"，容易得到字母 ‘a’、‘x’、‘u’、‘z’ 的出现频率对应为 4、2、1、1。我们可以设计编码 {‘a’=0, ‘x’=10, ‘u’=110, ‘z’=111}，也可以用另一套 {‘a’=1, ‘x’=01, ‘u’=001, ‘z’=000}，还可以用 {‘a’=0, ‘x’=11, ‘u’=100, ‘z’=101}，三套编码都可以把原文压缩到 14 个字节。但是 {‘a’=0, ‘x’=01, ‘u’=011, ‘z’=001} 就不是哈夫曼编码，因为用这套编码压缩得到 00001011001001 后，解码的结果不唯一，“aaaxuaxz” 和 “aazuaxax” 都可以对应解码的结果。本题就请你判断任一套编码是否哈夫曼编码。
输入格式：
首先第一行给出一个正整数 N（2≤N≤63），随后第二行给出 N 个不重复的字符及其出现频率，格式如下：

c[1] f[1] c[2] f[2] … c[N] f[N]

其中c[i]是集合{‘0’ - ‘9’, ‘a’ - ‘z’, ‘A’ - ‘Z’, ‘_’}中的字符；f[i]是c[i]的出现频率，为不超过 1000 的整数。再下一行给出一个正整数 M（≤1000），随后是 M 套待检的编码。每套编码占 N 行，格式为：

c[i] code[i]

其中c[i]是第i个字符；code[i]是不超过63个’0’和’1’的非空字符串。
输出格式：
对每套待检编码，如果是正确的哈夫曼编码，就在一行中输出"Yes"，否则输出"No"。
注意：最优编码并不一定通过哈夫曼算法得到。任何能压缩到最优长度的前缀编码都应被判为正确。
输入样例：

7
A 1 B 1 C 1 D 3 E 3 F 6 G 6
4
A 00000
B 00001
C 0001
D 001
E 01
F 10
G 11
A 01010
B 01011
C 0100
D 011
E 10
F 11
G 00
A 000
B 001
C 010
D 011
E 100
F 101
G 110
A 00000
B 00001
C 0001
D 001
E 00
F 10
G 11

输出样例：

Yes
Yes
No
No

代码：

#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#include<cmath>
#include<map>
using namespace std;
int main(){
	priority_queue<int,vector<int>,greater<int>>p;
	map<string,string>mp2;
	int n,m,f,a[101];
	string c,code;
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>c>>f;
		p.push(f);
		a[i]=f;
	}
	int ans=0;
	while(p.size()>=2){
		int min1=p.top();
		p.pop();
		int min2=p.pop();
		p.pop();
		ans+=(min1+min2);
		p.puah(min1+min2);
	}
	int ans1;
	string str[101];
	cin>>m;
	for(int i=0;i<m;i++){
		ans1=0;
		for(int j=0;j<n;j++){
			cin>>c>>code;
			str[j]=code;
			ans1+=code.size()*a[j];
		}
		
		if(ans1!=ans){
			cout<<"No\n"<<endl;
		}else{
			int flag=1;
			for(int j=0;j<n;j++){	
				for(int l=0;l<n;l++){
					if(j!=l&&str[l].size()>=str[j].size()){
						if(str[l].substr(0,str[j].size())==s2[j]){
							flag=0;
							break;
						}
					}
				}	
				if(flag==0) break;			
			}
			if(flag==1){
				printf("Yes\n");
			} else{
				printf("No\n");
			}
			
		}
		
	}
}

7-7 畅通工程之局部最小花费问题 (20 分)

#include<iostream>
using namespace std;
#define MAXN 110
#define INF 0xffffff
int AdjMatrix[MAXN][MAXN];
int lowcost[MAXN];
int closest[MAXN];
int sumCost=0;
void prim(int v,int n){
    int mincost;
    int k;
    for(int i=1;i<=n;i++){
        lowcost[i]=AdjMatrix[v][i];
        closest[i]=v;
    }
    lowcost[v]=-1;
    for(int i=0;i<n-1;i++){
        mincost=INF;
        for(int j=1;j<=n;j++){
            if(lowcost[j]!=-1&&lowcost[j]<mincost){
                mincost=lowcost[j];
                k=j;
            }
        }
        sumCost+=mincost;
        lowcost[k]=-1;
        for(int j = 1;j<=n;j++){
            if(AdjMatrix[k][j]<lowcost[j]&&j!=k){
                lowcost[j]=AdjMatrix[k][j];
                closest[j]=k;
            }
        }
    }
}
int main(){
    int n;
    cin>>n;
    for(int i=0;i<MAXN;i++){
         for(int j = 0;j<MAXN;j++){
         	AdjMatrix[i][j]=INF; 
		 }
               	
	}
    for(int i=0;i<n*(n-1)/2;i++){
        int x,y,cost,flag;
        cin>>x>>y>>cost>>flag;
        if(flag){
            AdjMatrix[x][y]=AdjMatrix[y][x]=0;        	
		}else{
            AdjMatrix[x][y]=AdjMatrix[y][x]=cost;			
		}
    }
    prim(1,n);
    cout<<sumCost<<endl;
    return 0;
}

7-8 哈利·波特的考试 (20 分)

#include<iostream>
#include<cstring>
using namespace std;
#define MAXN 1010
int data[MAXN][MAXN];
int main(){
	int n,m;
	cin>>n>>m;
    for(int i=0;i<=n;i++){
		for(int j=0;j<=n;j++){
			data[i][j]=1000000000;
		}
	}
	for(int i=0;i<=n;i++){
		data[i][i]=0;
	}
	int a,b,c;
	for(int i=0;i<m;i++){
		cin>>a>>b>>c;
		data[a][b]=data[b][a]=c;
	}
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(data[i][j]>data[i][k]+data[k][j]){
					data[i][j]=data[i][k]+data[k][j];
				}				
			}

		}
	}
	int maxx=1000000000;
	int ans=-1;
	for(int i=1;i<=n;i++){
		int maxx1=-1;
		for(int j=1;j<=n;j++){
			if(data[i][j]>maxx1){
				maxx1=data[i][j];
			}
		}
		if(maxx1<maxx){
			ans=i;
			maxx=maxx1;
		}
	}
	if(maxx==1000000000){
		cout<<0;
	}else{
		cout<<ans<<" "<<maxx;
	}
	return 0;
}

7-9 整型关键字的散列映射 (20 分)

#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<stack>
#include<cstdio>
using namespace std;
#define MAXN 101000
int a[MAXN],b[MAXN],c[MAXN];
int main(){
	int n,p,x,cnt=0;
	cin>>n>>p;
	for(int i=0;i<n;i++){
		cin>>a[i];
	}
	memset(c,-1,sizeof(c));
	for(int i=0;i<n;i++){
		x=a[i];
		if(c[a[i]]!=-1){
			continue;
		}
		while(1){
			if(b[x%p]==0){
				b[x%p]=1;
				c[a[i]]=x%p;
				break;
			}
			x++;
		}	
	}
	cout<<c[a[0]];
	for(int i=1;i<n;i++){
		cout<<" "<<c[a[i]];
	}
	cout<<endl;
	return 0;
}

7-10 PAT排名汇总 (20 分)

#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<map>
using namespace std;
#define MAXN 30010
typedef pair<string,int>pii;
vector<pii>v;
vector<pii>::iterator is;
//map<string,int>mp;
//map<string,int>::iterator it;
struct node{
	int id;
	string s;
	int score;
	int p;
}a[MAXN];
bool cmp1(node x,node y){
	if(x.score==y.score){
		return x.s<y.s;
	}
	return x.score>y.score;
}
bool cmp2(pii x,pii y){
	if(x.second==y.second){
		return x.first<y.first;
	}
	return x.second>y.second;
}
int main(){
	int n,k,tscore,cnt=1;
	cin>>n;
	string ts;
	int sum=1,temp=0,zongshu=0,paiming=1;
	for(int i=1;i<=n;i++){
		cin>>k;
		v.clear();
		paiming=1,temp=0,zongshu=0;
		for(int j=0;j<k;j++){  
			cin>>ts>>tscore;
            //mp[ts]=tscore;
			v.push_back(make_pair(ts,tscore));//第一次正确代码的基础上去掉了map,用make_pair存在vector里代替map转vector
		}
        /*for(it=mp.begin();it!=mp.end();it++){
			v.push_back(pii(it->first,it->second));
		}*/
		sort(v.begin(),v.end(),cmp2);
		for(is=v.begin();is!=v.end();is++){
			zongshu++;
			a[cnt].id=i;
			a[cnt].s=is->first;
			a[cnt].score=is->second;
			if(temp==is->second){
				a[cnt].p=paiming;
			}else{
				a[cnt].p=zongshu;
				paiming=zongshu;
			}
			temp=is->second;
			cnt++;
		}
	}
	int cnt1=1;
	sort(a+1,a+cnt,cmp1);
	cout<<cnt-1<<endl;
	for(int i=1;i<cnt;i++){
		cout<<a[i].s<<" ";
		if(a[i].score==a[i-1].score){
			cout<<cnt1<<" ";
		}else{
			cnt1=i;
			cout<<i<<" ";
		}
		cout<<a[i].id<<" "<<a[i].p<<endl;
	}
	return 0;
	
}
找不到我_
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实训报告
lanheit的博客
02-16 1万+
实训目的 数据结构实训是计算机科学与技术专业集中实践环节之一。数据结构是本专业一门重要的专业基础课程，是一门关键性核心课程。该课程较系统地介绍了软件设计中常用的数据结构以及相应的存储结构和实现算法，介绍了常用的多种查找和排序技术。该课程将为整个专业的学习以及软件设计水平的提高打下良好的基础。 数据结构是一门实践性较强的课程，为了学好这门课程，必须在掌握理论知识的同时，加强上机实践，设置数据结构实训环节十分重要。 实训项目要求 本次实训我选择的题目是二叉树的遍历与应用算法设计与实现 二叉树是树形结构..
第5周项目3 括号的匹配
fy77771的博客
10-12 253
假设表达式中允许三种括号：圆括号、方括号和大括号。编写一个算法，判断表达式中的各种左括号是否与右括号匹配。  例如，输入2+(3+4)*[2+{[3]}]-8，输出匹配正确；输入2+(3+4*[2)+{[3]}-8，输出匹配错误。 提示：（1）遇到左括号入栈，遇到右括号后，出栈一个符号，看是否配对。若配对，继续，直到读完所有的符号，栈也正好为空。若在中间出现一个不配对的，或者_________
假设表达式中包含三种括号 圆括号方括号大括号 设计一个算法用顺序栈判断表达式中的括号是否正确配对
Frozensmile的博客
09-24 2万+
栈的应用 stack <char> Q; char s[11000]; int main() { int T,i; Q.push('#'); scanf("%d",&T); while(T--) { scanf("%s",s); int len=strlen(s); ...
括号匹配检验算法-栈的应用（C语言）
kim的博客
04-04 2674
假设表达式中包含三种括号：圆括号( )、方括号[ ]和花括号{}，并且它们可以任意嵌套。 例如{[()]()[{}]}或[{()}([])]等为正确格式，而{[}()]或[({)]为不正确的格式。 输入可以是任意表达式，但只对三种括号的匹配情况进行处理判断,如不匹配，给出错误提示。 输入：[(3+4)*{5}-3] 输出：true 输入：[{3+6[}(3+5)] 输出：required ‘]’ 输入：{}())] 输出：required ‘(‘ 程序完整代码: #include&lt
第六周 项目三 括号的匹配
苏凯祺的博客
12-14 388
运行结果：
数据结构实训总结.doc
07-11
数据结构实训是对理论知识的深度实践，通过本次实训，我深感收获颇丰。首先，我对数据结构的理解得以巩固和深化，这不仅强化了我在课堂上学到的知识，而且提升了我将这些知识应用于实际问题的能力。数据结构是计算机...
数据结构实训报告.doc
11-29
数据结构实训报告 数据结构实训报告是信息管理与信息系统专业集中实践性环节之一，其目的就是要达到理论与实际应用相结合，使学生能够根据数据对象的特性，学会数据组织的方法，能把现实世界中的实际问题在计算机...
数据结构实训.docx
07-11
数据结构实训是计算机科学教育中的一个重要实践环节，它旨在通过实际操作加深学生对数据结构的理解。本实训项目主要关注队列这一基本数据结构，特别是基于链表实现的队列，即链式队列。队列是一种先进先出（First In...
括号匹配
Shadow
03-31 5457
题目描述：假设表达式中允许包含三种括号：圆括号、方括号和大括号。编写一个算法判断表达式中的括号是否正确匹配。 代码： #include #include #include #define MaxSize 100 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int top; }SqStack; //初始化栈
判断任意两个顶点间是否存在路径
05-25
采用邻接表存储有向图，此算法可以判断任意两个顶点间是否存在路径
数据结构实验手册
09-15
数据结构上机实验 很好用哦~ 里面的过程很详细 对你了解数据结构很有帮助
2019数据结构实训题目.doc
06-18
在网上看到许多数据结构实训的题目，内容及要求，和我这个差不多，可以提前看看，练习。
数据结构判断表达式3种括号匹配
10-08
数据结构上机作业。数据结构张宪超第二章13题。 假设表达式中允许包含3种括号：圆括号，方括号，大括号。设计算法采用顺序栈判断表达式中的括号是否正确配对。
判别表达式中三种括号是否匹配
10-22
1把元素x插入循环链表 表示的队列Q,Q指向队尾元素,Q.next指向头结点,Q.next.next指向队头元素 2判别表达式中三种括号是否匹配
求两点间所有路径的遍历算法
热门推荐
lysc_forever的专栏
12-23 5万+
1、深度优先遍历     1.1 深度优先遍历的定义     深度优先搜索（Depth_First Search）遍历类似于树的先根遍历，是树的先根遍历的推广。 假设给定图G，图中所有顶点未曾被访问过，则深度优先搜索可以从图中某个顶点v出发，访问此顶点，然后依次从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v有路径相通的顶点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未曾
6-3 两顶点之前有路径吗？ (20 分)
遇见生活
12-02 914
/* 这个题很简单，就是B题的一种变形，直接把B题的代码copy过来，然后改一下变量就过了 */ int hasPath(struct Graph *g, int v, int w) { int vm = 0; int q[1000]; int front = -1, rear = -1; q[++rear] = v; int...
有向图两顶点间是否存在路径
秀
12-02 4081
1.     试基于图的深度优先搜索策略编写一程序，判别以邻接表方式存储的有向图中是否存在有顶点Vi到Vj顶点的路径(i≠j)。   #include usingnamespacestd; constintN = 100; #include vectorint>data[N]; boolflag[N]; boolres= true; voiddfs(intstart,inte
河南工程学院数据结构实训
最新发布
06-28
河南工程学院的数据结构实训通常是为了让学生在理论学习之后，通过实际操作加深对数据结构的理解和应用能力。这可能包括以下几个部分： 1. **课程内容**：可能会涵盖数组、链表、树、图等基本数据结构，以及排序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值