数据结构单链表输入输出(c++)
严蔚敏版数据结构习题及参考答案
习题1一、单项选择题A1.数据结构是指（）。
A.数据元素的组织形式B.数据类型C.数据存储结构D.数据定义C2.数据在计算机存储器内表示时，物理地址与逻辑地址不相同的，称之为（）。
A.存储结构B.逻辑结构C.链式存储结构D.顺序存储结构D3.树形结构是数据元素之间存在一种（）。
A.一对一关系B.多对多关系C.多对一关系D.一对多关系B4.设语句x++的时间是单位时间，则以下语句的时间复杂度为（）。
for(i=1; i<=n; i++)for(j=i; j<=n; j++)x++;A.O(1)B.O(2n)C.O(n)D.O(3n)CA5.算法分析的目的是（1），算法分析的两个主要方面是（2）。
（1） A.找出数据结构的合理性 B.研究算法中的输入和输出关系C.分析算法的效率以求改进D.分析算法的易懂性和文档性（2） A.空间复杂度和时间复杂度 B.正确性和简明性C.可读性和文档性D.数据复杂性和程序复杂性6.计算机算法指的是（1），它具备输入，输出和（2）等五个特性。
（1） A.计算方法 B.排序方法C.解决问题的有限运算序列D.调度方法（2） A.可行性，可移植性和可扩充性 B.可行性，确定性和有穷性C.确定性，有穷性和稳定性D.易读性，稳定性和安全性7.数据在计算机内有链式和顺序两种存储方式，在存储空间使用的灵活性上，链式存储比顺序存储要（）。
A.低B.高C.相同D.不好说8.数据结构作为一门独立的课程出现是在（）年。
A.1946B.1953C.1964D.19689.数据结构只是研究数据的逻辑结构和物理结构，这种观点（）。
A.正确B.错误C.前半句对，后半句错D.前半句错，后半句对10.计算机内部数据处理的基本单位是（）。
A.数据B.数据元素C.数据项D.数据库二、填空题1.数据结构按逻辑结构可分为两大类，分别是______________和_________________。
《数据结构》课后参考答案
单元练习1一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳）（√）（1）数据的逻辑结构与数据元素本身的内容和形式无关。
（√）（2）一个数据结构是由一个逻辑结构和这个逻辑结构上的一个基本运算集构成的整体。
（ㄨ）（3）数据元素是数据的最小单位。
（ㄨ）（4）数据的逻辑结构和数据的存储结构是相同的。
（ㄨ）（5）程序和算法原则上没有区别，所以在讨论数据结构时可以通用。
（√）（6）从逻辑关系上讲，数据结构主要分为线性结构和非线性结构两类。
（√）（7）数据的存储结构是数据的逻辑结构的存储映像。
（√）（8）数据的物理结构是指数据在计算机内实际的存储形式。
（ㄨ）（9）数据的逻辑结构是依赖于计算机的。
（√）（10）算法是对解题方法和步骤的描述。
二．填空题（1）数据有逻辑结构和存储结构两种结构。
（2）数据逻辑结构除了集合以外，还包括：线性结构、树形结构和图形结构。
（3）数据结构按逻辑结构可分为两大类，它们是线性结构和非线性结构。
（4）树形结构和图形结构合称为非线性结构。
（5）在树形结构中，除了树根结点以外，其余每个结点只有 1 个前趋结点。
（6）在图形结构中，每个结点的前趋结点数和后续结点数可以任意多个。
（7）数据的存储结构又叫物理结构。
（8）数据的存储结构形式包括：顺序存储、链式存储、索引存储和散列存储。
（9）线性结构中的元素之间存在一对一的关系。
（10）树形结构结构中的元素之间存在一对多的关系，（11）图形结构的元素之间存在多对多的关系。
（12）数据结构主要研究数据的逻辑结构、存储结构和算法（或运算）三个方面的内容。
（13）数据结构被定义为(D，R)，其中D是数据的有限集合，R是D上的关系的有限集合。
（14）算法是一个有穷指令的集合。
（15）算法效率的度量可以分为事先估算法和事后统计法。
（16）一个算法的时间复杂性是算法输入规模的函数。
（17）算法的空间复杂度是指该算法所耗费的存储空间，它是该算法求解问题规模n 的函数。
数据结构-单链表实验报告
单链表实验报告一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉链表的操作为侧重点。
二、实验内容[问题描述]实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求]（1）依次从键盘读入数据，建立带头结点的单链表；（2）输出单链表中的数据元素（3）求单链表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。
三、算法设计（1）建立带表头结点的单链表；首先输入结束标志，然后建立循环逐个输入数据，直到输入结束标志。
（2）输出单链表中所有结点的数据域值；首先获得表头结点地址，然后建立循环逐个输出数据，直到地址为空。
（3）输入x,y在第一个数据域值为x的结点之后插入结点y，若无结点x，则在表尾插入结点y;建立两个结构体指针，一个指向当前结点，另一个指向当前结点的上一结点，建立循环扫描链表。
当当前结点指针域不为空且数据域等于x的时候，申请结点并给此结点数据域赋值为y，然后插入当前结点后面，退出函数；当当前结点指针域为空的时候，申请结点并给此结点数据域赋值为y，插入当前结点后面，退出函数。
（4）输入k，删除单链表中所有的结点k，并输出被删除结点的个数。
建立三个结构体指针，一个指向当前结点，另一个指向当前结点的上一结点，最后一个备用；建立整形变量l=0；建立循环扫描链表。
当当前结点指针域为空的时候，如果当前结点数据域等于k，删除此结点，l++，跳出循环，结束操作；如果当前结点数据域不等于k，跳出循环，结束操作。
当当前结点指针域不为空的时候，如果当前结点数据域等于k，删除此结点，l++，继续循环操作；如果当前结点数据域不等于k，指针向后继续扫描。
循环结束后函数返回变量l的值，l便是删除的结点的个数。
四、实验结果1、新建一个链表：2、输出链表的数据：（4）插入数据：在数据为3后面插入一个数据100：（5）删除数据：删除刚刚插入的数据100：五、总结实验之前由于准备不够充分，所以堂上实验时只完成了建立单链表和数据的输出，而后面两个实验要求也是用来很多时间长完成的。
大学课程《数据结构》课后习题答案
大学课程《数据结构》课后习题答案第 1 章绪论课后习题讲解1.填空⑴（）是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。
【解答】数据元素⑵（）是数据的最小单位，（）是讨论数据结构时涉及的最小数据单位。
【解答】数据项，数据元素【分析】数据结构指的是数据元素以及数据元素之间的关系。
⑶ 从逻辑关系上讲，数据结构主要分为（）、（）、（）和（）。
【解答】集合，线性结构，树结构，图结构⑷ 数据的存储结构主要有（）和（）两种基本方法，不论哪种存储结构，都要存储两方面的内容：（）和（）。
【解答】顺序存储结构，链接存储结构，数据元素，数据元素之间的关系⑸ 算法具有五个特性，分别是（）、（）、（）、（）、（）。
【解答】有零个或多个输入，有一个或多个输出，有穷性，确定性，可行性⑹ 算法的描述方法通常有（）、（）、（）和（）四种，其中，（）被称为算法语言。
【解答】自然语言，程序设计语言，流程图，伪代码，伪代码⑺在一般情况下，一个算法的时间复杂度是（）的函数。
【解答】问题规模⑻ 设待处理问题的规模为n，若一个算法的时间复杂度为一个常数，则表示成数量级的形式为（），若为n*log25n，则表示成数量级的形式为（）。
【解答】Ο(1)，Ο(nlog2n)【分析】用大O 记号表示算法的时间复杂度，需要将低次幂去掉，将最高次幂的系数去掉。
2.选择题⑴ 顺序存储结构中数据元素之间的逻辑关系是由（）表示的，链接存储结构中的数据元素之间的逻辑关系是由（）表示的。
A 线性结构B 非线性结构C 存储位置D 指针【解答】C，D【分析】顺序存储结构就是用一维数组存储数据结构中的数据元素，其逻辑关系由存储位置（即元素在数组中的下标）表示；链接存储结构中一个数据元素对应链表中的一个结点，元素之间的逻辑关系由结点中的指针表示。
⑵ 假设有如下遗产继承规则：丈夫和妻子可以相互继承遗产；子女可以继承父亲或母亲的遗产；子女间不能相互继承。
则表示该遗产继承关系的最合适的数据结构应该是（）。
《数据结构C语言版》----第02章
同理可证:顺序表删除一元素的时间效率为: 同理可证:顺序表删除一元素的时间效率为: T（n)=(n-1)/2 ≈O(n) O(n) （
插入效 E = ∑ is 率： i=0
n
1 n n pi ( n − i ) = ∑ (n − i) = 2 n + 1 i=0
n −1 删除效 1 n −1 n −1 Edl = ∑ qi (n − i ) = ∑ (n − i ) = 率： n i =0 2 i =0
2.2 线性表的顺序表示和实现
顺序存储结构的线性表称作顺序表 1.顺序表的存储结构 顺序表的存储结构
实现顺序存储结构的方法是使用数组。数组把线性表 实现顺序存储结构的方法是使用数组。 使用数组 的数据元素存储在一块连续地址空间的内存单元中， 连续地址空间的内存单元中 的数据元素存储在一块连续地址空间的内存单元中，这样 线性表中逻辑上相邻的数据元素在物理存储地址上也相邻。 线性表中逻辑上相邻的数据元素在物理存储地址上也相邻。 数据元素间的逻辑上的前驱、 数据元素间的逻辑上的前驱、后继逻辑关系就表现在数据 元素的存储单元的物理前后位置上。 元素的存储单元的物理前后位置上。 顺序表的存储结构如图所示
2.线性表抽象数据类型 2.线性表抽象数据类型
数据集合:｛ 的数据类型为DataType 数据集合 ｛ a0, a1, … , an-1 ｝, ai的数据类型为 (1) ListInitiate(L) 初始化线性表 (2) ListLength(L) 求当前数据元素个数 操作集合: 操作集合 (3) ListInsert(L,i,x) 插入数据元素 (4) ListDelete(L,i,x) 删除数据元素 (5) ListGet(L,i,x) 取数据元素
printf("参数 不合法 \n"); 参数i不合法 参数 不合法! return 0;
数据结构C语言版 线性表的单链表存储结构表示和实现
#include 〈stdio.h>＃include <malloc。
h>＃include 〈stdlib.h>/＊数据结构C语言版线性表的单链表存储结构表示和实现P28—31编译环境：Dev-C++ 4。
9。
9。
2日期：2011年2月10日＊/typedef int ElemType;// 线性表的单链表存储结构typedef struct LNode{ElemType data; //数据域struct LNode *next；//指针域}LNode, ＊LinkList；// typedef struct LNode *LinkList；// 另一种定义LinkList的方法// 构造一个空的线性表Lint InitList（LinkList ＊L){/＊产生头结点L，并使L指向此头结点,头节点的数据域为空，不放数据的。
void ＊malloc(size_t)这里对返回值进行强制类型转换了,返回值是指向空类型的指针类型.＊/（＊L）= (LinkList）malloc（sizeof（struct LNode) ）;if( ！(＊L）)exit（0）；// 存储分配失败(＊L)-〉next = NULL；// 指针域为空return 1；}// 销毁线性表L,将包括头结点在内的所有元素释放其存储空间。
int DestroyList（LinkList ＊L）｛LinkList q;// 由于单链表的每一个元素是单独分配的，所以要一个一个的进行释放while（＊L )｛q = (*L)—〉next;free（＊L ）；//释放*L = q;}return 1；｝/*将L重置为空表,即将链表中除头结点外的所有元素释放其存储空间，但是将头结点指针域置空，这和销毁有区别哦。
不改变L，所以不需要用指针。
*/int ClearList( LinkList L )｛LinkList p，q；p = L—〉next；// p指向第一个结点while( p ) // 没到表尾则继续循环｛q = p—>next;free( p )；//释放空间p = q；}L—>next = NULL; // 头结点指针域为空,链表成了一个空表return 1;}// 若L为空表（根据头结点L—〉next来判断，为空则是空表)，则返回1，// 否则返回0.int ListEmpty(LinkList L）{if（L—>next ) // 非空return 0;elsereturn 1；｝// 返回L中数据元素个数。
数据结构实验题目
实验题目一一、单链表基本运算【问题描述】设计并实现线性表的单链表存储和运算。
【基本要求】实现单链表的插入、删除和遍历运算，每种操作用一个函数实现。
插入操作：将一个新元素插入表中指定序号的位置。
删除操作：将指定序号的元素从表中删除。
遍历操作：从表头按次序输入所有元素的值，若是空表，则输出信息“empty list!”。
【实现提示】程序运行时，首先在main函数中创建空的、带头结点的单链表。
然后多次调用实现插入操作的函数（每次都将元素在序号1位置上插入），将元素依次插入表中，最后调用实现遍历操作的函数输出所有元素。
之后再多次调用实现删除操作的函数将表还原为空表（每次都删除第1个元素，每删除一个元素后，将表中剩余元素都输出一次）。
【测试数据】输入数据：1 2 3 4 5 0（为0时结束，0不存入链表）第一次输出：5 4 3 2 1第二次输出：4 3 2 1第三次输出：3 2 1第四次输出：2 1第五次输出：1第六次输出：empty list!二、约瑟夫环问题【问题描述】编号为1,2,...,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
现在给定一个随机数m>0，从编号为1的人开始，按顺时针方向1开始顺序报数，报到m时停止。
报m的人出圈，同时留下他的密码作为新的m值，从他在顺时针方向上的下一个人开始，重新从1开始报数，如此下去，直至所有的人全部出列为止。
【基本要求】利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。
【测试数据】M的初始值为20；n等于7，7个人的密码依次为：3，1，7，2，4，8，4。
输出为：6，1，4，7，2，3，5【实现提示】程序运行时，首先要求用户指定初始报数上限值，然后读取各人的密码。
可设n≤30。
此题所用的循环链表中不需要“头结点”，请注意空表和非空表的界限。
【选作内容】用顺序存储结构实现该题目。
三、一元多项式相加、减运算器【问题描述】设计一个一元稀疏多项式简单计算器。
《数据结构(C语言版)》习题指导与解答
附录2习题指导与解答习题一解答1．数据是人们利用文字符号、数字符号以及其他规定的符号对客观现实世界的事物及其活动所做的抽象描述。
它是计算机程序加工的‚原料‛。
表示一个事物的一组数据称为一个数据元素，它是数据的基本单位，在计算机中通常作为一个整体来进行考虑和处理。
一般情况下，一个数据元素由若干个数据项构成。
数据对象是性质相同的数据元素的集合，是数据的一个子集。
例如：描述N个学生的有关信息的N个数据元素构成了一个数据对象。
2．数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
具体来说，数据结构包含三个方面的内容，既数据的逻辑结构、数据的存储结构（或称物理结构）和对数据所施加的一组操作。
3．数据的逻辑结构是数据元素之间本身所固有的独立于计算机的一种结构，这种结构可以用数据元素之间固有的关系的集合来描述。
数据的存储结构（或物理结构）是逻辑结构在计算机存储器中的具体存放方式的体现，是逻辑结构在计算机存储器中的映像。
4．根据数据元素之间存在的关系的不同特性，数据结构通常可以分为如下4类基本结构：（1）线性结构。
元素之间存在一个一对一的线线关系，即除了第一个元素和最后一个元素外，每个元素都有一个直接前驱和一个直接后继，第一个元素有一个后继，最后一个元素有一个直接前驱。
例如学生档案管理系统中学生记录之间的关系即为线性关系；（2）树形结构。
数据元素之间存在着一个对多个的关系。
例如，老师T指导3个硕士研究生G1，G2，G3；每个研究生Gi（i=1,2,3）又分别指导3个本科生Si1，Si2，Si3；则数据元素之间的呈现树形结构。
(3)图形结构或网状结构。
数据元素之间存在多个对多个的关系。
如城市交通网络中城市之间的交通道路的连接关系就是一个网状结构。
（4）集合结构。
数据元素之间无任何关系。
5．抽象数据类型通常是指由用户定义，用以表示实际应用问题的数据模型，一般由基本数据类型或其他已定义的抽象数据类型以及定义在该模型上的一组操作组成。
数据结构单链表实验报告
{
printf("删除结点的位置i不合理!");
return ERROR;
}
r=pre->next;
pre->next=pre->next->next; /*修改指针，删除结点r*/
返回值说明：返回ERROR插入失败，返回OK插入成功;
（5）按位置查找链表元素：int GetList(LinkList L,int i,int *e);
4.详细设计
void init_linklist(LinkList *l)/*对单链表进行初始化*/{
*l=(LinkList)malloc(sizeof(Node)); /*申请结点空间*/
(*l)->next=NULL; /*置为空表*/
}
void CreateFromHead(LinkList L)
{
Node *s;
charc;
intflag=1;
while(flag) /* flag初值为1，当输入"$"时，置flag为0，建表结束*/
{
c=getchar();
if(c!='$')
*e = r->data;
free(r); /*释放被删除的结点所占的内存空间*/
printf("成功删除结点!");
return OK;
}
intListLength(LinkList L)
/*求带头结点的单链表L的长度*/
数据结构(C语言版)(第2版)课后习题答案
数据结构（C语言版）（第2版）课后习题答案李冬梅2015.3第1 绪论 (1)第2线性表 (5)第3栈和队列 14 第4串、数组和广义表 27 第5树和二叉树 34 第 6 图 (43)第7 查找 (55)第8 排序 (66)第 1 章绪论1．简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。
答案：数据：是客观事物的符号表示，指所有能输入到计算机中并被计算机程序处理的符号的总称。
如数学计算中用到的整数和实数，文本编辑所用到的字符串，多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。
数据元素：是数据的基本单位，在计算机中通常作为一个整体进行考虑和处理。
在有些情况下，数据元素也称为元素、结点、记录等。
数据元素用于完整地描述一个对象，如一个学生记录，树中棋盘的一个格局（状态）、图中的一个顶点等。
数据项：是组成数据元素的、有独立含义的、不可分割的最小单位。
例如，学生基本信息表中的学号、姓名、性别等都是数据项。
数据对象：是性质相同的数据元素的集合，是数据的一个子集。
例如：整数数据对象是集合N={0 ，± 1 ，±2，⋯}，字母字符数据对象是集合C={ ‘ A’，‘ B’，⋯，‘ Z’，‘ a’，‘ b ’，⋯，‘z’ } ，学生基本信息表也可是一个数据对象。
数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。
换句话说，数据结构是带“结构”的数据元素的集合，“结构”就是指数据元素之间存在的关系。
逻辑结构：从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。
因此，数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。
存储结构：数据对象在计算机中的存储表示，也称为物理结构。
抽象数据类型：由用户定义的，表示应用问题的数学模型，以及定义在这个模型上的一组操作的总称。
具体包括三部分：数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。
数据结构实验报告之链表顺序表的操作
数据结构实验报告之链表顺序表的操作1、编写程序实现顺序表的各种基本运算：初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计⼀个主程序完成如下功能：（1）初始化顺序表L；（2）依次在表尾插⼊a，b，c，d，e五个元素；（3）输出顺序表L；（4）输出顺序表L的长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插⼊元素f，之后输出顺序表L；（9）删除L的第2个元素，之后输出顺序表L；（10）销毁顺序表L。
2、编写程序实现单链表的各种基本运算：初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计⼀个主程序完成如下功能：（1）初始化单链表L；（2）依次在表尾插⼊a，b，c，d，e五个元素；（3）输出单链表L；（4）输出单链表L的长度；（5）判断单链表L是否为空；（6）输出单链表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插⼊元素f，之后输出单链表L；（9）删除L的第2个元素，之后输出单链表L；（10）销毁单链表L。
1顺序表2 #include<stdio.h>3 #include<malloc.h>4 #include<stdlib.h>56#define TRUE 17#define FALSE 08#define OK 19#define ERROR 010#define INFEASIBLE -111#define OVERFLOW -212 typedef int Status;13 typedef char ElemType;1415#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量16#define LISTINCREMENT 10 //线性表存储空间的分配增量17 typedef struct {18 ElemType *elem; //存储空间基地址19int length; //当前长度20int listsize; //当前分配的存储容量21 } SqList;2223 Status InitList_Sq(SqList &L) { //算法2.324 L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));25if (!L.elem) exit(OVERFLOW); //存储分配失败26 L.length = 0; //空表长度为027 L.listsize = LIST_INIT_SIZE; //初始存储容量28return OK;29 }//InitList_Sq3031 Status ListInsert_Sq(SqList &L, int i, ElemType e) { //算法2.432 ElemType *newbase, *p, *q;33if (i<1 || i>L.length + 1) return ERROR; //i值不合法34if (L.length >= L.listsize)35 { //当前存储空间已满，增加分配36 newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));37if (!newbase) exit(OVERFLOW); //存储分配失败38 L.elem = newbase; //新基址39 L.listsize += LISTINCREMENT; //增加存储容量40 }41 q = &(L.elem[i - 1]); //q为插⼊位置42for (p = &(L.elem[L.length - 1]); p >= q; --p) *(p + 1) = *p; //元素右移43 *q = e; //插⼊e44 ++L.length; //表长增145return OK;46 }4748void DispSqList(SqList L)49 {50int i;51for (i = 0; i < L.length; i++)52 printf("%c ", L.elem[i]);53 }5455 Status ListDelete(SqList &L, int i, ElemType &e)56 {57 ElemType *p,*q;58if ((i < 1) || (i > L.length)) return ERROR;59 p = &(L.elem[i - 1]);60 e = *p;61 q = L.elem + L.length - 1;62for (++p; p <= q; ++p)63 *(p - 1) = *p;64 --L.length;65return OK;66 } //ListDelete_Sq6768 Status GetElem(SqList L, int i, ElemType &e)69 {70if (L.length == 0 || i<1 || i>L.length)71return ERROR;72 e = L.elem[i - 1];73return OK;74 }7576int ListLength(SqList L)77 {78return(L.length);79 }8081 Status DestroyList(SqList &L)82 {83 free(L.elem);84 L.length = 0;85return OK;86 }8788 Status ListEmpty(SqList L)89 {90return(L.length == 0);91 }9293int LocateElem(SqList L, ElemType e)94 {95int i = 0;96while (i < L.length && L.elem[i] != e) i++;97if (i >= L.length) return0;98else return i + 1;99 }100101void main()102 {103 SqList h;104 ElemType e;105 InitList_Sq(h);106 ListInsert_Sq(h, h.length + 1, 'a');107 ListInsert_Sq(h, h.length + 1, 'b');108 ListInsert_Sq(h, h.length + 1, 'c');109 ListInsert_Sq(h, h.length + 1, 'd');110 ListInsert_Sq(h, h.length + 1, 'e');111 DispSqList(h);112 printf("%d\n\n",ListLength(h));113 ListEmpty(h);114if (ListEmpty(h))116 printf("Empty\n\n");117 }118else119 {120 printf("Not empty\n\n");121 }122 GetElem(h, 4, e);123 printf("%c\n", e);124 printf("%d\n",LocateElem(h, 'c'));125 ListInsert_Sq(h,3,' f');126 DispSqList(h);127 ListDelete(h, 2, e);128 DispSqList(h);129 DestroyList(h);130 }131132133134135136单链表137138139140 #include<stdio.h>141 #include<malloc.h>142 #include<stdlib.h>143144#define TRUE 1145#define FALSE 0146#define OK 1147#define ERROR 0148#define INFEASIBLE -1149#define OVERFLOW -2150 typedef int Status;151152 typedef char ElemType;153154155 typedef struct LNode {156 ElemType data;157int length;158struct LNode *next;159 }LNode, *LinkList;160161162 Status InitList_L(LinkList &L) {163 L = (LinkList)malloc(sizeof(LNode));164 L->next = NULL;165return OK;166 }167168 Status ListInsert_L(LinkList L, int i, ElemType e) { 169 LinkList p = L,s;170int j = 0;171while (p && j < i - 1)172 {173 p = p->next;174 ++j;175 }176if (!p || j > i - 1)177 {178return ERROR;179 }180else181 {182 s = (LinkList)malloc(sizeof(LNode));183 s->data = e;184 s->next = p->next;185 p->next = s;186return OK;187 }188 }189190void DispList_L(LinkList L)191 {192 LinkList p = L->next;193while (p != NULL)194 {195 printf("%c\n", p->data);196 p = p->next;197 }198200201void DestoryList(LinkList &L)202 {203 LinkList p = L, q = p->next;204while (q != NULL)205 {206 free(p);207 p = q;208 q = p->next;209 }210 free(p);211 }212213 Status ListLength_L(LinkList L) {214 LinkList p = L; int n = 0;215while (p->next != NULL)216 {217 n++;218 p = p->next;219 }220return (n);221 }222223 Status ListDelete(LinkList L, int i, ElemType &e){ 224int j;225 LinkList p, q;226 p = L;227 j = 1;228while (p->next && j < i)229 {230 p = p->next;231 ++j;232 }233if (!(p->next) || j > i)234 {235return ERROR;236 }237 q = p->next;238 p->next = q->next;239 e = q->data;240 free(q);241return OK;242 }243244 Status ListEmpty_L(LinkList L)245 {246return(L->length == 0);247 }248249 Status GetElem(LinkList L, int i, ElemType &e) 250 {251int j;252 LinkList p;253 p = L->next;254 j = 1;255while (p&&j<i)256 {257 p = p->next;258 ++j;259 }260if (!p || j > i)261 {262return ERROR;263 }264 e = p->data;265return OK;266 }267268 Status LocateElem(LinkList L, int e)269 {270 LinkList p = L;271int n=0;272//p->length = 0;273while (p != NULL)274 {275if(p->data != e)276 {277 p = p->next;278 n++;279 }280else281 {282break;283 }284 }285if(p != NULL)286 {287return n;288 }289else290 {291return ERROR;292 }293 }294295void main()296 {297 LinkList h;298 ElemType e;299 InitList_L(h);300 ListInsert_L(h, 1, 'a');301 ListInsert_L(h, 2, 'b');302 ListInsert_L(h, 3, 'c');303 ListInsert_L(h, 4, 'd');304 ListInsert_L(h, 5, 'e');305 DispList_L(h);306 printf("%d\n", ListLength_L(h)); 307if (ListEmpty_L(h))308 {309 printf("Empty\n\n");310 }311else312 {313 printf("Not empty\n\n");314 }315 GetElem(h, 4, e);316 printf("%c\n", e);317 printf("%d\n", LocateElem(h, 'c')); 318 ListInsert_L(h, 3, 'f');319 DispList_L(h);320 ListDelete(h, 2, e);321 DispList_L(h);322 DestoryList(h);323 }。
数据结构试题及答案
数据结构试题及答案一、单项选择题绪论1.计算机中的算法一般具有输入、输出和（ C ）五个基本性质。
A．确定性、有穷性、稳定性 B．易读性、确定性、可行性C．有穷性、确定性、可行性 D．可行性、可移植性、可扩展性2.数据的最小单位是(B )。
（A）数据元素 (B) 数据项 (C) 数据类型 (D) 数据变量3.以下数据结构中（D）属非线性结构。
A.栈B.串C.队列D.平衡二叉树4.以下不属于存储结构是（B）。
A.栈B.线索树C.哈希表D.双链表5.算法的时间复杂度取决于（C）。
A. 问题的规模B. 待处理数据的初始状态C. A和BD. 计算机的配置6.在（D）中将会用到栈结构。
A. 递归调用B. 函数调用C. 表达式求值D.以上场景都有7.某算法的空间复杂度为O(1)，则（B）。
A.该算法执行不需要任何辅助空间B.该算法执行所需辅助空间大小与问题规模n无关C.该算法执行不需要任何空间D.该算法执行所需全部空间大小与问题规模n无关8.顺序表和链表相比存储密度较大，这是因为（B ）。
A.顺序表的存储空间是预先分配的B.顺序表不需要增加指针来表示元素之间的逻辑关系C.链表中所有节点的地址是连续的D.顺序表中所有元素的存储地址是不连续的9.设n是描述问题规模的非负整数，下面程序片段的时间复杂度为（ A）。
x=1;while (x<=n)x=5*x;A. O(log5n)B.O(n)C.O(n log5n)D.O(n5)10.数据结构是指（D）。
A. 一种数据类型 C. 相互之间存在一种或多种特定关系的数据元素的集合B. 数据的存储结构D. 一组性质相同的数据元素的集合11.以下算法的时间复杂度为（A）。
void fun(int n){ int i=1;while (i<=n)i++;}A. O(n)B. O(n)C. O(nlog2n)D. O(log2n)12.在存储数据时，通常不仅要存储各数据元素的值，而且还要存储（C）。
数据结构试题库及答案
数据结构试题库及答案第一章概论一、选择题1、研究数据结构就是研究（ D ）。
A. 数据的逻辑结构B. 数据的存储结构C. 数据的逻辑结构和存储结构D. 数据的逻辑结构、存储结构及其基本操作2、算法分析的两个主要方面是（ A ）。
A. 空间复杂度和时间复杂度B. 正确性和简单性C. 可读性和文档性D. 数据复杂性和程序复杂性3、具有线性结构的数据结构是（ D ）。
A. 图B. 树C. 广义表D. 栈4、计算机中的算法指的是解决某一个问题的有限运算序列，它必须具备输入、输出、（ B ）等5个特性。
A. 可执行性、可移植性和可扩充性B. 可执行性、有穷性和确定性C. 确定性、有穷性和稳定性D. 易读性、稳定性和确定性5、下面程序段的时间复杂度是（ C ）。
for(i=0;i<m;i++)for(j=0;j<n;j++)a[i][j]=i*j;A. O(m2)B. O(n2)C. O(m*n)D. O(m+n)6、算法是（ D ）。
A. 计算机程序B. 解决问题的计算方法C. 排序算法D. 解决问题的有限运算序列7、某算法的语句执行频度为（3n+nlog2n+n2+8）,其时间复杂度表示（ C ）。
A. O(n)B. O(nlog2n)C. O(n2)D. O(log2n)8、下面程序段的时间复杂度为（ C ）。
i=1;while(i<=n)i=i*3;A. O(n)B. O(3n)C. O(log3n)D. O(n3)9、数据结构是一门研究非数值计算的程序设计问题中计算机的数据元素以及它们之间的（）和运算等的学科。
A. 结构B. 关系C. 运算D. 算法10、下面程序段的时间复杂度是（）。
i=s=0;while(s<n){i++;s+=i;}A. O(n)B. O(n2)C. O(log2n)D. O(n3)11、抽象数据类型的三个组成部分分别为（）。
A. 数据对象、数据关系和基本操作B. 数据元素、逻辑结构和存储结构C. 数据项、数据元素和数据类型D. 数据元素、数据结构和数据类型12、通常从正确性、易读性、健壮性、高效性等4个方面评价算法的质量，以下解释错误的是（ ）。
数据结构课程设计 实验报告 心得体会 链表 C语言
数据结构课程设计设计题目: 两个链表的交叉合并专业班级:08软件工程3班姓名：xxxxxx学号： 080107031123设计时间：2010/9/25指导教师：杨薇薇一、设计题目实现两个链表的合并设计目的1．掌握线性链表的建立。
2．掌握线性链表的基本操作。
设计内容和要求1. 建立两个链表A和B，链表元素个数分别为m和n个。
2. 假设元素分别为(x1,x2,…xm)，和(y1,y2, …yn)。
把它们合并成一个线形表C，使得：当m>=n时，C=x1,y1,x2,y2,...xn,yn, (x)当n>m时，C=y1,x1,y2,x2,…ym,xm,…,yn输出线性表C。
3. 用直接插入排序法对C进行升序排序，生成链表D，并输出链表D。
4. 能删除指定单链表中指定位子和指定值的元素。
二、运行环境（软、硬件环境）软件环境： VC++6.0编程软件，运行平台：Win32硬件：普通个人pc机、算法设计的思想三、算法的流程图四、算法设计分析这个两个链表的交叉合并算法主要运用到的是链表的基本操作，定义节点，将链表的创建、计算链表的长度、链表A,B的交叉组合、链表内容升序排列、删除链表指定位置元素、删除指定的元素等算法写成了独立函数，通过主函数调用。
这样就大大精简了主函数的操作。
但主函数中很大篇幅用到了if、else语句，用以指定链表指定结点和指定元素的删除操作，这样就使得本来很精简变得繁琐，降低了程序的质量。
所以其有优点和缺点，但需要不断的改进，不断优化该程序。
五、源代码程序源代码:#include<stdio.h>#include<stdlib.h>typedef struct node //节点定义{int data;struct node *next;} node,*linklist;linklist creat(linklist head) //该函数用来创建链表{node *r,*s;int a;r = (linklist)malloc(sizeof(node));head = r;scanf("%d",&a);while(a != 0){s =(node*)malloc(sizeof(node));s->data=a;r->next=s;r=s;printf("please input a data:");scanf("%d",&a);}r->next=NULL;return head;}linklist length(linklist l) // 返回L中数据元素个数{int i=0;linklist p=l->next; // p指向第一个结点while(p){i++;p=p->next;}return i;}linklist mergel(linklist A,linklist B) //用于实现链表A,B的交叉组合 {int m,n;node *p,*q,*s,*t;linklist C;p=A->next;q=B->next;m=length(A);n=length(B);C=A;if(m<n){p=B->next;q=A->next;C=B;}while(p&&q){s=p->next;p->next=q;if(s){t=q->next;q->next=s;}p=s;q=t;}return C;}linklist sort(linklist L) //链表内容升序排列{linklist p,q,min;int temp;p=L;while( p=p->next ){q=min=p;while(q=q->next){if( q->data<min->data )min = q;}if( min!=p ){temp = p->data;p->data = min->data;min->data=temp;}}return L;}linklist Delete(linklist l,int index) //删除链表指定位置元素{ linklist p,t;int cx=1; //用于计数p=l;if(index<length(l)){while(p&&(cx<index)){t=p;p=p->next;cx++;}t->next=p->next;}elseprintf("input indext error");return l;}linklist Delete_element(linklist l,int data) //删除指定的元素{ linklist p;p=l;if(p->next){while(p->next->data!=data){p=p->next;}p->next=p->next->next;}elseprintf("don't faind the element");return l;}linklist display(linklist l) //打印{ linklist p;printf("new linklist :\n");p = l->next;while(p){printf("%d\n",p->data);p= p->next;}return l;}main(){linklist p,q,A,B,C,D;int indexs;int datas;char name;int cmd;printf("Creat linklist A:\n"); //创建A链表,并打印printf("please input a data:");A = creat(A);printf("Creat linklist B:\n"); //创建B链表,并打印printf("please input a data:");B = creat(B);C = mergel(A,B); //生成C链表，并打印 printf("linklist C\n");p = C->next;while(p){printf("%d\n",p->data);p=p->next;}D=C; //对C进行排序生成D sort(D);printf("linklist D:\n");q = D->next;while(q){printf("%d\n",q->data);q = q->next;}printf("\nplease input 0 or 1 \n");//用1和0判断是按位置删除还是直接删除元素scanf("%d",&cmd);if(cmd==0) //位置删除{printf("please input linklist name\n ");fflush(stdin);scanf("%c",&name);printf("\nplease input index \n");scanf("%d",&indexs);fflush(stdin);if(name=='A'){Delete(A,indexs);display(A);}else if(name=='B'){Delete(B,indexs);display(B);}else if(name=='C'){Delete(C,indexs);display(C);}else if(name=='D'){Delete(D,indexs);display(D);}elseprintf("nameError");}else if(cmd==1) //元素删除{fflush(stdin); //清除缓冲printf("please input linklist name\n ");//fflush(stdin);scanf("%c",&name);printf("\nplease input datas \n");scanf("%d",&datas);if(name=='A'){Delete_element(A,datas);display(A);}else if(name=='B'){Delete_element(B,datas);display(B);}else if(name=='C'){Delete_element(C,datas);display(C);}else if(name=='D'){Delete_element(D,datas);display(D);}elseprintf("name2error");}elseprintf("cmdError");printf("\nOver\n"); getchar();return 0;}六、运行结果分析截图：结果分析：大体来说，该程序都实现了课程设计的算法要求及功能，但还是有很多问题，由于时间问题该算法做得比较粗糙，还不能很好的处理问题，例如，如果想在一次操作完成后还像再次操作，但此时已经结束算法了，需要重新运行程序再次输入操作才能达到要求，这样很繁琐。
数据结构题集答案
数据结构题集第一章绪论一、单选题1.在数据结构中，从逻辑上可以把数据结构分成【C 】。
A.动态结构和静态结构B.紧凑结构和非紧凑结构C。
线性结构和非线性结构D。
内部结构和外部结构2。
数据结构在计算机内存中的表示是指【A 】。
A。
数据的存储结构B。
数据结构C.数据结构的逻辑结构D。
数据元素之间的关系3。
【A 】是数据的最小单位，【B 】是数据的基本单位。
A.数据项B.数据元素C.信息项D.表元素4. 计算机所处理数据一般具有某种内在联系，这是指【B 】.A.数据与数据之间存在某种关系B。
数据元素与数据元素之间存在某种关系C.元素内部存在某种结构D。
数据项与数据项之间存在某种关系5.算法分析的目的是【C 】.A.找出数据结构的合理性B。
研究输入和输出的关系C.分析算法的效率以求改进D.分析算法的易懂性6。
在存储数据时，不仅要考虑存储各数据元素的值，而且还要存储【C 】。
A。
数据处理的方法 B.数据元素的类型C。
数据元素之间的关系D。
数据的存储方法7。
算法分析的主要任务是分析【D 】。
A.算法是否具有较好的可读性B.算法中是否存储语法错误和逻辑错误C。
算法的功能是否符合设计要求D。
算法的执行时间与问题规模之间的关系。
8.数据的运算【A 】。
A.效率与采用何种存储结构有关B.是根据存储结构来定义的C。
有算术运算和关系运算两大类D.必须用程序设计语言来描述9。
算法的计算量的大小称为算法的【B 】.A.效率B.时间复杂度C.现实性D。
难度10.连续存储分配时，存储单元的地址【A 】.A.一定连续B。
一定不连续C。
不一定连续 D.部分连续，部分不连续二、判断题1.数据元素是数据结构的最小单位【。
×】.2。
数据的逻辑结构说明数据元素之间的顺序关系，它依赖于计算机的存储结构【×.】.3。
数据的逻辑结构指数据元素的各数据项之间的逻辑关系【×。
】。
4。
算法的优劣与算法的描述语言无关，但与使用的计算机有关【.×】。
数据结构单链表实验报告
数据结构单链表实验报告数据结构单链表实验报告1. 引言数据结构是计算机科学中的重要基础，它研究数据的组织、存储和管理方式。
单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
本实验旨在通过实践操作单链表，加深对数据结构的理解。
2. 实验目的本实验的主要目的是掌握单链表的基本操作，包括创建链表、插入节点、删除节点和遍历链表。
通过实践操作，加深对链表的理解，提高编程能力和解决问题的能力。
3. 实验环境和工具本实验使用C语言进行编程实现，可以选择任何C语言开发环境，如Dev-C++、Code::Blocks等。
在编程过程中，可以使用任何文本编辑器编写代码。
4. 实验步骤4.1 创建链表首先，需要定义一个节点结构体，包含数据和指向下一个节点的指针。
然后，通过动态内存分配来创建链表的第一个节点，并将其地址赋给头指针。
接下来，可以通过输入数据的方式，逐个创建链表的其他节点。
4.2 插入节点在链表中插入节点是一种常见的操作。
可以在链表的任意位置插入一个新节点，只需要修改相应节点的指针即可。
首先，需要找到插入位置的前一个节点，然后将新节点的指针指向原来的下一个节点，再将前一个节点的指针指向新节点。
4.3 删除节点删除链表中的节点也是一种常见的操作。
可以根据节点的值或位置来删除节点。
首先，需要找到要删除的节点的前一个节点，然后将前一个节点的指针指向要删除节点的下一个节点，最后释放要删除节点的内存空间。
4.4 遍历链表遍历链表是一种查看链表中所有节点的操作。
可以通过循环遍历链表中的每个节点，输出节点的值或进行其他操作。
需要注意的是，遍历链表时需要使用一个临时指针来指向当前节点，以便于移动到下一个节点。
5. 实验结果与分析通过实验，我们成功实现了单链表的创建、插入、删除和遍历操作。
在实际应用中，单链表可以用于实现各种数据结构和算法，如栈、队列和图等。
它具有灵活性和高效性的特点，可以方便地进行节点的插入和删除操作。
《数据结构》实验指导书(C语言版)(浦江学院)
实验1: 顺序表的操作实验一、实验名称和性质二、实验目的1．掌握线性表的顺序存储结构的表示和实现方法。
2．掌握顺序表基本操作的算法实现。
3．了解顺序表的应用。
三、实验内容1．建立顺序表。
2．在顺序表上实现插入、删除和查找操作（验证性内容）。
3．删除有序顺序表中的重复元素（设计性内容）。
四、实验的软硬件环境要求硬件环境要求：PC机（单机）使用的软件名称、版本号：Windows环境下的VC++6.0五、知识准备前期要求熟练掌握了C语言的编程规则、方法和顺序表的基本操作算法。
六、验证性实验1．实验要求编程实现如下功能：（1）根据输入顺序表的长度n和各个数据元素值建立一个顺序表，并输出顺序表中各元素值，观察输入的内容与输出的内容是否一致。
（2）在顺序表的第i个元素之前插入一个值为x的元素，并输出插入后的顺序表中各元素值。
（3）删除顺序表中第i个元素，并输出删除后的顺序表中各元素值。
（4）在顺序表中查找值为e的数据元素，如果查找成功，则显示“查找成功”和该元素在顺序表中的位置，否则显示“查找失败”。
2. 实验相关原理线性表的顺序存储结构称为顺序表，顺序表的存储结构描述为：#define MAXLEN 30 /*线性表的最大长度*/typedef struct{Elemtype elem[MAXLEN]; /*顺序表中存放元素的数组，其中elemtype为抽象数据类型，在程序具体实现时可以用任意类型代替*/int length; /*顺序表的长度，即元素个数*/}Sqlist; /*顺序表的类型*/【核心算法提示】（1）顺序表插入操作的基本步骤：要在顺序表中的第i个数据元素之前插入一个数据元素x,首先要判断插入位置i是否合法，假设线性表的表长为n，则i的合法值范围：1≤i ≤n+1，若是合法位置，就再判断顺序表是否满，如果满，则增加空间或结束操作，如果不满，则将第i个数据元素及其之后的所有数据元素都后移一个位置，此时第i个位置已经腾空，再将待插入的数据元素x插入到该位置上，最后将线性表的表长增加1。
(完整版)数据结构题库多选题
1 . 以下说法正确的是()A . 二叉树的特点是每个结点至多只有两棵子树.B . 二叉树的子树无左右之分。
C . 二叉树只能进行链式存储。
D . 树的结点包含一个数据元素及若干指向其子树的分支。
答案：A，D解析:2 . 算法设计的要求包括____。
A . 正确性B 。
可读性C 。
健壮性D . 确定性答案：A，B，C解析：“确定性"属于算法特性而非要求。
3。
下列属于算法的重要特征的是：A 。
有穷性B 。
确定性C . 可行性D . 输入和输出答案：A，B,C，D解析： ABCD4 . 图的四中存储结构A 。
邻接矩阵B . 邻接表C 。
邻接多重表D 。
十字链表答案：A，B,C，D解析：5。
依据所有数据成员之间的逻辑关系的不同，数据结构分为（）A . 非线性结构B . 逻辑结构C . 物理结构D . 线性结构答案:A，D解析：6 . 图的应用算法有（）A 。
克鲁斯卡尔算法B . 哈弗曼算法C . 迪杰斯特拉算法D . 拓扑排序算法答案：A,C，D解析：7 . 计算机算法必须具备________________等特性。
A . 可行性、确定性B 。
可行性、可移植性C 。
输入、输出D 。
有穷性E 。
易读性F 。
稳定性答案：A，C，D8 . 下列数据结构中，属于线性数据结构的是____A . 栈B . 队列C 。
树D 。
图答案：A，B解析：9 . 下列说法正确的有：A . 算法和程序原则上没有区别，在讨论数据结构时二者通用B . 从逻辑关系上讲，数据结构分为两大类：线性结构和非线性结构C 。
所谓数据的逻辑结构是指数据元素之间的逻辑关系D 。
同一数据逻辑结构中的所有数据元素都具有相同的特性是指数据元素所包含的数据项的个数相等E 。
数据的逻辑结构与数据元素本身的内容和形式无关F . 数据结构是指相互之间存在一种或多种关系的数据元素的全体答案:B，C，E10 . 线性表的特点正确的（）A . 存在唯一的一个被称作”第一个“的数据元素.B . 不存在唯一的一个被称作"第一个“的数据元素.C . 存在唯一的一个被称作”最后一个“的数据元素。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
return head;
link<T> *p=new link<T>(head->next);
while( p!=NULL && count<i)
{
p=p->next;
count++;
}
return p;
}
template<class T>
bool inklist<T>::insert(const int i,const T value)
bool insert(const int p,const T value);
bool remove(const int p);
void print();
};
template<class T>
inklist<T>::inklist()
{
head=tail=new link<T>(NULL);
}
template<class T>
inklist<T>::~inklist()
{
link<T> *tmp;
while(head!=NULL)
{
tmp=head;
head=head->next;
delete tmp;
}
}
template<class T>
link<T> *inklist<T>::setpos(int i)
{
int count=0;
{
cout<<p->date<<" ";
p=p->next;
}
cout << endl;
}
void main()
{
inklist<int> b;
int i,a[10];
for(i=0;i<5;i++)
{
cin>>a[i];
b.append(a[i]);
}
b.print();
}
bool inklist<T>::remove(const int i)
{
link<T> *p,*q;
if((p=setpos(i-1))==NULL||p==tail)
{
cout<<"非法删除点";
return false;
}
q=p->next;
if(q==tail)
{
tail=p;
p->next=NULL;
{
link<T> *p,*q;
if((p=setpos(i-1))==NULL){
cout<<"非法插入点"<<endl;
return false;}
q=new link<T>(valt=q;
if(p==tail)
tail=q;
return true;}
template<class T>
return true;}
else{
tail->next=new link<T>(value,NULL);
tail=tail->next;
return true;
}
}
template<class T>
void inklist<T>::print()
{
link<T>*p;
p=head->next;
while(p!=NULL)
delete q;
}
else
{
p->next=q->next;
delete q;
}
return true;
}
template<class T>
bool inklist<T>::append(const T value)
{
if(tail==NULL){
head->next=tail=new link<T>(value,NULL);
#include<iostream.h>
template<class T>
class link
{
public:
T date;
link<T> *next;
link(const T info, link<T> *nextvalue=NULL)
{
date=info;
next=nextvalue;
}
link(link<T> *nextvalue)
{
next=nextvalue;
}
};
template<class T>class inklist{
private:
link<T> *head,*tail;
link<T> *setpos(const int p);
public:
inklist();
~inklist();
bool append(const T value);