头歌实践教学平台——数据结构

最新推荐文章于 2024-11-27 20:30:23 发布
最新推荐文章于 2024-11-27 20:30:23 发布
阅读量3k 收藏 25
点赞数 10
文章标签： 数据结构 算法 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/king_faner/article/details/134909541
版权

目录

一、迷宫问题

任务描述

编程要求

输入

输出

测试说明

二、基于Dijsktra算法的最短路径求解

三、六度空间理论

四、基于邻接表的新顶点的增加

五、基于邻接矩阵的新顶点的增加

一、迷宫问题

任务描述

密密被困在一个迷宫里，迷宫有n个路口，编号为1-n。密密现在站在第一个路口，出口编号为m。先给出每个路口通向何处，问密密能否逃出迷宫。

编程要求

输入

多组数据，每组数据n+2行。第一行为一个正整数n代表路口的个数，之后n行，这n行中的第i行为第i个路口的向左路口、向前路口、向右路口。最后一行为一个正整数m代表迷宫的终点。当n=0时输入结束。

输出

每组数据输出一行，若密密能走出迷宫，输出“YES”，否则输出“NO”。

测试说明

平台会对你编写的代码进行测试：

测试输入：

6

0 2 0

3 5 6

0 0 4

0 0 0

0 0 0

7 0 0

7

3

2 0 0

0 0 0

0 0 0

3

0

预期输出：

YES

NO

#include <iostream>
using namespace std;
int m,n;//m:出口编号  n:入口
int tag;//输出标记
int DFS(int k,int (*a)[3])
{//深度搜索第k层，k:当前路口
/**************begin************/
	int i,j;
	if(k==m)//到达出口
	{
		tag=1;
		return 0;
	}
	for(i=0;i<3;i++)//遍历三个路口
	{
		if(0!=a[k][i]&&tag!=1)//如果当前路口有通路，并且没有走过
		{
			DFS(a[k][i],a);//进入下一个路口 ，递归
		}
	}
	return 0;
    /**************end************/
}
int main()
{
	while(cin>>n)
	{
	if(n==0)break;
	int i,j;
	tag=0;
	int a[n+1][3];//迷宫
	for(i=1;i<=n;i++)
		for(j=0;j<3;j++)
			cin>> a[i][j];
	cin>>m;
	DFS(1,a);//从第一层开始搜索
	if(tag==1)
		cout<<"YES"<<endl;
	else if(tag==0)
		cout<<"NO"<<endl;
	}
	return 0;
}

二、基于Dijsktra算法的最短路径求解

#include <iostream>
#include <cstring>
#define MVNum 100
#define MaxInt 999
using namespace std;
 
typedef struct
{
	char vexs[MVNum];//点集 
	int arcs[MVNum][MVNum];//边的邻接矩阵 
	int vexnum,arcnum;//点数&边数 
}AMGraph;
 
int LocateVex(AMGraph G,char u)
 {//存在则返回u在顶点表中的下标;否则返回-1
   int i;
   for(i=0;i<G.vexnum;++i)
     if(u==G.vexs[i])
       return i;
   return -1;
 }
 
void InitAM(AMGraph &G)
{//初始化图 
 	memset(G.vexs,0,sizeof(G.vexs));//初始化顶点集 
	for(int i=0;i<MVNum;i++)
		for(int j=0;j<MVNum;j++)
			G.arcs[i][j]=MaxInt;
	return;
}
 
int CreateUDN(AMGraph &G)
{
	int i,j,k;  
	//G.vexnum++;
	for(i=0;i<G.vexnum;i++)
		cin>>G.vexs[i];
	for(k=0;k<G.arcnum;k++)//将边录入邻接矩阵，顺便将顶点录入 
	{
		char v1,v2;int w;
		cin>>v1>>v2>>w;//边的端点
		i=LocateVex(G,v1);
		j=LocateVex(G,v2);
		G.arcs[i][j]=w;
		G.arcs[j][i]=G.arcs[i][j];
		G.arcs[i][j]=w;
		G.arcs[k][k]=0;
	}
	return 1;
}
 
void ShortestPath_DIJ(AMGraph G){ 
    //用Dijkstra算法求有向网G的v0顶点到其余顶点的最短路径 
    char v0,v1;
    int S[MVNum];
    int D[MVNum];
    int Path[MVNum];
    cin>>v0>>v1;
    int v00=LocateVex(G,v0);
    int n=G.vexnum; int v;                  		//n为G中顶点的个数 
    for( v = 0; v<n; ++v){             	//n个顶点依次初始化 
       S[v] = false;                  	//S初始为空集 
       D[v] = G.arcs[v00][v];           	//将v0到各个终点的最短路径长度初始化 
       if(D[v]< MaxInt)  Path [v]=v00; //v0和v之间有弧，将v的前驱置为v0 
       else Path [v]=-1;               	//如果v0和v之间无弧，则将v的前驱置为-1 
      }//for 
      S[v00]=true;                    	//将v0加入S 
      D[v00]=0;     
	  int w;  int i;               		//源点到源点的距离为0 	
/*―开始主循环，每次求得v0到某个顶点v的最短路径，将v加到S集―*/ 
      for(i=1;i<n; ++i){               	//对其余n?1个顶点，依次进行计算 
        int min= MaxInt;  
        for(w=0;w<n; ++w) 
          if(!S[w]&&D[w]<min)  
              {v=w; min=D[w];}         	//选择一条当前的最短路径，终点为v 
        S[v]=true;                   		//将v加入S 
        for(w=0;w<n; ++w) 	//更新从v0出发到集合V?S上所有顶点的最短路径长度 
        if(!S[w]&&(D[v]+G.arcs[v][w]<D[w])){ 
             D[w]=D[v]+G.arcs[v][w];   	//更新D[w] 
             Path [w]=v;              		//更改w的前驱为v 
        }//if 
    }//for   
	w=LocateVex(G,v1);
	cout<<D[w]<<endl; 
	char road[G.vexnum];
	road[0]=G.vexs[w];
	int t=w;i=0;
	while(1)
	{  
		i++;
		if(t==-1||t==v00)break;
		//cout<<G.vexs[Path[t]];//<<"#"<<Path[t]<<"#"<<Path[Path[t]]
		road[i]=G.vexs[Path[t]];
		//if(t!=-1||t!=v00)cout<<" ";
		t=Path[t];	
	}
	while(i)
	{
		if(road[i])cout<<road[i]<<" ";
		i--;
	} 
	cout<<road[0];
	cout<<endl;
}//ShortestPath_DIJ 
 
void CA(AMGraph &G)
{//输出矩阵 
	int i;int j;
	//输出表头 
	cout<<0<<" ";
	for(int i=0,j;i<G.vexnum;i++)
	{
			cout<<G.vexs[i];
			if(i!=G.vexnum-1)cout<<" ";
	}
	cout<<endl;
	for(i=0;i<G.vexnum;i++)
	{
		//输出表头 
		cout<<G.vexs[i];
		if(i!=G.vexnum)cout<<" ";
		//输出内容 
		for(j=0;j<G.vexnum;j++)
		{
			cout<<G.arcs[i][j];
			if(j!=G.vexnum-1)cout<<" "; 
		}
		cout<<endl;
	}
 } 
 
int main()
{	
	while(1)
	{
		AMGraph G;
		InitAM(G);
		cin>>G.vexnum>>G.arcnum;
		if(G.vexnum==0&&G.arcnum==0)break;
		CreateUDN(G);
		//CA(G);
		ShortestPath_DIJ(G);
		//cout<<"--------------"<<endl;
	}
}

三、六度空间理论

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXN 10005

typedef struct VNode* Vertex;
struct VNode {
	Vertex Next;
	int V;
};

typedef struct LNode {
	Vertex FirstEdge;
	
}List[MAXN];

typedef struct GNode* Graph;
struct GNode {
	int Nv,Ne;
	List Head;
};

Graph G;


void Insert(int v,int w) {
	Vertex NewNode = (Vertex)malloc(sizeof(struct VNode));
	NewNode->V = v;
	NewNode->Next = G->Head[w].FirstEdge;
	G->Head[w].FirstEdge = NewNode;
	
	NewNode = (Vertex) malloc(sizeof(struct VNode));
	NewNode->V = w;
	NewNode->Next = G->Head[v].FirstEdge;
	G->Head[v].FirstEdge = NewNode;
}

int visit[MAXN];

void BFS(int s) {
	int Q[MAXN],front = 0,rear = 0,v,i;
	int tail,last = s,cnt = 0,level = 0,kase = s;
	Vertex p;
	double perc;
	Q[++rear] = s;
	visit[s] = 1;
	cnt ++;
	while(rear!=front) {
		v = Q[++front];
		for(p = G->Head[v].FirstEdge;p;p = p->Next) {
			if(!visit[p->V]) {
				Q[++rear] = p->V;
				visit[p->V] =1;
				cnt ++;
				tail = p->V;
			}
		}
		if(v==last) {
			level ++;
			last = tail;
		}
		if(level == 6) break;
	}
	perc = ((double)cnt)/((double)G->Nv) * 100;
	printf("%d: %.2lf%%\n",kase,perc);
}
int main()
{
	int i;
	int v,w;
	G = (Graph)malloc(sizeof(struct GNode));
	while(1){
	scanf("%d%d",&G->Nv,&G->Ne);
	if(!G->Nv||!G->Ne)
		return 0;
	for(i=1;i<=G->Nv;i++)
		G->Head[i].FirstEdge = NULL;
	for(i=1;i<=G->Ne;i++) {
		scanf("%d%d",&v,&w);
		Insert(v,w);
	}
	for(i=1;i<=G->Nv;i++) {
		memset(visit,0,sizeof(visit));
		BFS(i);
	}
	}
	return 0;
	
}

四、基于邻接表的新顶点的增加

#include<iostream>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MVNum 100
using namespace std;

typedef struct VNode{
	int data;
	struct VNode *next;
}VNode,*NodeList;

typedef struct{
	NodeList V[MVNum];
	int vexnum,arcnum;
}ALGragh ;

int CreateUDG(ALGragh  &G,int vexnum,int arcnum){
	G.vexnum = vexnum;
	G.arcnum = arcnum;
	for(int i=1;i<=vexnum; i ++){
		G.V[i] = new VNode;
		G.V[i]->next = NULL;
		G.V[i]->data = i;
	}
    for(int i=0;i<arcnum;i++){
		int v1,v2;
		cin>>v1>>v2;
		NodeList p1 =new VNode;
		p1->data =v2;
		p1->next =G.V[v1]->next;
		G.V[v1]->next = p1;
		NodeList p2 =new VNode;
		p2->data = v1;
		p2->next = G.V[v2]->next;
		G.V[v2]->next = p2;
	}
	return OK;
}

int InsertVex(ALGragh  &G){
	int data;
	cin>>data;
	G.vexnum++;
	G.V[G.vexnum] = new VNode;
    G.V[G.vexnum]->data = data;
    G.V[G.vexnum]->next = NULL;
    return OK;
}

int PrintGraph(ALGragh  G){
	for(int i=1;i<=G.vexnum;i++){
		NodeList p =G.V[i];
		while(p->next){
			cout<<p->data<<" ";
			p = p->next;
		}
		cout<<p->data<<endl;
	}
	return OK;
}



int main()
{
	int n,m;
	while(cin>>n>>m)
	{
      	if(n==0&&m==0) break;     //输入结束标志
      	ALGragh G;
       	CreateUDG(G,n,m);      //采用邻接表表示法，创建无向图G
     	InsertVex(G);        //在图G中增添新顶点
	   	PrintGraph(G);      //输出图G
	}
	return 0;
}

五、基于邻接矩阵的新顶点的增加

#include <iostream>
#define MaxInt 32767 
#define MVNum 100
#define OK 1
#define ERROR -1
using namespace std;
 
typedef struct{
	char vexs[MVNum];
	int arcs[MVNum][MVNum];
	int vexnum,arcnum;
}AMGraph;
 
int InitAM(AMGraph &G){
    for(int i =0;i<MVNum; i++)
      G.vexs[i] = 0;
    for(int i =0;i<MVNum; i++)
     for(int j =0 ; j<MVNum;j++){
	 	G.arcs[i][j]= 0;
	}
	return OK;
}
 
int LocateVex(AMGraph G,char v){
	for(int i=0;i<G.vexnum;i++)
	 if(v==G.vexs[i])
	   return i;
	return ERROR;
}
 
int CreateUDN(AMGraph &G){
	int n;
	int vex = 0;
	for(n=0;n<G.arcnum;n++){
		char v1,v2;
		cin>>v1>>v2;
		int tag = 0;
		for(int i =0;i<G.vexnum;i++){
			if(v1==G.vexs[i]) tag = 1;
		}
		if(tag == 0){
			G.vexs[vex] = v1;
			vex++;
		}
		tag = 0;
		for(int i =0;i<G.vexnum;i++){
			if(v2==G.vexs[i]) tag = 1;
		}
		if(tag == 0){
			G.vexs[vex] = v2;
			vex++;
		}
		int i = LocateVex(G,v1);
		int j = LocateVex(G,v2);
		G.arcs[i][j] = 1;
		G.arcs[j][i] = G.arcs[i][j]; 
	}
	cin>>G.vexs[vex];
    G.vexnum++;
	return OK; 
}
void PrintAM(AMGraph &G){
	int i,j;
	cout<<0<<" ";
	for(i=0;i<G.vexnum;i++)
	{
			cout<<G.vexs[i];
			if(i!=G.vexnum-1)
			  cout<<" ";
	}
	cout<<endl;
	for(i=0;i<G.vexnum;i++)
	{
		cout<<G.vexs[i]; //输出表头 
		if(i!=G.vexnum)
		   cout<<" ";
		//输出内容 
		for(j=0;j<G.vexnum;j++)
		{
			cout<<G.arcs[i][j];
			if(j!=G.vexnum-1)
			  cout<<" "; 
		}
		cout<<endl;
	}
 } 
 int main()
{	
    AMGraph G;
	while(cin>>G.vexnum>>G.arcnum&&G.vexnum!=0&&G.arcnum!=0)
	{	InitAM(G);
		CreateUDN(G);
		PrintAM(G); 	
	}
}

头歌实践平台：招聘大数据——数据分析
Mb_JUJI的博客
12-12 1762
头歌：招聘大数据——数据分析
Educoder头歌实践平台 Java 数据结构之图 答案.txt
11-10
Educoder头歌实践平台 中 Java 数据结构之图 共4关 金币共2300 的那个实践项目答案 由于图论问题渗透整个计算机科学，图算法对于计算机学科至关重要。成百上千的计算问题最后都可以归约为图论问题。
头歌JAVA数据结构答案
热门推荐
嵌入一下?的博客
11-28 2万+
头歌JAVA数据结构答案 一、Java数据结构-循环链表的设计与实现 第1关 单循环链表的实现—链表的添加、遍历 package step1; /** * Created by sykus on 2018/1/15. */ public class MyCircleLinkedList { private Node head;//头结点, 不存数据 private Node tail;//尾结点, 指向链表的最后一个节点 private int size; publi
头歌实践平台-数据结构-二叉树及其应用
toptopniba的博客
11-13 4808
【代码】头歌实践平台-数据结构-二叉树及其应用。
头歌实践平台（python数据结构）(1-6)
qq_62640789的博客
11-15 1万+
任务描述本关任务：编写代码实现栈的基本操作。相关知识为了完成本关任务，你需要掌握：栈抽象数据类型；Python 中 List 的操作方法。栈抽象数据类型抽象数据类型“栈”是一个有次序的数据集。 在栈中，数据项的加入和移除都仅发生在同一端，这一端被称为栈顶，相对地，把另一端称为栈底。距离栈底越近的数据项， 留在栈中的时间就越长，而最新加入栈的数据项会被最先移除。这种次序通常称为“后进先出”（ LIFO ）：Last in First out。下图是一个栈的抽象模型：转存失败重新上传取消图1 栈模型抽象数据类型
头歌实践教学平台-数据结构与算法课程设计-C++STL与算法基础-答案
Jasoncmd的博客
10-27 738
里面只有五章答案，有需要的自取。
课程思政视域下基于BOPPPS的混合式教学实践研究——以“数据结构与算法”为例.pdf
08-07
本文以《课程思政视域下基于BOPPPS的混合式教学实践研究——以“数据结构与算法”为例》为题，探讨了如何在“数据结构与算法”这一重要计算机科学基础课程中实施课程思政，并运用BOPPPS模型来进行混合式教学设计，...
头歌教学实践平台 Web前端开发基础 HTML-表单类的标签
01-20
HTML（HyperText Markup Language）是Web前端开发的基础，用于创建网页结构和呈现内容。在HTML中，表单类的标签是构建用户交互界面的关键元素，它们允许用户输入数据并发送到服务器进行处理。本教程将深入讲解这些...
基于移动云平台的翻转课堂教学改革实践——以《数据结构》课程为例.pdf
08-07
例如，在《数据结构》课程的改革实践中，教师在课前需要制作详细的学习任务单，说明自学内容与要求，并且要整理和推送相关的教学参考资料和自测题目。在课堂上，教师将更多地扮演组织者和引导者的角色，而不是单向的...
头歌数据结构循环队列及链队列的基本操作
05-18
在本文中，我们将深入探讨头歌数据结构中的两种基本数据结构——循环队列和链队列，以及它们在实现过程中的基本操作。首先，我们来理解这两种数据结构的概念。 循环队列是一种线性数据结构，它模拟了现实生活中的...
头歌educoder教学实践平台计算机组成原理计算机数据表示.zip
07-12
头歌educoder教学实践平台计算机组成原理计算机数据表示第1—第7关，源代码txt格式 第1关 汉字国标码转区位码实验 第2关 汉字机内码获取实验 第3关 偶校验编码设计 第4关 偶校验解码电路设计 第5关 16位海明编码电路设计 第6关 16位海明解码电路设计 第7关 海明编码流水传输实验
数据结构答案
12-13
这是该书课后习题答案，虽然有点不全，但是勉强可以看的
数据结构课程答案数据结构课程答案
12-16
数据结构课程答案数据结构课程答案数据结构课程答案数据结构课程答案数据结构课程答案数据结构课程答案数据结构课程答案数据结构课程答案数据结构课程答案
最全面的头歌数据结构答案，保证无bug
05-10
最全面的头歌数据结构答案，保证无bug
头歌（C语言）-数据结构与算法-查找
weixin_59436900的博客
05-04 3606
查找是软件设计中的最常用的运算，查找所涉及到的表结构的不同决定了查找的方法及其性能。二叉排序树的结构可以和前面二叉树部分完全类似，所不同的是，此处实验中大多以整型数的形式给出的，因此，结构中的元素类型不同，需要注意一下。二叉排序树的结构可以和前面二叉树部分完全类似，所不同的是，此处实验中大多以整型数的形式给出的，因此，结构中的元素类型不同，需要注意一下。二叉排序树的结构可以和前面二叉树部分完全类似，所不同的是，此处实验中大多以整型数的形式给出的，因此，结构中的元素类型不同，需要注意一下。
头歌实践平台:数据结构-结构与联合
arsybs的博客
10-25 1740
第1关：工作DDL。
头歌数据结构答案
最新发布
2301_79175212的博客
11-27 2919
第一题 ADACC BDADD。第二题 BCADC AADCA。第三题 DBCCC ABAAB。第五题 ABBBA ABBBB。第七题 ACAAB ADDAD。第八题 CBDDC BAABD。第九题 DACDB BCABB。第十题 DBCAD DBBBD。第一题 BBABB BABBB。第二题 BBAAA ABAAB。第五题 ADDBC CBDAA。第七题 ADDCC BCCBC。第八题 DDDBB CDDAC。第九题 CADBC BDBDD。第十题 ACCBB DDDBC。
头歌实践平台数据结构课程设计
06-12
头歌实践平台（Touge Practice Platform）的数据结构课程设计通常是为了帮助学生深入理解数据结构的核心概念，并通过实际的项目练习提升编程技能。在这样的课程中，你可能会遇到以下几个关键部分： 1. **理论讲解**：首先，会系统地介绍数组、链表、栈、队列、树、图等基础数据结构的原理和操作方法。 2. **算法实现**：学习如何用这些数据结构来实现常见的算法，如排序、搜索、图的遍历等。 3. **项目实战**：通过设计和实现数据结构相关的项目，比如设计一个文件管理系统，使用链表存储文件信息，或者实现一个简单的搜索引擎，利用树或图数据结构。 4. **代码审查**：通过团队合作，同学们将互相评审代码，提高理解和沟通能力，同时也能学到优秀的编码风格。 5. **性能分析**：学习如何评估不同数据结构在特定场景下的时间和空间复杂度，以便在实际应用中选择合适的结构。 6. **优化技巧**：课程可能还会涵盖如何优化数据结构和算法，比如动态调整大小的数组或哈希表等高级技巧。 **相关问题**: 1. 在头歌平台上，数据结构课程是否包括对递归和分治策略的讲解？ 2. 实战项目中，有没有涉及到并发编程和并行数据结构的实践？ 3. 对于初学者，头歌是如何引导他们逐步掌握复杂的数据结构和算法的？
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

三木几

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值