下载文档原格式
数据结构习题及参考答案一、概述在计算机科学领域，数据结构是指组织和存储数据的方式，以便于有效地访问和操作。
它是计算机算法和程序设计的基础。
下面将介绍一些常见的数据结构习题，并提供相应的参考答案，帮助读者更好地理解和掌握数据结构。
二、数组1. 习题：给定一个数组，编写一个函数来计算数组中元素的和。
【参考答案】```pythondef sum_array(arr):sum = 0for num in arr:sum += numreturn sum```三、链表1. 习题：给定一个链表，反转链表，并返回反转后的头节点。
【参考答案】```pythonclass ListNode:def __init__(self, val=0, next=None): self.val = valself.next = nextdef reverse_linked_list(head):prev = Nonecurr = headwhile curr:next_node = curr.nextcurr.next = prevprev = currcurr = next_nodereturn prev```四、栈和队列1. 习题：使用栈实现队列的功能。
【参考答案】```pythonclass MyQueue:def __init__(self):self.stack1 = []self.stack2 = []def push(self, x):self.stack1.append(x)def pop(self):if not self.stack2:while self.stack1:self.stack2.append(self.stack1.pop())return self.stack2.pop()def peek(self):if not self.stack2:while self.stack1:self.stack2.append(self.stack1.pop())return self.stack2[-1]def empty(self):return len(self.stack1) == 0 and len(self.stack2) == 0 ```五、树1. 习题：给定一个二叉树，判断它是否是高度平衡的。
数据结构（第4版）习题及实验参考答案数据结构复习资料完整版（c语言版）数据结构基础及深入及考试习题及实验参考答案见附录结论1、数据的逻辑结构是指数据元素之间的逻辑关系。
即从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。
2、数据的物理结构亦称存储结构，是数据的逻辑结构在计算机存储器内的表示（或映像）。
它依赖于计算机。
存储结构可分为4大类：顺序、链式、索引、散列3、抽象数据类型：由用户定义，用以表示应用问题的数据模型。
它由基本的数据类型构成，并包括一组相关的服务（或称操作）。
它与数据类型实质上是一个概念，但其特征是使用与实现分离，实行封装和信息隐蔽（独立于计算机）。
4、算法：是对特定问题求解步骤的一种描述，它是指令的有限序列，是一系列输入转换为输出的计算步骤。
5、在数据结构中，从逻辑上可以把数据结构分成（C）A、动态结构和表态结构B、紧凑结构和非紧凑结构C、线性结构和非线性结构D、内部结构和外部结构6、算法的时间复杂度取决于（A）A、问题的规模B、待处理数据的初态C、问题的规模和待处理数据的初态线性表1、线性表的存储结构包括顺序存储结构和链式存储结构两种。
2、表长为n的顺序存储的线性表，当在任何位置上插入或删除一个元素的概率相等时，插入一个元素所需移动元素的平均次数为（E），删除一个元素需要移动的元素的个数为（A）。
A、(n-1)/2B、nC、n+1D、n-1E、n/2F、(n+1)/2G、(n-2)/23、“线性表的逻辑顺序与存储顺序总是一致的。
”这个结论是（B）A、正确的B、错误的C、不一定，与具体的结构有关4、线性表采用链式存储结构时，要求内存中可用存储单元的地址（D）A、必须是连续的B、部分地址必须是连续的C一定是不连续的D连续或不连续都可以5、带头结点的单链表为空的判定条件是（B）A、head==NULLB、head->ne某t==NULLC、head->ne某t=headD、head!=NULL6、不带头结点的单链表head为空的判定条件是（A）A、head==NULLB、head->ne某t==NULLC、head->ne某t=headD、head!=NULL7、非空的循环单链表head的尾结点P满足（C）A、p->ne某t==NULLB、p==NULLC、p->ne某t==headD、p==head8、在一个具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是（B）A、O(1)B、O(n)C、O(n2)D、O(nlog2n)数据结构(第4版）习题及实验参考答案9、在一个单链表中，若删除p所指结点的后继结点，则执行（A）A、p->ne某t=p->ne某t->ne某t;B、p=p->ne某t;p->ne某t=p->ne某t->ne某t;C、p->ne某t=p->ne某t;D、p=p->ne某t->ne某t;10、在一个单链表中，若在p所指结点之后插入所指结点，则执行（B）A、->ne某t=p;p->ne某t=;B、->ne某t=p->ne某t;p->ne某t=;C、->ne某t=p->ne某t;p=;D、p->ne某t=;->ne某t=p;11、在一个单链表中，已知q是p的前趋结点，若在q和p之间插入结点，则执行（C）A、->ne某t=p->ne某t;p->ne某t=;B、p->ne某t=->ne某t;->ne某t=p;C、q->ne某t=;->ne某t=p;D、p->ne某t=;->ne某t=q;12、在线性结构中，第一个结点没有前趋结点，其余每个结点有且只有1个前趋结点。
数据结构习题参考答案一、栈和队列1. 栈是一种具有后进先出（Last In First Out）特性的线性数据结构。
常用方法：- push(x): 将元素x压入栈顶；- pop(): 弹出栈顶元素；- top(): 返回栈顶元素；- isEmpty(): 判断栈是否为空；例题解答：（1）题目描述：使用栈实现队列的功能。
解答：使用两个栈，一个用于入队操作，一个用于出队操作。
入队操作：直接将元素压入入队栈中；出队操作：如果出队栈为空，则将入队栈的元素逐个弹出并压入出队栈，此时出队栈的栈顶元素即为要弹出的元素。
复杂度分析：入队操作的时间复杂度为O(1)，出队操作的平均时间复杂度为O(1)。
（2）题目描述：判断括号序列是否合法，即括号是否完全匹配。
解答：使用栈来处理括号序列，遇到左括号则入栈，遇到右括号则与栈顶元素进行匹配，如果匹配成功则继续处理剩余字符，如果不匹配则判定为非法序列。
算法步骤：- 初始化一个空栈；- 从左到右遍历括号序列，对于每个字符执行以下操作：- 如果是左括号，则将其入栈；- 如果是右括号，则将其与栈顶元素进行匹配：- 如果栈为空，则判定为非法序列；- 如果栈顶元素与当前字符匹配，则将栈顶元素出栈，继续处理剩余字符；- 如果栈顶元素与当前字符不匹配，则判定为非法序列。
- 遍历结束后，如果栈为空，则括号序列合法；否则，括号序列非法。
复杂度分析：时间复杂度为O(n)，其中n为括号序列的长度。
2. 队列是一种具有先进先出（First In First Out）特性的线性数据结构。
常用方法：- enqueue(x): 将元素x入队；- dequeue(): 出队并返回队首元素；- getFront(): 返回队首元素；- isEmpty(): 判断队列是否为空；例题解答：（1）题目描述：使用队列实现栈的功能。
解答：使用两个队列，一个用于入栈操作，一个用于出栈操作。
入栈操作：直接将元素入队入栈队列中；出栈操作：如果出栈队列为空，则将入栈队列的元素逐个出队并入队出栈队列，此时出栈队列的队首元素即为要出栈的元素。
习题1 参考答案1至8题答案略。
9.（1）【解】该逻辑结构为线性结构，其图形表示如下：（2）【解】该逻辑结构为树型结构，其图形表示如下：（3）【解】该逻辑结构为图型结构，其图形表示如下：（4）【解】该逻辑结构为线性结构，其图形表示如下：10.【解】该图书库存管理系统所要处理的数据对象为图书，所以该问题中涉及的数据元素为图书，设数据元素类型为bookType 类型。
每个数据元素应包含的数据项有图书编号、书名、作者、出版社、出版日期等。
可用一个表格（如下表）的形式表示图书间的逻辑关系，即该问题数学模型可采用简单的线性结构来表示。
根据问题需求功能目标，此模型的所需的主要处理操作有插入、删除、查找和修改等基本操作。
所以，现用抽象数据类型bookList 表示问题模型，其逻辑结构与基本操作的定义如下： （1）逻辑结构bookList=( D, {r} )D={b i | b i 为bookType 类型的元素，i=1,2,3, ....., n ，n ≥0} r ={ <bk i ,b i+1>| i=1,2,…, n -1, n ≥0 } （2）基本操作 ①初始化操作函数：InitBookList(&BL)。
……初始条件：图书表BL 不存在。
操作结果：构造一个空的图书表BL 。
②求图书表长度操作函数：bookListLength(BL)。
初始条件：图书表BL 已存在。
操作结果：返回图书表BL 中所包含的数据元素（图书）的个数。
③取图书表中元素操作函数：getBook(BL, i, &b)。
初始条件：图书表BL 已存在，且1≤i ≤bookListLength(BL)。
操作结果：用b 返回图书表BL 中的第i 个数据元素的值。
④按编号查找操作函数：locateById(BL, id)。
初始条件：图书表BL 已存在，id 是给定的一个图书编号。
操作结果：返回图书表BL 中图书编号为id 的数据元素的位序，若这样的数据元素不存在，则返回0。
数据结构与算法实验报告目录实验一学生成绩分析程序 (4)1.1 上机实验的问题和要求（需求分析）： (4)1.2 程序设计的基本思想，原理和算法描述： (4)1.3 调试和运行程序过程中产生的问题及采取的措施： (4)1.4 运行输出结果： (4)1.5 源程序及注释： (5)实验二线性表的基本操作 (8)2.1 上机实验的问题和要求（需求分析）： (8)2.2 程序设计的基本思想，原理和算法描述： (8)2.3 调试和运行程序过程中产生的问题及采取的措施： (8)2.4 运行输出结果： (8)2.5 源程序及注释： (8)实验三链表的基本操作 (11)3.1 上机实验的问题和要求（需求分析）： (11)3.2 程序设计的基本思想，原理和算法描述： (11)3.3 调试和运行程序过程中产生的问题及采取的措施： (11)3.4 运行输出结果： (11)3.5 源程序及注释： (11)实验四单链表综合实验 (14)4.1 上机实验的问题和要求（需求分析）： (14)4.2 程序设计的基本思想，原理和算法描述： (14)4.3 调试和运行程序过程中产生的问题及采取的措施： (14)4.4 运行输出结果： (14)4.5 源程序及注释： (14)实验五串 (19)5.1 上机实验的问题和要求（需求分析）： (19)5.2 程序设计的基本思想，原理和算法描述： (19)5.3 调试和运行程序过程中产生的问题及采取的措施： (19)5.4 运行输出结果： (19)5.5 源程序及注释： (21)实验六循环队列的实现与运算 (22)6.1 上机实验的问题和要求（需求分析）： (22)6.2 程序设计的基本思想，原理和算法描述： (22)6.3 调试和运行程序过程中产生的问题及采取的措施： (22)6.4 运行输出结果： (22)6.5 源程序及注释： (23)实验七栈子系统 (26)7.1 上机实验的问题和要求（需求分析）： (26)7.2 程序设计的基本思想，原理和算法描述： (26)7.3 调试和运行程序过程中产生的问题及采取的措施： (26)7.4 运行输出结果： (26)7.5 源程序及注释： (28)实验八树 (36)8.1 上机实验的问题和要求（需求分析）： (36)8.2 程序设计的基本思想，原理和算法描述： (39)8.3 调试和运行程序过程中产生的问题及采取的措施： (39)8.4 运行输出结果： (39)8.5 源程序及注释： (41)实验九建立哈夫曼树与哈夫曼树与码 (50)9.1 上机实验的问题和要求（需求分析）： (50)9.2 程序设计的基本思想，原理和算法描述： (50)9.3 调试和运行程序过程中产生的问题及采取的措施： (50)9.4 运行输出结果： (50)9.5 源程序及注释： (50)实验十图 (53)10.1 上机实验的问题和要求（需求分析）： (53)10.2 程序设计的基本思想，原理和算法描述： (53)10.3 调试和运行程序过程中产生的问题及采取的措施： (53)10.4 运行输出结果： (53)10.5 源程序及注释： (53)实验一学生成绩分析程序一、上机实验的问题和要求（需求分析）：【题目】设一个班有10个学生，每个学生有学号，以及数学、物理、英语、语文、体育 5 门课的成绩信息。
数据结构实验答案1重庆文理学院软件工程学院实验报告册专业：_____软件工程__ _班级：_____软件工程2班__ _学号：_____201258014054 ___姓名：_____周贵宇___________课程名称：___ 数据结构 _指导教师：_____胡章平__________2013年 06 月 25 日实验序号 1 实验名称实验一线性表基本操作实验地点S-C1303 实验日期2013年04月22日实验内容1.编程实现在顺序存储的有序表中插入一个元素（数据类型为整型）。
2.编程实现把顺序表中从i个元素开始的k个元素删除（数据类型为整型）。
3.编程序实现将单链表的数据逆置，即将原表的数据（a1,a2….an）变成(an,…..a2,a1)。
（单链表的数据域数据类型为一结构体，包括学生的部分信息：学号，姓名，年龄）实验过程及步骤1.#include#include#include#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define ElemType int#define MAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/typedef struct{ ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ]中的位置（下标值），空表置为-1*/}SeqList;#include "common.h"#include "seqlist.h"void px(SeqList *A,int j);void main(){ SeqList *l;int p,q,r;int i;l=(SeqList*)malloc(sizeof(SeqList));printf("请输入线性表的长度:");scanf("%d",&r);l->last = r-1;printf("请输入线性表的各元素值:\n");for(i=0; i<=l->last; i++){scanf("%d",&l->elem[i]);}px(l,i);printf("请输入要插入的值:\n");scanf("%d",&l->elem[i]);i++；px(l,i);l->last++;for(i=0; i<=l->last; i++){ printf("%d ",l->elem[i]);}printf("\n");}void px(SeqList *A,int j){ int i,temp,k;for(i=0;i<j;i++)< p="">{ for(k=0;k<j-1;k++)< p="">{if(A->elem[i]elem[k]){temp=A->elem[i];A->elem[i]=A->elem[k];A->elem[k]=temp;}}}}2.#include#include#include#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define ElemType int#define MAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/typedef struct{ ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ]中的位置（下标值），空表置为-1*/}SeqList;#include "common.h"#include "seqlist.h"void px(SeqList *A,int j);int DelList(SeqList *L,int i,SeqList *e,int j)/*在顺序表L中删除第i个数据元素，并用指针参数e返回其值。
数据结构与算法测试题+参考答案一、单选题（共80题，每题1分，共80分）1、某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用什么存储方式最节省运算时间？A、仅有头指针的单循环链表B、双链表C、仅有尾指针的单循环链表D、单链表正确答案：C2、数据结构研究的内容是（）。
A、数据的逻辑结构B、数据的存储结构C、建立在相应逻辑结构和存储结构上的算法D、包括以上三个方面正确答案：D3、下列关于无向连通图特征的叙述中，正确的是：所有顶点的度之和为偶数边数大于顶点个数减1至少有一个顶点的度为1A、只有1B、1和2C、1和3D、只有2正确答案：A4、下面的程序段违反了算法的（）原则。
void sam(){ int n=2;while (n%2==0) n+=2;printf(“%d”,n);}A、确定性B、可行性C、有穷性D、健壮性正确答案：C5、对任意给定的含 n (n>2) 个字符的有限集 S，用二叉树表示 S 的哈夫曼编码集和定长编码集，分别得到二叉树 T1 和 T2。
下列叙述中，正确的是：A、出现频次不同的字符在 T2 中处于相同的层B、出现频次不同的字符在 T1 中处于不同的层C、T1 的高度大于 T2 的高度D、T1 与 T2 的结点数相同正确答案：A6、数据序列{ 3，2，4，9，8，11，6，20 }只能是下列哪种排序算法的两趟排序结果？A、快速排序B、选择排序C、插入排序D、冒泡排序正确答案：A7、设散列表的地址区间为[0,16]，散列函数为H(Key)=Key%17。
采用线性探测法处理冲突，并将关键字序列{ 26，25，72，38，8，18，59 }依次存储到散列表中。
元素59存放在散列表中的地址是：A、11B、9C、10D、8正确答案：A8、采用递归方式对顺序表进行快速排序，下列关于递归次数的叙述中，正确的是：A、每次划分后，先处理较短的分区可以减少递归次数B、递归次数与每次划分后得到的分区处理顺序无关C、递归次数与初始数据的排列次序无关D、每次划分后，先处理较长的分区可以减少递归次数正确答案：B9、以下数据结构中，（）是非线性数据结构。
数据结构试题及答案(10套最新)数据结构试题及答案(10套最新)第一套试题：问题一：什么是数据结构？数据结构的作用是什么？回答：数据结构是一种组织和存储数据的方式，它关注数据元素之间的关系以及对数据元素的操作。
数据结构的作用包括提供高效的数据存储和访问方式，减少资源消耗，简化问题的解决方法，提高算法的性能和程序的可读性。
问题二：请列举几种常见的线性数据结构，并简要介绍它们的特点。
回答：常见的线性数据结构包括数组、链表和栈。
数组是一种连续存储数据元素的结构，具有随机访问的特点；链表是一种通过指针相连的数据元素，可以灵活地插入和删除元素；栈是一种遵循先进后出原则的数据结构，常用于解决递归问题。
问题三：请说明二叉树的定义及其性质。
回答：二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点。
二叉树具有以下性质：每个节点最多有两个子节点，分别称为左子节点和右子节点；左子树和右子树都是二叉树；二叉树的节点个数为n，边的个数为n-1。
问题四：在数组中查找一个元素的时间复杂度是多少？为什么？回答：在数组中查找一个元素的时间复杂度是O(n)，其中n是数组的长度。
因为在数组中查找元素需要按照索引一个一个比较，最坏情况下需要比较n次才能找到目标元素。
问题五：请解释堆排序算法的原理及时间复杂度。
回答：堆排序算法利用堆这种数据结构进行排序。
首先将待排序的元素构建成一个大顶堆，然后将堆顶元素与最后一个元素交换，继续调整堆，再取出堆顶元素与倒数第二个元素交换，依次执行，最后得到从小到大排序的序列。
堆排序的时间复杂度为O(nlogn)。
第二套试题：问题一：请解释图的邻接矩阵和邻接表表示法。
回答：图的邻接矩阵表示法是使用二维数组来表示图的连接关系，数组中的元素表示相应节点之间的边的关系。
邻接表表示法使用链表来表示图的连接关系，链表中的元素表示相邻节点之间的边的关系。
问题二：请说明深度优先搜索算法的原理及其应用。
回答：深度优先搜索（DFS）算法是一种遍历或搜索图的算法，其原理是从起始节点开始，依次深入到尽可能远的节点，直到无法继续深入为止，然后回溯到上一个节点，再继续深入其他未访问过的节点。
实验一线性表一．目的与要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现，提高分析和解决问题的能力。
要求仔细阅读并理解下列例题，上机通过，并观察其结果，然后独立完成后面的实习题。
二．例题问题描述:用链表形式存储一个字符串，插入、删除某个字符，最后按正序、逆序两种方式输出字符串。
输入:初始字符串，插入位置，插入字符，删除字符。
输出:已建立链表（字符串），插入字符后链表，删除字符后链表，逆转后链表。
存储结构:采用链式存储结构算法的基本思想:建立链表当读入字符不是结束符时，给结点分配存储空间，写数据域，将新结点插到表尾；插入字符：根据读入的字符在链表中找插入位置，将新结点插入到该位置之前；删除字符：根据读入的删除字符在链表中找到被删结点后，将其从链表中删除；链表逆转：从链表的第一个结点开始对所有结点处理，将每个结点的前驱变为它的后继；打印链表：从链表的第一个结点开始，依次打印各[运行情况]Input a linktable(a string):abcde↙Build link is :abcdePlease input a char you want to insert after:b↙Please input a char you want to insert:c↙After p insert y,link is:abccdePlease input a char you want to delete:e↙after delete p,link is:abccdOpsite result is :dccba如图显示：实习题：问题描述：设顺序表A中的数据元素递增有序，试写一程序，将x插入到顺序表的适当位置上，使该表仍然有序。
输入：插入前的顺序表，插入的数，插入后的顺序表输出：插入前的顺序表，插入的数，插入后的顺序表存储结构：顺序表存储数据算法基本思想:其实这个题在学C语言时就已经写过了，这里采用顺序表来存储数据。
《数据结构》实验报告二学校：班级：09软工A1学号：09XXXXX 姓名：XXX日期：2010 .04.08 程序名：L2311.CPP一、上机实验的问题和要求：单链表的查找、插入与删除。
设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求：1.从键盘输入20个整数，产生带表头的单链表，并输入结点值。
2.从键盘输入1个整数，在单链表中查找该结点。
若找到，则显示“找到了”；否则，则显示“找不到”。
3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。
4.从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。
5.将单链表中值重复的结点删除，使所得的结果表中个结点值均不相同，输出单链表所有结点值，观察输出结果。
6.删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。
7.把单链表变成带表头结点的循环链表，输出循环单链表所有结点值，观察输出结果。
8.（★）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。
二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）三、源程序及注释：#include <iostream.h>//单链表的定义：typedef int DataType; //DataType可以是任何相应的数据类型如int, float或char typedef struct node //结点类型定义{ DataType data; //结点的数据域struct node *next; //结点的指针域}ListNode,*LinkList;//typedef ListNode *LinkList;void main(){int i;DataType key,x;LinkList head;//ListNode *p;LinkList p;LinkList CreateList(void);void PrintList(LinkList head);LinkList LocateNode(LinkList head,DataType key);LinkList GetNode(LinkList head,int i);void InsertList(LinkList head,DataType x,int i);void DeleteList(LinkList head,int i);void DeleteManyList(LinkList head);void DeleteEvenList(LinkList head);void ChangeCircList(LinkList head);void PrintCircList(LinkList head);head=CreateList(); //建立单链表PrintList(head); //打印单链表cout<<"输入要查找的值:";cin>>key;p=LocateNode(head,key); //单链表查找cout<<"输入要查找的位置:";cin>>i;p=GetNode(head, i);cout<<"请输入欲插入元素的位置:";cin>>i;cout<<"请输入欲插入的元素(整数):";cin>>x;InsertList(head,x,i); //单链表插入PrintList(head); //打印单链表cout<<"请输入欲删除结点的位置:";cin>>i;DeleteList(head,i); //单链表删除PrintList(head); //打印单链表DeleteManyList(head); //删除重复值PrintList(head); //打印单链表DeleteEvenList(head); //删除偶数值PrintList(head); //打印单链表ChangeCircList(head); //修改为循环单链表PrintCircList(head); //打印循环单链表/*void DivideList(LinkList head,LinkList *A,LinkList *B);//分割成两个单链表DivideList(head, &A, &B);PrintList(A);PrintList(B);*/}//单链表的建立：LinkList CreateList(void){LinkList head,p,q;head=new ListNode;head->next=NULL;q=head;cout<<"输入20个整数(以空格分隔):";for(int i=0;i<20;i++){p=new ListNode;cin>>p->data;q->next=p;q=q->next;}q->next=NULL;return head;//在此插入必要的语句}//单链表的打印：void PrintList(LinkList head){LinkList L=head;cout<<"单链表打印:";while(L->next!=NULL){cout<<L->next->data<<" ";L=L->next;}cout<<endl;//在此插入必要的语句}//单链表的查找1：LinkList LocateNode(LinkList head,DataType key) {LinkList L=head;while(L->next!=NULL){{cout<<"找到了!\n";return L;}L=L->next;}cout<<"没找到!\n";return L;//在此插入必要的语句}//*单链表的查找2：LinkList GetNode(LinkList head,int i){LinkList L=head;for(int j=1;j<=i;j++){L=L->next;if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n查找失败!\n";return L;}}if(i<=0){cout<<"<警告!您输入的节点位置不存在!>\n查找失败!\n";return L;}cout<<L->data;cout<<"找到了!\n";return L;}//单链表的插入：void InsertList(LinkList head,DataType x,int i){LinkList L=head,p;for(int j=1;j<i;j++){//if(L->next->next==NULL){cout<<"<警告!您输入的元素位置不存在,程序自动将数插到链表尾部!>\n";break;}L=L->next;}if(i<=0){cout<<"<警告!您输入的元素位置不存在,程序自动将数插到链表的头结的后面!>\n";}//L=L->next;p=new ListNode;p->data=x;p->next=L->next;L->next=p;//在此插入必要的语句}//单链表的删除：void DeleteList(LinkList head,int i){LinkList L=head;for(int j=1;j<i;j++){L=L->next;if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}}if(i<=0){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}L->next=L->next->next;cout<<"删除成功!\n";//在此插入必要的语句}//删除单链表中重复值：void DeleteManyList(LinkList head){LinkList L=head,p;cout<<"删除链表中重复的元素\n";while(L->next!=NULL){p=L->next;while(p->next!=NULL){if(L->next->data==p->next->data)L->next=L->next->next;p=p->next;}L=L->next;}//在此插入必要的语句}//删除单链表中偶数值：void DeleteEvenList(LinkList head){LinkList L=head;cout<<"删除链表中的偶数值\n";do{if(L->next->data%2==0){if(L->next->next!=NULL)L->next=L->next->next;else{L->next=NULL;break;}}L=L->next;}while(L->next!=NULL);//在此插入必要的语句}//修改为循环单链表：void ChangeCircList(LinkList head){LinkList L=head;cout<<"修改为循环单链表\n";while(L->next!=NULL){L=L->next;}L->next=head;//在此插入必要的语句}//循环单链表的打印：void PrintCircList(LinkList head){LinkList L=head;cout<<"循环单链表打印:";while(L->next!=head){cout<<L->next->data<<" ";L=L->next;}cout<<endl;//在此插入必要的语句}/*//分割成两个单链表void DivideList(LinkList head,LinkList *A,LinkList *B); {//在此插入必要的语句}*/四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：当需要插入和删除的数值超过20时，如果不写：if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}那么就会不产生效果.六、对算法的程序的讨论、分析，改进设想，其它经验教训：七、对实验方式、组织、设备、题目的意见和建议：。
第一章概论一、选择题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、下面程序段的时间复杂度是（A ）。
i=s=0;while(s<n){i++;s+=i;}A. O(n)B. O(n2)C. O(log2n)D. O(n3)11、抽象数据类型的三个组成部分分别为（ A）。
A. 数据对象、数据关系和基本操作B. 数据元素、逻辑结构和存储结构C. 数据项、数据元素和数据类型D. 数据元素、数据结构和数据类型12、通常从正确性、易读性、健壮性、高效性等4个方面评价算法的质量，以下解释错误的是（）。
【实验题】
1．狐狸逮兔子
围绕着山顶有10个圆形排列的洞，狐狸要吃兔子，兔子说：“可以，但必须找到我，我就藏身于这十个洞中，你先到１号洞找，第二次隔１个洞（即3号洞）找，第三次隔２个洞（即6号洞）找，以后如此类推，次数不限。
”但狐狸从早到晚进进出出了1000次，仍没有找到兔子。
问兔子究竟藏在哪个洞里？
（提示：这实际上是一个反复查找线性表的过程。
）
【数据描述】
定义一个顺序表，用具有10个元素顺序表来表示这10个洞。
每个元素分别表示围着山顶的一个洞，下标为洞的编号。
#define LIST_INIT_SIZE 10 lem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(Elem Type));
if(!((*L).elem)) return OVERFLOW; /* 存储分配失败*/
(*L).length=0; /*空表长度为0 */
(*L).listsize=LIST_INIT_SIZE; /*初始存储容量*/
return OK;
} /*InitList_Sq */
status Rabbit(SqList *L){
/*构造狐狸逮兔子函数*/
int i,current=0; /*定义一个当前洞口号的记数器，初始位置为第一个洞口*/ for(i=0;i<LIST_INIT_SIZE;i++)
(*L).elem[i]=1; /*给每个洞作标记为1，表示狐狸未进之洞*/ (*L).elem[LIST_INIT_SIZE-1]=0;
(*L).elem[0]=0; /*第一次进入第一个洞，标记进过的洞为0 */
for(i=2;i<=1000;i++)
{ current=(current+i)%LIST_INIT_SIZE;/*实现顺序表的循环引用*/ (*L).elem[current]=0; /* 标记进过的洞为0 */
}/*第二次隔１个洞找，第三次隔２个洞找，以后如此类推,经过一千次*/ printf("\n兔子可能藏在如下的洞中：") ;
for(i=0;i<LIST_INIT_SIZE;i++)
if((*L).elem[i]==1)
printf(" \n此洞是第%d号洞",i+1);/*输出未进过的洞号*/
return OK;
}
void main()
{
SqList *L;
InitList_Sq(L);
Rabbit(L);
getch();
}
【测试数据】
最后的输出结果为：2 4 7 9
【说明】
本算法思路比较简单，采用了顺序表表示围着山顶的10个洞，首先对所有洞设置标志为1，然后通过1000次循环，对每次所进之洞修改标志为0，最后输出标志为1的洞。
2．银行客户
某银行有一个客户办理业务站，在单位时间内随机地有客户到达，设每位客户的业务办理时间是某个范围内的随机值。
设只有一个窗口，一位业务人员，要求程序模拟统计在设定时间内，业务人员的总空闲时间和客户的平均等待时间。
假定模拟数据已按客户到达的先后顺序依次存于某个正文数据文件中。
对应每位客户有两个数据，到达时间和需要办理业务的时间。
复习概念：
与栈相对应，队列是一种先进先出的线性表。
它只允许在表的一端进行插入，而在另一端进行删除元素。
允许插入的一端称队尾，允许删除的一端称队头。
插入与删除分别称为入队与出队。
队列示意图见图3-2：
出队 ←a1 a2 …… an-1 ←an 进队
队头 队尾
【数据描述】
typedef struct{
int arrive;
int treat;6.2f ;
printf("\n 字符串查找\n 设源字符串 \"%s\"\n",str1);
printf("请输入要查找的字符串:");
gets(str2);
result=StrIndexOf(str1,str2);
if(result==-1) {
printf("查找不到你输入的字符串！"); }
else
{
printf("查找到你输入的字符串！开始位置 %d",result+1);
}
break;
}
}
}
张德、陈氏 张文、刘氏 张武、王氏 张兵、李氏 张强 张华 张兵 张德 张武 张文 李氏 张强 陈氏
刘氏 王氏 张华。
