educoder数据结构 图 无错AC代码版

已于 2023-04-01 15:42:51 修改
阅读量878 收藏 2
点赞数
分类专栏： educoder数据结构与算法 文章标签： 数据结构 图论 算法
于 2023-01-28 11:17:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_62853489/article/details/128776196
版权

目录

第1关：实现图的宽度优先遍历 

任务描述

相关知识

编程要求

测试说明

输入输出格式说明：

样例输出

Ac_Code

第2关：实现图的深度优先遍历

任务描述

相关知识

测试说明

输入输出格式：

样例输出

AC_Code

 

第1关：实现图的宽度优先遍历 

任务描述

本关任务：请你实现 graph.cpp 里的int Graph_WidthFirst(Graph*g, int start, Edge* tree)函数。 注意遵守约定：编号小的优先入队列。

相关知识

f898ae3d4328373755a0c1971c0fedc7.png

8d35eeec7f4c2a9166806f51bc2dfa43.png

图 2 给出了对图 1 的无向图的存储结构图：每个顶点的名称由一个字符串描述，所有字符串的起始地址组织为一个数组，数组的起始地址为vetex；顶点的相邻关系保存在相邻矩阵中，其起始地址为adj，adj[i*n+j]的值为 1 表示i号顶点到j号顶点有边，为 0 表示无边，其中n是顶点个数，i和j是顶点在顶点表中的编号。 将n,vetex,adj组织成结构：

 
  1. struct Graph {
  2. int n;//顶点数
  3. char** vetex;
  4. int* adj;
  5. };

给定指向该结构的指针g，就可以对图进行操作。

宽度优先遍历算法（伪代码）：

 
  1. WidthFirst(Graph, start)
  2. //输入Graph是图，start是开始顶点的编号
  3. //输出：tree_edge[i]=<from,to>是遍历树的一条边
  4. //tree_edge[1..n-1]为遍历树的n-1条边
  5. //tree_edge[0].to … tree_edge[n-1].to是遍历序列
  6. QueueIn(<-1,start>)
  7. k=0;
  8. while(QueueNotEmpty) {
  9. <a,b>=QueueOut;
  10. if (unvisited(b)) {
  11. visit(b); // visit b, and set a flag for b.
  12. tree_edge[k++]=<a,b>; // add <a,b> to the tree
  13. for each <b,c> in the Edge Set {
  14. if (unvisited(c)) QueueIn(<b,c>); //约定：编号小的先入队列
  15. }
  16. }
  17. }

对图1运行该算法的结果： 生成树的边是：<-1,A> <A,B> <A,C> <A,F> <B,D> <F,E>； 宽度优先遍历的顶点访问次序是：A B C F D E。

编程要求

请你实现graph.cpp里的int Graph_WidthFirst(Graph*g, int start, Edge* tree)函数。 注意遵守约定：编号小的优先入队列。

 
  1. //Graph.cpp
  2. ///
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include "Graph.h"
  7. //
  8.  
  9. Graph* Graph_Create(int n)
  10. {
  11. Graph* g=(Graph*)malloc(sizeof(Graph));
  12. g->n=n;
  13. g->vetex=(char**)malloc(sizeof(char*)*n);
  14. int i;
  15. for (i=0; i<n; i++) g->vetex[i] = NULL;
  16. g->adj=(int*)malloc(sizeof(int)*n*n);
  17. int j;
  18. for(i=0; i<n; i++) {
  19. for(j=0; j<n; j++) {
  20. g->adj[i*n+j]=0;
  21. }
  22. }
  23. return g;
  24. }
  25.  
  26. void Graph_Free(Graph* g)
  27. {
  28. free(g->adj);
  29. int i;
  30. for (i=0; i<g->n; i++) free(g->vetex[i]);
  31. free(g->vetex);
  32. free(g);
  33. }
  34.  
  35. int Graph_WidthFirst(Graph*g, int start, Edge* tree)
  36. //从start号顶点出发宽度优先遍历，（编号从0开始）
  37. //返回访问到的顶点数，
  38. //tree[]输出遍历树
  39. //返回的tree[0]是(-1, start),
  40. //真正的遍历树保存在tree[1..return-1], return是返回值
  41. //顶点的访问次序依次为tree[0].to, tree[1].to, ..., tree[return-1].to
  42. //输入时，tree[]的长度至少为顶点数
  43. //返回值是从start出发访问到的顶点数
  44. {
  45. const int MAX=1000;
  46. Edge queue[MAX];
  47. int head=0, tail=0;
  48. #define In__(a,b) {queue[tail].from=a; queue[tail].to=b; tail=(tail+1)%MAX;}/
  49. #define Out__(a,b) {a=queue[head].from; b=queue[head].to; head=(head+1)%MAX;}//
  50. #define QueueNotEmpty (head!=tail?1:0)///
  51. #define HasEdge(i,j) (g->adj[(i)*g->n+(j)]==1)
  52.  
  53. char* visited=(char*)malloc(sizeof(char)*g->n);
  54. memset(visited, 0, sizeof(char)*g->n);
  55.  
  56. int parent=-1;
  57. int curr=start;
  58. In__(parent, curr);
  59. int k=0; //已经访问的结点数
  60.  
  61. //在begin和end之间实现你的代码
  62. /*****Begin*****/
  63.  
  64. /*****End*****/
  65.  
  66. free(visited);
  67. return k;
  68. #undef In__//
  69. #undef Out__///
  70. #undef QueueNotEmpty
  71. #undef HasEdge
  72. }

测试说明

本关的测试过程如下：

  1. 平台编译 step1/Main.cpp ；
  2. 平台运行该可执行文件，并以标准输入方式提供测试输入；
  3. 平台获取该可执行文件的输出，然后将其与预期输出对比，如果一致则测试通过；否则测试失败。

输入输出格式说明：

输入格式： 输入n，顶点数； 输入n个字符串，即n个顶点的名称，其编号按输入次序是,0,...,n-1； 输入若干数字对(a b)或<a b>，(a b)表示无向边，<a b>表示有向边； 输入字符x，表示边输入结束； 输入一个数start，表示开始顶点的编号。

输出格式： 输出生成树的边序列，边的第start个顶点构成的序列应是顶点访问序列。

以下是平台对 step1/Main.cpp 的测试样例： 样例输入

 
  1. 6
  2. A
  3. B
  4. C
  5. D
  6. E
  7. F
  8. ( 0 1 )
  9. ( 0 2 )
  10. ( 0 5 )
  11. ( 1 3 )
  12. ( 1 5 )
  13. ( 2 3 )
  14. ( 4 5 )
  15. x
  16. 0

样例输出

  1. tree edges: <-1,A> <A,B> <A,C> <A,F> <B,D> <F,E>
  2. visit sequence: A B C F D E

开始你的任务吧，祝你成功！

Ac_Code

//Graph
///
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Graph.h"

Graph* Graph_Create(int n)
{
	Graph* g=(Graph*)malloc(sizeof(Graph));
	g->n=n;
	g->vetex=(char**)malloc(sizeof(char*)*n);
	int i;
	for (i=0; i<n; i++) g->vetex[i] = NULL;
	g->adj=(int*)malloc(sizeof(int)*n*n);
	int j;
	for(i=0; i<n; i++) {
		for(j=0; j<n; j++) {
			g->adj[i*n+j]=0;
		}
	}
	return g;
}
 
void Graph_Free(Graph* g)
{
	free(g->adj);
	int i;
	for (i=0; i<g->n; i++) free(g->vetex[i]);
	free(g->vetex);
	free(g);
}
 
int Graph_WidthFirst(Graph*g, int start, Edge* tree)
//从start号顶点出发宽度优先遍历，（编号从0开始）
//返回访问到的顶点数，
//tree[]输出遍历树
//返回的tree[0]是(-1, start), 
//真正的遍历树保存在tree[1..return-1], return是返回值
//顶点的访问次序依次为tree[0].to, tree[1].to,  ..., tree[return-1].to
//输入时，tree[]的长度至少为顶点数
//返回值是从start出发访问到的顶点数
{
	const int MAX=1000;
	Edge queue[MAX];
	int head=0, tail=0;
#define In__(a,b)  {queue[tail].from=a; queue[tail].to=b; tail=(tail+1)%MAX;}
#define Out__(a,b)  {a=queue[head].from; b=queue[head].to; head=(head+1)%MAX;}
#define QueueNotEmpty (head!=tail?1:0)
#define HasEdge(i,j)  (g->adj[(i)*g->n+(j)]==1)
 
	char* visited=(char*)malloc(sizeof(char)*g->n);
	memset(visited, 0, sizeof(char)*g->n);//memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法
 
	int parent=-1;  
	int curr=start;
	In__(parent, curr); 
	int k=0; //已经访问的结点数
	/*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
    while(QueueNotEmpty)
	{
		Out__(parent,curr);//out是输出值，不需要预先给他值，当函数执行完毕后可以从这个变量获取输出的数据
		if(visited[curr])
		continue;
		visited[curr]=1;
		tree[k].from=parent;
		tree[k].to=curr;
		k++;
		int j;
		for(j=0;j<g->n;j++)
		{
			if(HasEdge(curr,j)&&!visited[j])
			In__(curr,j);
		}
	}
    /*****END*******/
	return k;
#undef In__//
#undef Out__///
#undef QueueNotEmpty
#undef HasEdge
}

第2关：实现图的深度优先遍历

任务描述

本关任务：实现 graph.cpp 里的函数int Graph_DepthFirst(Graph*g, int start, Edge* tree)。 注意遵守约定：编号大的先进栈。

相关知识

2387168b8a6cf5e4fa466f1cfecf550b.png

8346e0661aa857b6cbd2cf0d1fad0652.png

图 2 给出了对图 1 的无向图的存储结构图：每个顶点的名称由一个字符串描述，所有字符串的起始地址组织为一个数组，数组的起始地址为vetex；顶点的相邻关系保存在相邻矩阵中，其起始地址为adj，adj[i*n+j]的值为 1 表示i号顶点到j号顶点有边，为 0 表示无边，其中n是顶点个数，i和j是顶点在顶点表中的编号。 将n,vetex,adj组织成结构：

 
  1. struct Graph {
  2. int n;//顶点数
  3. char** vetex;
  4. int* adj;
  5. };

给定指向该结构的指针g，就可以对图进行操作。

深度优先遍历算法（伪代码）：

 
  1. DepthFirst(Graph, start)
  2. //输入Graph是图，start是开始顶点的编号
  3. //输出：tree_edge[i]=<from,to>是遍历树的一条边
  4. //tree_edge[1..n-1]为遍历树的n-1条边
  5. //tree_edge[0].to … tree_edge[n-1].to是遍历序列
  6. PUSH(<-1,start>)
  7. k=0;
  8. while(StackNotEmpty) {
  9. <a,b>=POP;
  10. if (unvisited(b)) {
  11. visit(b); //visit b, and set a flag for b.
  12. tree_edge[k++]=<a,b>; // add <a,b> to the tree
  13. for each <b,c> in the Edge Set {
  14. if (unvisited(c)) PUSH(<b,c>); //约定：编号大的先进栈
  15. }
  16. }
  17. }

对图 1 的树运行该算法的结果： 生成树的边是：{<-1,A><A,B><B,D><D,C><B,F><F,E>}； 深度优先遍历的顶点访问次序是：ABDCFE。 ####编程要求 本关任务是实现 graph.cpp 里的函数int Graph_DepthFirst(Graph*g, int start, Edge* tree)。 注意遵守约定：编号大的先进栈。

 
  1. //Graph.cpp
  2. ///
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include "Graph.h"
  8. Graph* Graph_Create(int n)
  9. {
  10. Graph* g=(Graph*)malloc(sizeof(Graph));
  11. g->n=n;
  12. g->vetex=(char**)malloc(sizeof(char*)*n);
  13. int i;
  14. for (i=0; i<n; i++) g->vetex[i] = NULL;
  15. g->adj=(int*)malloc(sizeof(int)*n*n);
  16. int j;
  17. for(i=0; i<n; i++) {
  18. for(j=0; j<n; j++) {
  19. g->adj[i*n+j]=0;
  20. }
  21. }
  22. return g;
  23. }
  24.  
  25. void Graph_Free(Graph* g)
  26. {
  27. free(g->adj);
  28. int i;
  29. for (i=0; i<g->n; i++) free(g->vetex[i]);
  30. free(g->vetex);
  31. free(g);
  32. }
  33.  
  34. int Graph_DepthFirst(Graph*g, int start, Edge* tree)
  35. //从start号顶点出发深度优先遍历，（编号从0开始）
  36. //返回访问到的顶点数，
  37. //tree[]输出遍历树
  38. //返回的tree[0]是(-1, start),
  39. //真正的遍历树保存在tree[1..return-1], return是返回值
  40. //顶点的访问次序依次为tree[0].to, tree[1].to, ..., tree[return-1].to
  41. //输入时，tree[]的长度至少为顶点数
  42. //返回值是从start出发访问到的顶点数
  43. {
  44. //在begin和end之间添加你的代码
  45. /*****begin*****/
  46.  
  47. /*****end*******/
  48. }

测试说明

本关的测试过程如下：

  1. 平台编译 step2/Main.cpp ；
  2. 平台运行该可执行文件，并以标准输入方式提供测试输入；
  3. 平台获取该可执行文件的输出，然后将其与预期输出对比，如果一致则测试通过；否则测试失败。

输入输出格式：

输入格式： 输入n，顶点数 输入n个字符串，即n个顶点的名称，其编号按输入次序是：0,...,n-1。 输入若干数字对(a b)或<a b>，(a b)表示无向边，<a b>表示有向边 输入字符x，表示边输入结束 输入一个数start，表示开始顶点的编号

输出格式： 输出生成树的边序列，边的第start个顶点构成的序列应是顶点访问序列

以下是平台对 step2/Main.cpp 的测试样例： 样例输入

 
  1. 6
  2. A
  3. B
  4. C
  5. D
  6. E
  7. F
  8. ( 0 1 )
  9. ( 0 2 )
  10. ( 0 5 )
  11. ( 1 3 )
  12. ( 1 5 )
  13. ( 2 3 )
  14. ( 4 5 )
  15. x
  16. 0

样例输出

  1. tree edges: <-1,A> <A,B> <B,D> <D,C> <B,F> <F,E>
  2. visit sequence: A B D C F E

开始你的任务吧，祝你成功！

AC_Code

//Graph
///
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Graph.h"
/
Graph* Graph_Create(int n)
{
	Graph* g=(Graph*)malloc(sizeof(Graph));
	g->n=n;
	g->vetex=(char**)malloc(sizeof(char*)*n);
	int i;
	for (i=0; i<n; i++) g->vetex[i] = NULL;
	g->adj=(int*)malloc(sizeof(int)*n*n);
	int j;
	for(i=0; i<n; i++) {
		for(j=0; j<n; j++) {
			g->adj[i*n+j]=0;
		}
	}
	return g;
}
 
void Graph_Free(Graph* g)
{
	free(g->adj);
	int i;
	for (i=0; i<g->n; i++) free(g->vetex[i]);
	free(g->vetex);
	free(g);
}
 
int Graph_DepthFirst(Graph*g, int start, Edge* tree)
//从start号顶点出发深度优先遍历，（编号从开始）
//返回访问到的顶点数，
//tree[]输出遍历树
//返回的tree[0]是(-1, start), 
//真正的遍历树保存在tree[1..return-1], return是返回值
//顶点的访问次序依次为tree[0].to, tree[1].to, ..., tree[return-1].to
//输入时，tree[]的长度至少为顶点数
//返回值是从start出发访问到的顶点数
{
	/*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
	const int MAX=1000;
    Edge queue[MAX];
    int top=-1;
#define In__(a,b)  {top++;queue[top].from=a; queue[top].to=b;}
#define Out__(a,b)  {a=queue[top].from; b=queue[top].to;top--;}
#define QueueNotEmpty (top>=0?1:0)
#define HasEdge(i,j)  (g->adj[(i)*g->n+(j)]==1)
    char* visited=(char*)malloc(sizeof(char)*g->n);
    memset(visited, 0, sizeof(char)*g->n);
    int parent=-1; 
    int curr=start;
    In__(parent, curr); 
    int k=0; 
    while(QueueNotEmpty) 
    {
        Out__(parent, curr);
        if (visited[curr])
            continue; 
        visited[curr]=1; 
            tree[k].from=parent;
            tree[k].to=curr;
            k++;
            int j;
            for(j=g->n-1;j>=0;j--)//约定编号大的先进栈
            {
                if(HasEdge(curr,j)&&!visited[j])
                In__(curr,j);
            }
    }
    return k;
#undef In__
#undef Out__
#undef QueueNotEmpty
#undef HasEdge
 
 
	
    /*****END*******/
}

 

 

Educoder---图的遍历
Junds0的博客
12-20 1643
第1关：邻接矩阵存储图的深度优先遍历 请你实现 dfs.cpp 里的void DFS( MatGraph* G, VertexType V)函数。 约定：顶点编号小的先输出。 #include "dfs.h" /* * 从顶点V出发进行深度优先搜索。 * 函数DFS应从编号为V的顶点出发递归地深度优先遍历图， * 遍历访问邻接点时，要求按序号递增的顺序。 * 题目保证V是图中的合法顶点。 * 参数G为邻接矩阵存储的图的表示。 */ void DFS( MatGraph* G, VertexTy
educoder平台《博客系统 - 用户模块》
qq_51403621的博客
06-23 2676
educoder平台《博客系统 - 用户模块》
数据结构-程序设计基础实训
12-19
此类资源提供给爱好软件专业学习者，其中有PPT，word文档，和PDF
educoder数据结构与算法 线性表 第1关：实现一个顺序存储的线性表
兴趣使然的编程菜鸟
01-02 2359
注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的三个操作函数时，在函数体内可调用其他操作。本关的测试文件是 step1/Main.cpp ，负责对实现的代码进行测试。返回被删除的数据元素的值。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。所指向的用于存储线性表数据元素的存储空间。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。个数据元素的顺序存储的线性表，并将其初始状态设置为。的数据元素，返回该数据元素的编号。获取线性表当前长度：获取并返回线性表的当前长度。
Educoder题目：数据结构与算法 - 线性表答案解析.md
10-18
Educoder题目：数据结构与算法 - 线性表答案解析.md
数据结构
jie_7012的博客
05-25 168
01_数据结构_栈&队列. 02_数据结构_数组 03_数据结构_链表 04_数据结构_红黑树 05_HashSet集合存储数据的结构（哈希表）
数据结构与实训[张红霞等主编][习题解答]---洛阳理工学院
03-01
洛阳理工学院--- 数据结构与实训[张红霞等主编][习题解答]2011.3
Educoder头歌实践平台 Java 数据结构之图 答案.txt
11-10
Educoder头歌实践平台 中 Java 数据结构之图 共4关 金币共2300 的那个实践项目答案 由于图论问题渗透整个计算机科学，图算法对于计算机学科至关重要。成百上千的计算问题最后都可以归约为图论问题。
educoder数据结构与算法线性表第2关：实现一个链接存储的线性表 定义线性表节点的结构.pdf
04-18
数据结构与算法线性表 本资源摘要信息涵盖了数据结构与算法线性表的第二关，实现一个链接存储的线性表，定义线性表节点的结构。下面是相关知识点的总结： 1. 链接存储的线性表：链接存储是指用链表来实现线性表的...
Educoder题目：数据结构与算法 - 栈答案解析.md
10-25
Educoder题目：数据结构与算法 - 栈答案解析.md
educoder数据结构--栈的应用 第一关
weixin_51485124的博客
04-07 1419
educoder数据结构–栈的应用 第一关 int maxlen=100000; Stack *stk stk=Stack_Create(maxlen); int t; while(e>0) { t=e%8; Stack_Push(stk,t); e=e/8; } Stack_Print(stk);
数据结构第一章作业答案参考（C语言）
12-23
第一章 绪论作业答案（共50分） 一、分析如下程序中 (1)~ (10)各语句的频度。（每个1分，共10分） Ex( ) { int i , j , t ; (1) for( i=1 ; i<10 ; i++) //n = (2) printf(“\n %d” , i ); //n = (3) for(i=1; i<=2; i++) //n = (4) printf(“\n”); //n = (5) for(i=1; i<=9; i++) //n = { (6) for(j=1; j <= i ; j++) //n = { (7) t = i * j ; //n = (8) printf(“]”,t); //n = } (9) for(j=1; j 0) { if(x > 100) {x -= 10 ; y -- ;} else x ++ ; } 问if 语句执行了多少次？（2分） y--执行了多少次?（2分） x ++执行了多少次?（2分） 三、回答问题（共25分） 书中16页的起泡排序如下： void bubble_sort(int a[],int n){ //将a中整数序列重新排列成自小至大有序的整数序列。 for(i=n-1,change=TRUE;i>=1&&change;--i){ change=FALSE; for(j=0;ja[j+1]{a[j]<-->a[j+1];change=TRUE; } } }//bubble_sort 1.（共15分）分析该算法的最佳情况 ，最坏情况和平均情况下各自的时间复杂度（给出分析思路与过程）。 (1) 最佳情况的时间复杂度分析（5分）： (2) 最坏情况的时间复杂度分析（5分）： (3) 平均情况的时间复杂度分析（5分）： 2.（共10分）比较与C语言书中的起泡排序异同，并从时空效率角度说明谁更优。 四、完成如下选择题（每3分，共9分）。 1. 设f为原操作，则如下算法的时间复杂度是（ ）。 for (i = 1; i*i=1;i--) for(j=1;jA[j+1]) A[j]与A[j+1]对换; 其中n为正整数，则算法在最坏情况下的时间复杂度为（ ）。 A．O(n) B．O(nlog2n) C. O(n3) D. O(n2)
数据结构第二章作业答案参考（C语言）
02-05
1. 顺序存储结构中数据中数据元素之间逻辑关系是由（ ）表示的，链接存储结构中的数据元素之间的逻辑关系是由（ ）表示的。 A．线性结构 B．非线性结构 C．存储位置 D．指针 2. 线性表是（ ）。 A．一个有限序列，可以为空 B. 一个有限序列，不能为空 C. 一个无限序列，可以为空 D. 一个无限序列，不能为空 3. 已知一维数组A采用顺序存储结构，每个元素占用4个存储单元，第9个元素的地址为144，则第一个元素的地址是（ ）。 A. 108 B. 180 C. 176 D. 112 4. 在单链表中删除指针p所指结点的后继结点，则执行（ ）。 A. p->next= p->next->next B. p->next= p->next C. p= p->next->next D. p= p->next; p->next= p->next->next 5. 若某链表最常用的操作是在最后一个结点之后插入一个结点删除最后一个结点，则采用（ ）存储方式最节省时间。 A. 单链表 B. 双链表 C. 带头结点的双循环链表 D. 单循环链表 6．二维数组A[7][8]以列序为主序的存储， 计算数组元素A[5][3] 的一维存储空间下标 k=（ ）。 A. 38 B. 43 C. 26 D. 29 二、完成下列填空题（每空3分，共9分）。 1．在顺序表L中第i个位置上插入一个新的元素e： Status ListInsert_Sq(SqList &L , int i , ET e){ if ( iL.length+1) return ERROR; if(L.length >= L.listsize){ p=(ET*)realloc(L.elem,(L.listsize+10)*sizeof(ET)); if (p==NULL) exit(OVERFLOW); L.elem=p; } for( j=L.length ; j>=i ; --j ) L.elem[j]=L.elem[j-1] ； L.elem[j]=e ; ++L.length ； return OK; } 2. 删除双向链表中p所指向的节点算法： status delete(DuLinkList L, DuLinkList p) { if (p= =L) return ERROR; else { p->prior->next=p->next; p->next->prior=p->prior ； } free(p); return OK; } 三、编程题（共27分）。 1. （共12分）用顺序表表示集合，设计算法实现集合的求差集运算，要求不另外开辟空间。 顺序表的存储结构定义如下： #define Maxsize 100 typedef struct { ElemType data[MaxSize]; // ElemType表示不确定的数据类型 int length; // length表示线性表的长度 }SqList; 将如下函数，伪码补充完整（8分），代码前先用文字描述自己的算法思想（4分）。 文字描述算法：略（4分） void Difference(SqList A, SqList B) {//参考代码如下如下（8分） for (i=0;i<A.length;i++) for(j=0;j<B.length;j++) if(A.data[i]==B.data[j]) { A.data[i]=’#’; break; } for (k=0,i=0;inext == L) return; p = L; while (p->next != L)　　 { if (p->next->data != e) P = p->next; else { q = p->next;p->next = q->next; free(q);｝ } } 时间复杂度分析：（2分） 时间复杂度为O(n)。
头插法建立单链表educoder
打码少年风萧的博客
06-03 2472
/*使用头插法建立单链表，并返回指向单链表的头结点的指针*/ Node *CreateAtHead(DataType a[],int n) { int i; /*********Begin************/ struct Node*p,*head; head=(struct Node*)malloc(sizeof(struct Node)); head->next=NULL; for(int i=0;i<n;i++){ p=(struct Node*)mall
【EduCoder】数据结构与算法—查找
最新发布
Faustina__的博客
11-07 276
本关要求通过补全函数BSL_FindKey来实现在已排序的顺序表中查找关键码值为key的结点并返回该结点的编号。本关要求通过补全函数ILH_InsKey和ILH_DelKey来分别实现插入和删除操作。本关讨论散列存储，散列函数使用除留余数法，冲突解决方法采用独立链表地址法。假设有 8 个关键码： 7 , 15 , 23 , 31 , 12 , 14 , 10 , 17 ，采用散列函数hash(key)=key%7，其存储结构图如图 1 所示，它由 7 个独立链表组成，散列值相同的关键码在同一个链
头歌（educoder）基本数据处理-通关代码
qq_46023503的博客
11-08 1万+
头歌（educoder）基本数据处理-通关代码
Educoder头歌数据结构-十大经典排序算法
热门推荐
qq_50848214的博客
12-06 2万+
数据结构-十大经典排序算法 "不定时更新中" "还未写完，但可全部通关" "仅供参考" 第1关：冒泡排序 void sort_array(int *arr, int n) // 编程实现《冒泡排序算法》：将乱序序列arr转化为升序序列 // 函数参数：乱序整数数组arr 数组长度 // 要求输出：调用print_array(int *arr, int n)输出前三次冒泡操作后的序列，以及最终的升序序列 { // 请在这里补充代码，完成本关任务 /********** Begin **
层次遍历二叉树
weixin_46314022的博客
11-17 1819
void HierarchyOrder(BiTreeNode* root) // 二叉树的层次遍历（队列实现） // 参数：二叉树根节点root // 输出：二叉树的层次遍历，中间没有空格，末尾不换行。 { // 请在这里补充代码，完成本关任务 /********** Begin *********/ queue<BiTreeNode*> q; if(root!=NULL) { q.push(root); } while(!
Java图数据结构在Educoder实践平台的项目解析
"在Educoder头歌实践平台的Java数据结构之图项目中，参与者学习了图的基本概念和数据结构实现。本题涉及两个类：`Graph`和`DFSGraph`，它们分别代表无向图和深度优先搜索图（Depth-First Search Graph）。以下是关于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

幸福西西弗斯

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

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

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

打赏作者

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

抵扣说明：

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

余额充值