《数据结构》程序设计实习题目
《数据结构》程序设计实习题目
《数据结构》程序设计实习题目1.分别以顺序表和单链表作为存储结构，实现将线性表就地逆置的操作。
（所谓“就地逆置”是指辅助空间为O（1），即利用原表中的结点空间）。
2.写一程序将单链表中值重复的结点删除，使得表中各结点值均不相同。
3.已知一单链表中含有两类字符的数据元素（如：字母、数字），试编写程序将该单链表分成两个单链表，使得每个链表中只含有同一类的字符。
4.假设有两个按元素值递增有序的单链表A和B，试编写程序将A和B归并成一个按元素值递减有序的单链表。
5.利用线性结构（顺序表或链表）实现两个20位大整数的加法运算。
6.已知两个以顺序结构存储的线性表A和B，试编写程序实现从A表中删除包含在B表中的元素。
7.已知两个单链表A和B，试编写程序实现从A表中删除包含在B表中的元素。
8.已知两个以顺序结构存储的线性表A和B，试编写程序实现：将在B表中但不在A表中的元素插入到A表。
9.已知两个单链表A和B，试编写程序实现：将在B表中但不在A表中的元素插入到A表。
10.试编写程序，对任意输入的一个算术表达式，将式中的数字和运算符分成两类（一类是数字，一类是运算符），并按逆序输出。
（提示：利用栈来实现）11.利用栈结构，编写一个程序，对以逆波兰式表示的表达式求值。
12.编写程序，求得所有包含在串S中而不包含在串T中的字符（S中重复的字符只选一个）构成的新串R。
13.编写程序，求任意输入的串S中所含不同字符的总数和每种字符的个数。
14.一个文本串可用事先给定的字母映射表进行加密。
例如：设字母映射表为：a b c d e f g h i j k l m n o p q r s t u v w x y zn g z q t c o b m u h e l k p d a w x f y i v r s j则字符串“encrypt”被加密为“tkzwsdf”。
试写一程序将输入的文本串进行加密后输出。
15.假设两个10×10的稀疏矩阵A和B以三元组表的方式存储，试编写程序实现矩阵的相加运算，其结果存放在三元组表C中。
程序设计与数据结构练习题 附答案
一、单项选择题1．有下列程序段落:int i,a[5]；for(i=0;i<5;i++)scanf(“%d”,&a[i]);若要使数组元素的值分别为1，2，3，4，5，应从键盘输入（B）。
Ａ．1,2,3,4,5↙Ｂ．1 2 3 4 5↙Ｃ．12345↙Ｄ．1;2;3;4;5↙2．数组名作为函数参数进行传递时，形参获得的是（D）。
A．该数组第一个元素的值B．该数组所有元素的值C．该数组所有元素的地址D．该数组的首地址3.设有如下宏定义:#define A 3+2#define B A*A则表达式“B*B”的值为（ A ）。
Ａ．23Ｂ．5 Ｃ．25Ｄ．6254．在下列说明中，结构类型变量x 所占用内存字节数为（D）。
struct exp{ int i;float j;double k;}x;Ａ．8个Ｂ．7个Ｃ．14个Ｄ．随计算机而定5．设有定义：int k=3,*p=&k; 则表达式*p的值是（D）。
Ａ．1 Ｂ．0 Ｃ．2 Ｄ．36．下列程序的输出结果为（A）。
main（）{ int i=3，b；b=(i--)+(i--)；printf（“%d”，b）；}Ａ．6 Ｂ．2 Ｃ．3 Ｄ．47．当c的值不为0时，在下列选项中能正确将c的值赋给变量a、b的是（D）。
Ａ．c=b=a Ｂ. (a=c)||(b=c) Ｃ. a=c=b Ｄ. (a=c)&&(b=c)8．下列叙述不正确的是（ A ）。
Ａ．函数定义可以嵌套Ｂ．宏定义可以嵌套Ｃ．函数调用可以嵌套Ｄ．循环结构可以嵌套9．设char *p=“abcde”，则printf(“%s”, p ) 的输出结果为（ D ）。
Ａ．c Ｂ．cde Ｃ．b Ｄ．abcde10．p1,p2 为指向浮点的指针变量，下列运算没有意义的是（D）。
Ａ．*p1－*p2 Ｂ．p1++ Ｃ．*p1+*p2 Ｄ．p1+p211．设有int i=010,j=10; 则printf( “%d,%d\n”,++i,j--);的输出是（B）。
数据结构实验考试题
第 1 题：报数问题(时间限制为：5000毫秒)5输入：标准输入输出：标准输出描述：n个人围成一个圈，每个人分别标注为1、2、...、n，要求从1号从1开始报数，报到k的人出圈，接着下一个人又从1开始报数，如此循环，直到只剩最后一个人时，该人即为胜利者。
例如当n=10,k=4时，依次出列的人分别为4、8、2、7、3、10，9、1、6、5，则5号位置的人为胜利者。
给定n个人，请你编程计算出最后胜利者标号数。
输入：输入包含若干个用例，每个用例为接受键盘输入的两个数n(1<=n<=1000000), k(1<=k<=50)，分别表示总人数及报到出圈数。
输入为“0 0“表示输入用例结束。
输出：每个用例用一行输出最后胜利者的标号数。
输入样例1：1 110 40 0输出样例1：15第2题：成绩统计(顺序线性表)(时间限制为：1000毫秒)描述：根据输入统计学生的平均分及各科平均分。
输入：第一行为学生的个数n及课程数m，第二行至m+1行为课程名，接下来为各学生的姓名及成绩，每个学生的信息占两行，第一行为学生的姓名，第二行为m个实数，表示学生各科成绩。
输出：输出包含2n+2m行，前2n行为学生的平均分，其中第一行为学生姓名，第二行为该生的平均分，后2m行为各课程的平均分，其中第一行为课程名，第二行为对应的平均分。
(保留两位小数)样例输入：3 2englishcomputerzhangshan87.5 98lisi80 78wangwu60 59样例输出：zhangshan92.75lisi79.00wangwu59.50english75.83computer78.33第3题：合并线性表(时间限制为：500毫秒)描述：已知两非递减的顺序线性表，要求合并成一个新的非递减顺序线性表。
输入：输入包含四行，第一行为自然数n，表示第一个非递减顺序线性表的长度，第二行为n个自然数构成的非递减顺序线性表，第三行为自然数m，表示第二个非递减顺序线性表的长度，第四行为m个自然数构成的非递减顺序线性表。
数据结构与算法实践练习题目及解答
数据结构与算法实践练习题目及解答以下是一些数据结构与算法的实践练题目及其解答。
1. 数组相关题目题目一给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回它们的索引。
def twoSum(nums, target):nums_dict = {}for i in range(len(nums)):nums_dict[nums[i]] = i题目二给定一个整数数组 nums，将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
def moveZeroes(nums):count = 0for i in range(len(nums)):if nums[i] != 0:nums[count] = nums[i]count += 1while count < len(nums):nums[count] = 0count += 12. 链表相关题目题目三反转一个单链表。
class ListNode:def __init__(self, val=0, next=None): self.val = valself.next = nextdef reverseList(head):prev = Nonecurr = headwhile curr is not None:next_node = curr.nextcurr.next = prevprev = currcurr = next_nodereturn prev题目四给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
def deleteDuplicates(head):curr = headwhile curr is not None and curr.next is not None:if curr.val == curr.next.val:curr.next = curr.next.nextelse:curr = curr.nextreturn head以上是一些数据结构与算法的实践练习题目及其解答。
程序设计员实操考核数据结构题目
程序设计员实操考核数据结构题目题目背景描述在现代软件开发中，数据结构是非常重要的一部分。
程序设计员需要对常见的数据结构有深入的了解，并能够灵活运用。
针对这一需求，本文将给出一系列数据结构题目作为程序设计员的实操考核。
题目一：链表反转请设计一个函数，将给定的链表反转。
输入：一个链表的头节点输出：反转后的链表的头节点题目二：判断链表是否有环请设计一个算法，判断给定的链表中是否存在环。
输入：一个链表的头节点输出：若存在环，则返回True；否则返回False题目三：二叉搜索树的插入操作请设计一个算法，实现二叉搜索树的插入操作。
输入：二叉搜索树的根节点和待插入的节点值输出：插入节点后的二叉搜索树的根节点题目四：二叉树的深度请设计一个算法，计算给定二叉树的最大深度。
输入：二叉树的根节点输出：最大深度值题目五：LRU缓存请设计一个数据结构，实现LRU(Least Recently Used)缓存算法。
输入：缓存的容量，以及对缓存的操作（访问某个key、添加某个key-value 对）输出：根据缓存的操作返回相应结果题目六：并查集请设计一个算法，实现并查集（Union-Find）的功能。
输入：并查集的操作（合并两个集合、判断两个元素是否属于同一个集合）输出：根据并查集的操作返回相应结果题目七：堆排序请设计一个算法，实现堆排序。
输入：待排序的数组输出：排序后的数组题目八：图的表示与遍历请设计一个算法，实现图的存储和遍历。
输入：图的顶点和边的关系输出：根据遍历方式返回相应结果题目九：哈希表实现请设计一个算法，实现哈希表的基本操作。
输入：哈希表的操作（插入元素、删除元素、查询元素）输出：根据操作返回相应结果题目十：队列实现栈请设计一个算法，使用队列实现栈的功能。
输入：栈的操作（入栈、出栈、查看栈顶元素）输出：根据操作返回相应结果总结本文给出了程序设计员实操考核的十个数据结构题目，分别涵盖了链表反转、判断链表是否有环、二叉搜索树的插入操作、二叉树的最大深度、LRU缓存、并查集、堆排序、图的表示与遍历、哈希表的实现以及使用队列实现栈等方面的知识点。
数据结构实践题及答案
重庆邮电学院软件学院《数据结构》实验参考资料<适用于软件学院13104级>重庆邮电学院软件学院实验中心目录一、课程编号 (2)二、课程类型 (2)三、本课程的地位、作用与任务 (2)四、课程基本要求 (2)五、实验安排 (2)1、数据结构实验机器与环境 (2)（一）计算机的硬件配置 (2)（二）计算机的软件配置 (2)2、VisualC++6.0开发C语言程序 (2)（一）进入C++工作环境 (2)（二）编译、运行C程序 (3)3、上机实验 (6)实验1：线性表操作 (6)实验2：单链表操作 (11)实验3：表达式计算 (17)实验4：二叉树操作 (24)实验5：二叉搜索树操作 (30)实验6：图的运算 (36)实验7：散列表操作 (43)实验8：外存文件的排序操作 (49)实验9：二叉搜索树与文件操作 (53)六、教材 (60)七、成绩考核办法 (60)数据结构（C语言版）实验一、课程编号130101（本科）二、课程类型课程类型：必修课。
适用专业：计算机系各专业实验学时：10学时三、本课程的地位、作用与任务《数据结构》在计算机科学中是一门综合性的专业基础课。
数据结构的研究不仅涉及到计算机硬件的研究范围，而且和计算机软件的研究有密切的关系，可以认为数据结构是介于数学、计算机硬件和计算机软件三者之间的一门核心课程。
在计算机科学中，数据结构不仅是一般程序设计的基础，而且是设计和实现编译程序、操作系统、数据库系统及其它系统程序和大型应用程序的重要基础，它的主要任务是讨论各种数据结构的逻辑结构，存储结构及有关操作的算法。
目的是使学生学会分析研究计算机加工的数据结构的特性，以便为应用涉及的数据选择适当的逻辑结构、存储结构及相应的算法，并初步了解对算法的时间分析和空间分析技术。
另一方面，通过对本课程算法设计和上机实践的训练，还应培养学生的数据抽象能力和程序设计的能力。
从而为提高学生的实际分析问题和解决问题的编程能力打下基础。
数据结构完整题目及答案1
数据结构与算法实验报告目录实验一学生成绩分析程序 (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. 程序所实现的功能：（1）实现链表的基本操作，如插入、删除、查找等；（2）实现二叉树的基本操作，如插入、删除、查找等；（3）实现数据管理系统，包括数据的存储、查询、修改、删除等；（4）实现用户界面，方便用户进行操作。
2. 程序的输入：（1）输入数据格式：链表数据以空格分隔，二叉树数据以括号表示，节点间用逗号分隔；（2）输入说明：用户需按照要求输入数据，系统将自动处理。
3. 程序的输出：（1）输出格式：链表、二叉树以文本形式输出；（2）输出说明：系统将按照用户操作要求，实时显示操作结果。
4. 测试数据：（1）链表测试数据：1 2 3 4 5；（2）二叉树测试数据：(1,2,(3,4,5),6)。
5. 合作人及其分工：（1）负责人：负责整体设计和开发；（2）成员1：负责链表和二叉树的基本操作实现；（3）成员2：负责数据管理系统的设计和实现；（4）成员3：负责用户界面设计和实现。
三、设计说明1. 主要的数据结构设计说明：（1）链表：采用单向链表实现，节点包含数据域和指针域；（2）二叉树：采用二叉搜索树实现，节点包含数据域和左右指针域。
2. 程序的主要流程图：（1）用户输入数据；（2）系统解析数据并创建链表和二叉树；（3）用户选择操作，系统根据操作进行相应处理；（4）系统输出操作结果。
3. 程序的主要模块：（1）链表模块：负责链表的基本操作；（2）二叉树模块：负责二叉树的基本操作；（3）数据管理系统模块：负责数据的存储、查询、修改、删除等；（4）用户界面模块：负责用户与系统的交互。
4. 程序的主要函数及其伪代码说明：（1）链表插入：function insertNode(head, data)（2）链表删除：function deleteNode(head, data)（3）二叉树插入：function insertNode(root, data)（4）二叉树删除：function deleteNode(root, data)5. 合作人设计分工：（1）负责人：负责整体设计和开发；（2）成员1：负责链表和二叉树的基本操作实现；（3）成员2：负责数据管理系统的设计和实现；（4）成员3：负责用户界面设计和实现。
数据结构与C语言程序设计试题及答案
6．在置换-选择排序中，假设工作区的容量为w，若不计输入、输出的时间，则对n个记录的文件而言，生成所有初始归并段所需时间为O(n log w)。
三.简答题（6’5）
1．有n个不同的英文单词，它们的长度相等，均为m，若n>>50，m<5，试问采用什么排序方法时间复杂度最佳？为什么？
采用基数排序方法最佳。
因单词长度相等，而只有26个字母组成，符合基数排序的条件。
因m<<n，故时间复杂性由O(m(n+rm))变成O(n)。
2．对于一个栈，给出输入序列A，B，C，试给出全部可能的输出序列。若输入序列的长度为n，则可能的输出序列有多少？
ABC，ACB，BAC，BCA，CBA
C2nn/（n+1）
（）10、任何有向图的顶点都可以按拓扑序排序。
二.填空题（2’6）
1．假设用于通信的电文由8个字母组成，其频率分别为0.07，0.19,0.02,0.06, 0.32,0.03,0.21,0.10,为这8个字母设计哈夫曼编码，其中编码长度最大的字母的编码是5位。
2．已知二叉树按中序遍历所得到的结点序列为DCBGEAHFIJK，按后序遍历所得到的结点序列为DCEGBFHKJIA，按先序遍历所得到的结点序列为ABCDGEIHFJK。
O(n log n)
四.程序设计题（38’）
1．假设有两个集合A和B，均以元素值递增有序排列的带头结点的单链表作为存储结构。请编写算法求C=AB，要求C按元素值递增有序排列，并要求利用原表（即表A和表B）的结点空间存放表C。(12’)
void Join(LinkList &la , LinkList &lb , LinkList &lc)
数据结构实验题目
实验题目一一、单链表基本运算【问题描述】设计并实现线性表的单链表存储和运算。
【基本要求】实现单链表的插入、删除和遍历运算，每种操作用一个函数实现。
插入操作：将一个新元素插入表中指定序号的位置。
删除操作：将指定序号的元素从表中删除。
遍历操作：从表头按次序输入所有元素的值，若是空表，则输出信息“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。
此题所用的循环链表中不需要“头结点”，请注意空表和非空表的界限。
【选作内容】用顺序存储结构实现该题目。
三、一元多项式相加、减运算器【问题描述】设计一个一元稀疏多项式简单计算器。
数据结构课程设计-学生-21个题目
选题一：迷宫与栈问题【问题描述】以一个mXn的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。
设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。
【任务要求】1)首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。
求得的通路以三元组（i，j，d）的形式输出。
其中：（i，j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。
如，对于下列数据的迷宫，输出一条通路为：（1，1，1），（1，2，2），（2，2，2），（3，2，3），（3，1，2），…。
2)编写递归形式的算法，求得迷宫中所有可能的通路。
3)以方阵形式输出迷宫及其通路。
【测试数据】迷宫的测试数据如下：左上角（0，1）为入口，右下角（8，9）为出口。
出口出口选题二：算术表达式与二叉树【问题描述】一个表达式和一棵二叉树之间，存在着自然的对应关系。
写一个程序，实现基于二叉树表示的算术表达式的操作。
【任务要求】假设算术表达式Expression内可以含有变量（a～z）、常量（0～9）和二元运算符（+，-，*，/，^(乘幂)）。
实现以下操作：1)ReadExpre(E)—以字符序列的形式输入语法正确的前缀表达式并构造表达式E。
2)WriteExpre(E)—用带括弧的中缀表达式输出表达式E。
3)Assign(V,c)—实现对变量V的赋值（V=c），变量的初值为0。
4)Value(E)—对算术表达式E求值。
5)CompoundExpr（P，E1，E2）--构造一个新的复合表达式（E1）P（E2）【测试数据】1)分别输入0；a；-91；+a*bc；+*5^x2*8x；+++*3^x3*2^x2x6并输出。
2)每当输入一个表达式后，对其中的变量赋值，然后对表达式求值。
选题三：银行业务模拟与离散事件模拟【问题描述】假设某银行有4个窗口对外接待客户，从早晨银行开门（开门9：00am，关门5：00pm）起不断有客户进入银行。
数据结构课程设计题目
数据结构课程设计题目以下7个题目任选其一。
1．排序算法比较利用随机函数产生30000个随机整数，利用插入排序、起泡排序、选择排序、快速排序、堆排序、归并排序等排序方法进行排序，并且（1）统计每一种排序上机所花费的时间。
（2）统计在完全正序，完全逆序情况下记录的比较次数和移动次数。
（3）比较的指标为关键字的比较次数和记录的移动次数(一次记录交换计为3次移动)。
（4）对结果作简单分析，包括对各组数据得出结果波动大小的解释。
2．图的深度遍历对任意给定的图（顶点数和边数自定），建立它的邻接表并输出，然后利用堆栈的五种基本运算（清空堆栈、压栈、弹出、取栈顶元素、判栈空）实现图的深度优先搜索遍历。
画出搜索顺序示意图。
3．图的广度遍历对任意给定的图（顶点数和边数自定），建立它的邻接表并输出，然后利用队列的五种基本运算（置空队列、进队、出队、取队头元素、判队空）实现图的广度优先搜索遍历。
画出搜索顺序示意图。
4．二叉树的遍历对任意给定的二叉树（顶点数自定）建立它的二叉链表存贮结构，并利用栈的五种基本运算（置空栈、进栈、出栈、取栈顶元素、判栈空）实现二叉树的先序、中序、后序三种遍历，输出三种遍历的结果。
画出搜索顺序示意图。
5．链表操作利用链表的插入运算建立线性链表，然后利用链表的查找、删除、计数、输出等运算反复实现链表的这些操作（插入、删除、查找、计数、输出单独写成函数的形式），并能在屏幕上输出操作前后的结果。
画出搜索顺序示意图。
6．一元稀疏多项式简单计数器（1）输入并建立多项式（2）输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。
序列按指数降序排列。
（3）多项式a和b相加，建立多项式a+b，输出相加的多项式。
（4）多项式a和b相减，建立多项式a-b，输出相减的多项式。
用带头结点的单链表存储多项式。
测试数据：（1）(2x+5x8-3.1x11)+(7-5x8+11x9)（2）(6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2+7.8x15)（3）(x+x2+x3)+0（4）(x+x3)-(-x-x-3)7．实现两个链表的合并基本功能要求：（1）建立两个链表A和B，链表元素个数分别为m和n个。
数据结构实习题目
一元多项式计算能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减和相乘, 并将结果输出。
矩阵的运算采用十字链表表示稀疏矩阵, 并实现矩阵的加法运算, 要求: 要检查有关运算的条件, 并对错误的条件产生报警。
迷宫求解输入一个任意大小的迷宫数据, 用递归和非递归两种方法求出一条走出迷宫的路径, 并将路径输出；宾馆订房和退房系统假设一个宾馆有n个标准的客房, 每个标准客房有m个标准间, 利用链表、栈或者队列等数据结构设计出具有订房和退房等功能的管理系统。
建立二叉树和线索二叉树分别用以下方法建立二叉树并用图型显示出来:用先序遍历的输入序列用层次遍历的输入序列用先序和中序遍历的结果最后对所建立的二叉树进行中序线索化, 并对此线索树进行中序遍历(不使用栈)。
学生成绩查询系统试编写程序完成学生成绩记录的查询。
按学号排序后对学号进行折半查找。
随机输入以学号为关键字的学生信息并构建二叉排序树, 对学号进行二叉排序树查找。
马的遍历问题设计程序完成如下要求: 在中国象棋棋盘上, 对任一位置上放置的一个马, 均能选择一个合适的路线, 使得该棋子能按象棋的规则不重复地走过棋盘上的每一位置。
要求:1)依次输出所走过的各位置的坐标。
2)最好能画出棋盘的图形形式, 并在其上动态地标注行走过程。
教学计划编制问题大学的每个专业都要编制教学计划。
假设任何专业都有固定的学习年限, 每学年含两学期, 每学期的时间长度和学分上限都相等。
每个专业开设的课程都是确定的, 而且课程的开设时间的安排必须满足先修关系。
每个课程的先修关系都是确定的, 可以有任意多门, 也可以没有。
每一门课程恰好一个学期。
试在这样的情况下设置一个教学计划编制程序。
设计要求：针对计算机系本科课程, 根据课程之间的依赖关系(如高级语言、离散数学应在数据结构之前开设)制定课程安排计划, 并满足各学期课程数目大致相同。
设计一个模拟计算器的程序要求对包含加、减、乘、除、括号运算符的任意整型表达式进行求解。
(完整版)数据结构经典题目及c语言代码
《数据结构》课程设计题目(程序实现采用C语言)题目1：猴子选王(学时:3）一堆猴子都有编号，编号是1，2,3 .。
.m，这群猴子（m个)按照1-m的顺序围坐一圈，从第1开始数，每数到第n个,该猴子就要离开此圈，这样依次下来，直到圈中只剩下最后一只猴子，则该猴子为大王.要求:m及n要求从键盘输入,存储方式采用向量及链表两种方式实现该问题求解.//链表#include 〈stdio.h〉＃include 〈stdlib.h>// 链表节点typedef struct _RingNode｛int pos；struct _RingNode ＊next;}RingNode， *RingNodePtr；// 创建约瑟夫环，pHead:链表头指针,count：链表元素个数void CreateRing(RingNodePtr pHead, int count)｛RingNodePtr pCurr = NULL， pPrev = NULL；int i = 1;pPrev = pHead；while（——count 〉 0）｛pCurr = (RingNodePtr）malloc（sizeof（RingNode））;i++;pCurr—〉pos = i；pPrev-〉next = pCurr；pPrev = pCurr;}pCurr-〉next = pHead; // 构成环状链表｝void KickFromRing(RingNodePtr pHead， int n){RingNodePtr pCurr, pPrev；int i = 1； // 计数pCurr = pPrev = pHead；while(pCurr != NULL){if （i == n）｛// 踢出环printf（"\n％d"， pCurr->pos); // 显示出圈循序pPrev—>next = pCurr->next；free（pCurr)；pCurr = pPrev—>next；i = 1;}pPrev = pCurr；pCurr = pCurr—〉next;if （pPrev == pCurr)｛// 最后一个printf("\nKing is %d", pCurr—〉pos）; // 显示出圈循序 free（pCurr)；break；}i++;｝}int main（）｛int n = 0, m = 0；RingNodePtr pHead = NULL;printf("M（person count）= ”）;scanf(”％d”, &m);printf("N（out number) = "）;scanf(”％d”， &n）;if(m 〈= 0 |｜ n <= 0）｛printf("Input Error\n”)；return 0;}// 建立链表pHead = (RingNodePtr)malloc（sizeof（RingNode））； pHead->pos = 1;pHead->next = NULL;CreateRing(pHead， m);// 开始出圈printf("\nKick Order： ")；KickFromRing(pHead， n）；printf(”\n"）;system(”pause”）；return 0；}//数组做：#include<stdio。
数据结构课程设计题目(最终版)-2012
数据结构课程设计题目1、医务室模拟。
问题描述：假设只有一位医生，在一段时间内随机地来几位病人；假设病人到达的时间间隔为0~14分钟之间的某个随机值，每个病人所需处理时间为1~9分钟之间的某个随机值。
试用队列结构进行模拟。
实现要求：要求输出医生的总等待时间和病人的平均等待时间。
程序设计思路：计算机模拟事件处理时，程序按模拟环境中的事件出现顺序逐一处理，在本程序中体现为医生逐个为到达病人看病。
当一个病人就诊完毕而下一位还未到达时，时间立即推进为下一位病人服务，中间时间为医生空闲时间。
当一个病人还未结束之前，另有一位病人到达，则这些病人应依次排队，等候就诊。
2、招聘模拟问题描述：某集团公司为发展生产向社会公开招聘m个工种的工作人员，每个工种各有不同的编号（0，1，2，…，m-1）和计划招聘人数，参加招聘的人数有n个（编号为0，1，2，。
，n-1）。
每位应聘者可以申报两个工种，并参加公司组织的考试。
公司将按应聘者的成绩，从高到低的顺序排队录取。
公司的录取原则是：从高分到低分依次对每位应聘者按其第一志愿录取；当不能按第一志愿录取时，便将他的成绩扣去5分后，重新排队，并按其志愿考虑录取。
程序为每个工种保留一个录取者的有序队列。
录取处理循环直至招聘额满，或已对全部应聘者都做了录用处理。
实现要求：要求程序输出每个工种录用者的信息（编号、成绩），以及落选者的信息（编号、成绩）。
3、组织机构问题问题描述：以青岛理工大学为例，实现对我校组织结构的管理。
要求把我校的组织结构以树型结构存储，实现要求：（1）树中每个结点保存部门名称；（2）假定处级部门（含院系）在树中第二层，科级部门在第三层（即最后一层），软件应该能计算出处级部门有几个，有哪几个？（3）软件可以查询某部门下面的具体编制？4、最少换车次数问题问题描述：设某城市有n个车站，并有m条公交线路连接这些车站。
设这些公交车站都是单向的，这n个车站被顺序编号为0~n-1。
数据结构实验考试题
3.求以递增序排列的两个线性表A和B的交集，将结果存于新表C中。要求C中元素仍然以递增序排列，并且C中没有重复的元素。以顺序结构实现此算法。
试设计一个算法，将数组A(0:n-1)中的元素循环右移k位，并要求只用一个元素大小的附加存储，元素移动或交换的次数为O(n)。
用一维数组做存储结构，就地逆置一线性表。如：(a1,a2,...an)逆置后为(an,an-1,...,a1)
设有一个双链表，每个结点中除了有pre,data和next三个域外，还有一个访问频度域freq，在链表起用之前，所有的freq = 0。每当在链表进行一次LOCATE(l,x)运算时，令元素值等于x的结点中freq域的值增1，并使此链表中结点保持按访问频度递减的顺序排列，以便使频繁访问的结点总是靠近表头。
假设二叉树结点的数据为char在一棵以二叉链表存储的二叉树中求在前序序列中排在第k位的结点假设表达式由单字母变量和双目运算符构成写一个算法判断表达式是否为正确的后缀表达式
数据结构实验考试题
1.已知线性表A,B,C是递增有序的线性表。要求对A表作如下运算：删去那些既在B表中出现又在C表中出现的元素。A,B,C以顺序表存储。
8.Ackerman函数的非递归解法
akm(m,n) = n + 1 (当m = 0时)
akm(m-1,1) (当m <> 0且n = 0时)
akm(m-1,akm(m,n-1)) (当m<>0且n<>0时)
9.求一个广义表的深度*广义表的深度即是括号的最大层数。通过记录一个表中所出现的配对括号的层数，就可以求出广义表的深度。
《数据结构》实验题目
《数据结构》实验指导第一章实验0 C/C++程序设计一、实验基础知识二、实验案例1 学生成绩统计系统[问题描述]一个班同学的学号为1-n，输入n位同学的学号、姓名、语文、数学、英语等3门课程成绩，统计每位同学的总分后按成绩从高到低的次序输出。
[基本要求]实现成绩表的录入、总分统计、总分排序和输出。
[测试数据]对于10个同学的学号、姓名、语文、数学、英语等3门课程成绩设计实例数据[实现提示]1）用结构体设计同学记录，学号、各课程成绩和总分数据域用整型，姓名域采用字符数组；学生成绩表用数组模拟，数组大小根据实际学生数动态申请；学生成绩统计系统通过主菜单形式提供成绩表初始化、学生成绩录入、学生总分统计和排名、成绩表输出等功能。
[提高部分]1）实现成绩表的文件录入和文件保存2）实现成绩键盘录入的有效数据限制2复数计算器[问题描述]设计一个能进行复数运算的演示程序。
[基本要求]实现复数的基本运算：1）由输入的实部和虚部生成一个复数；2）求两个复数的和；3）求两个复数的差；4）求两个复数的乘积；5）求复数的实部；6）求复数的虚部[测试数据]0+0=03.1,0;4.22,8.9;输出7.32+i8.99,8;-9,8;输出i169,-8;-9,-8;输出-i16-9,8;-9,-8;输出-189,-7;-9,8;输出i9,-9;-9,8;输出-i[实现提示]将复数的实部和虚部组成结构体数据类型，利用实数的操作实现复数的操作。
[提高部分]1）实现复数的除法运算；2）求共轭复数3有理数计算器[问题描述]设计一个能进行有理数运算的演示程序。
[基本要求]实现有理数的基本运算：1）由输入的分子和分母生成一个有理数；2）求两个有理数的和；3）求两个有理数的差；4）求两个有理数的乘积；5）求有理数的分子；6）求有理数的分母[实现提示]将有理数的分子和分母组成结构体数据类型，利用整数的操作实现有理数的操作。
[提高部分]1）实现有理数的除法运算；第二章线性表一、实验基础知识二、实验案例4顺序表基本操作演示系统[问题描述]设计一个能进行顺序表基本运算的演示程序。
数据结构实践题目
数据结构实践题目实践组1题目：设性线表A=(a1,a2,a3,a4,……an)以带头结点的单链表作为存储结构。
编写一个函数，对A进行调整，使得当n为奇数时A=(a2,a4,….an-1,a1,a3,….an)，使得当n为偶数时,A=(a2,a4,……an,a1,a3….an-1)。
用相关语言编写完整的程序。
实践组2题目：假设称正读和反读都相同的字符序列为“回文”，例如“abba”，“abcba”是回文。
试写一个算法判别读入的一个以‘@’为结束符的字符序列是否是“回文”。
用相关语言编写完整的程序。
实践组3题目：已知在一维数组A[m+n]中依次存放着两个顺序表（a0, a1, ...a m-1,）和（b0, b1, ...b n-1,），试编写一个函数，将数组中两个顺序表的位置互换，即交（b0, b1, ... b n-1,）放在（a0, a1, ... a m-1,）的前面。
用相关语言编写完整的程序。
实践组4题目：一个链表的结点结构struct Node{int data ;Node *next ;};typedefstruct Node Node ;已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。
用相关语言编写完整的程序。
实践组5题目：假设二叉排序树（t为指向根结点的指针）中各元素值均不相同，设计一个递增归算法顺序输出树上各元素值。
用相关语言编写完整的程序。
实践组6题目：一个链表的结点结构struct Node{int data ;Node *next ;};typedefstruct Node Node ;已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)用相关语言编写完整的程序。
实践组7题目：设带头结点的单链表（L为头指针）中的数据元素递增有序。
设计算法，将X插入到链表的适当位置上，并仍保持该表的有序性。
用相关语言编写完整的程序。
北邮数据结构实验题目
实验一线性表1 实验目的通过选择下面四个题目之一进行实现，掌握如下内容：熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法学习指针、模板类、异常处理的使用掌握线性表的操作的实现方法学习使用线性表解决实际问题的能力2 实验内容2.1题目1根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。
线性表存储结构（五选一）：1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能：1、构造：使用头插法、尾插法两种方法2、插入：要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他：可自行定义编写测试main()函数测试线性表的正确性。
2.2题目2利用线性表实现一个通讯录管理，通信录的数据格式如下：struct DataType{int ID; //编号char name[10]; //姓名char ch; //性别char phone[13]; //电话char addr[31]; //地址};要求：实现通讯录的建立、增加、删除、修改、查询等功能能够实现简单的菜单交互，即可以根据用户输入的命令，选择不同的操作。
能够保存每次更新的数据（选作）能够进行通讯录分类，比如班级类、好友类、黑名单等等（选作）编写测试main()函数测试线性表的正确性2.3题目3利用线性表实现一个一元多项式Polynomialf(x) = a+ a1x + a2x2 + a3x3+ … + a n x n提示：Polynomial的结点结构如下：struct term{float coef; //系数int expn; //指数};可以使用链表实现，也可以使用顺序表实现。
要求：能够实现一元多项式的输入和输出能够进行一元多项式相加能够进行一元多项式相减能够计算一元多项式在x处的值能够计算一元多项式的导数（选作）能够进行一元多项式相乘（选作）编写测试main()函数测试线性表的正确性2.4题目4利用循环链表实现约瑟夫问题的求解。
数据结构实习题目
n（ n>20）的阶乘【问题描述】大数运算——计算 n 的阶乘（ n>=20）。
【基本要求】（1）数据的表示和存储；（1.1）累积运算的中间结果和最终的计算结果的数据类型要求是整型——这是问题本身的要求；（ 1.2）试设计合适的存储结构，要求每个元素或结点最多存储数据的 3 位数值。
（2）数据的操作及其实现：基于设计的存储结构实现乘法操作，要求从键盘上输入 n 值，在屏幕上显示最终计算结果。
【测试数据】（1） n＝ 20， n！＝ 2432902008176640000（2） n＝ 30， n！＝ 265252859812191058636308480000000#include "stdafx.h"#include <iostream>#include<iomanip>using namespace std;template <class T>class Chain;template <class T>class ChainNode{friend Chain<T>;private:T data;ChainNode<T> *link;};template<class T>class Chain{public:Chain() {first = 0;}// 构造函数~Chain();// 析构函数bool IsEmpty() const {return first == 0;} int Length() const;bool Find(int k, T& x) const;int Search(const T& x) const;Chain<T>& Delete(int k, T& x);Chain<T>& Insert(int k, const T& x);// 判断链表是否为空// 求链表的长度// 查找第 k 个元素// 查找元素x// 删除第 k 个元素// 在第 k 个元素之后插入xvoid Output(ostream& out) const;// 单链表的输出Chain<T>& Fac(long n);//求大数阶乘private:ChainNode<T> *first;//指向第一个节点};template<class T>Chain<T>::~Chain(){// 删除所有的节点ChainNode<T> *next;while (first){next = first->link;delete first;first = next;}}template<class T>bool Chain<T>::Find(int k, T& x) const{//查找第k个元素，并赋值给xif (k < 1) return false;ChainNode<T> *current = first;int index = 1;while (index < k && current){current = current->link;index++;}if (current){x = current->data;return true;}return false;}template<class T>int Chain<T>::Search(const T& x) const{// 查找元素x，返回该元素的下标ChainNode<T> *current = first;int index = 1;while (current && current->data != x){current = current->link;index++;}if (current) return index;return 0;}template<class T>Chain<T>& Chain<T>::Delete(int k, T& x){//删除第k个元素，并赋值给x，返回改变后的链表ChainNode<T> *p = first;if (k == 1)first = first->link;else{ChainNode<T> *q = first;for (int index = 1; index < k - 1 && q;index++)q = q->link;p = q->link;q->link = p->link;}x = p->data;delete p;return *this;}template<class T>int Chain<T>::Length() const//返回链表的长度{ChainNode<T> *current = first;int len = 0;while (current){len++;current = current->link;}return len;}template<class T>Chain<T>& Chain<T>::Insert(int k, const T& x)// 在第k 个元素之后插入x，返回插入后的链表{ChainNode<T> *p = first;for (int index = 1; index < k && p;index++)p = p->link;ChainNode<T> *y = new ChainNode<T>;y->data = x;if (k){y->link = p->link;p->link = y;}else{y->link = first;first = y;}return *this;}template<class T>void Chain<T>::Output(ostream& out) const//输出链表元素{ChainNode<T> *current;int i=0,j=Length();for (current = first; current;current = current->link){i++;if(i==j&&j>=1){if(current->link)out <<setw(3)<<setfill('0')<< current->data << "";elseout<< current->data << "";i=1;j--;current=first;}}out<<setw(3)<<setfill('0')<<first->data<<" ";}template <class T> // 重载运算符 <<ostream& operator<<(ostream& out, const Chain<T>& x){x.Output(out); return out;}template <class T>Chain<T>& Chain<T>::Fac(long n)// 初始化{int i=0;long j=n;while(j>999){Insert(i,j%1000);i++;j=j/1000;}Insert(i,j);// 通过插入来建立链表(0,20) //计算long m=0, k=0;ChainNode<T> *current;for(;n>2;n--){for (current = first;current;current = current->link)//?{m=k;k=(current->data*(n-1)+k)/1000;// 向前进位current->data=(current->data*(n-1)+m)%1000;if(!current->link&&k>0)//?{while(k>999){Insert(Length(),k%1000);k=k/1000;}Insert(Length(),k);// 链表长度加一k=0;break;}}}return *this;}int main(){long n;char ch;do{n: ";cout<<" 请输入需要阶乘的数字cin>>n;Chain<long> a;a.Fac(n);cout<<n<<" 的阶乘为 :"<<endl;cout<<a;cout<<endl;cout<<" 是否进行计算:";cout<<endl;cin>>ch;}while(ch=='Y');return 0;}2:题目：表达式求值要求：实现关键栈的使用两位数以上、负数、小数点？实现方式控制台程序MFC 对话框#include "stdafx.h"#include <iostream>using namespace std;#include<assert.h>#include <cstdlib>#include <math.h>template<class T>class Stack{public:Stack(int sz=50);~Stack(){delete[]elements;}void Push(const T &x); //压入栈bool Pop(T&x);// 弹出栈T GetTop(void)const; // 取栈顶元素bool IsEmpty()const{return(top==-1)?true:false;}bool IsFull()// 判断栈是否满{return (top==MaxSize-1)?true:false;}int GetSize()const//?{return top+1;}void MakeEmpty(){top=-1;}private:T*elements;int top;int MaxSize;void overflowProcess();//栈溢出处理};template<class T>Stack<T>::Stack(int sz){top=-1;MaxSize=sz;elements=new T[MaxSize];// 创建栈的数组空间assert(elements!=NULL);//判断动态内存是否分配成功是否}template<class T>void Stack<T>::Push(const T&x){if(IsFull()==true){overflowProcess();}top++;elements[top]=x;}template<class T>bool Stack<T>::Pop(T&x){if(IsEmpty()==true){return false;}x=elements[top--];return true;}template<class T>T Stack<T>::GetTop(void)const//返回栈顶元素{if(IsEmpty()==true){cerr<<"栈为空 !"<<endl;exit(1);}return elements[top];}template<class T>void Stack<T>::overflowProcess() //溢出处理{T *newArray=new T[2*MaxSize]; // 扩充栈的空间for(int i=0;i<=top;i++){MaxSize=2*MaxSize;newArray[i]=elements[i];}delete[]elements;// 释放原来旧的空间}class Calculater//计算的声明{public:Calculater(){}void Run();// 执行表达式计算void Clear();// 清空处理private:Stack<double>s;// 声明double 型的栈对象void AddOperand(double value);// 把数值压入栈中bool GetOperand(double &left,double& right);// 判断取操作数操作是否成功void DoOperator(char ch);// 进行操作};void Calculater::AddOperand(double value){s.Push(value);}bool Calculater::GetOperand(double&left,double&right){if(s.IsEmpty()==true){cerr<<"缺少右操作数"<<endl;return false;}s.Pop(right);if(s.IsEmpty()==true){cerr<<"缺少左操作数"<<endl;return false;}s.Pop(left);return true;}void Calculater::Clear(){s.MakeEmpty();}void Calculater::DoOperator(char ch){double left,right,value;bool result;result=GetOperand(left,right);if(result==true){switch(ch){case'+':value=left+right;s.Push(value);break;case'-':value=left-right;s.Push(value);break;case'*':value=left*right;s.Push(value);break;case'/':if(right==0.0){cerr<<"Divide by 0!"<<endl;Clear();}else{value=left/right;s.Push(value);}break;}cout<<"="<<s.GetTop()<<" ";}elseClear();}void Calculater::Run(){char ch;double newOperand;while(cin>>ch,ch!='#'){switch(ch){case '+':case'-':case'*':case'/'://是操作数，执行计算DoOperator(ch);break;default:// 其实也是一种case，只不过就是指“除了指定的几个case以外的其他情况”，不是操作符cin.putback(ch);// 字符放回输入流cin>>newOperand;// 重新读取操作数，一个操作数的第一个字符 AddOperand(newOperand);// 将操作数放入栈中}}}int main(){Calculater call;cout<<"输入计算表达式:";call.Run();return 0;}3.题目 :题目：二叉树基本算法的实现功能要求：键盘输入二叉树结点序列，创建一棵二叉树实现SwapTree 方法，以根结点为参数，交换每个结点的左子树和右子树（提示：前序递归）实现 Find 方法，查找值为 key 的结点，并输出该结点的所有祖先结点你可以选择：对BinaryTree 模板进行功能扩充；自己定义并实现二叉树类要求键盘输入二叉树结点序列结点序列可以是前序，也可以是层次空结点以 #表示//binarytree.h#ifndef BINARYTREE_H#define BINARYTREE_H#include<iostream.h>template<class T>class BinaryTreeNode//二叉树结点{//friend BinaryTree<T>;public:BinaryTreeNode(){LeftChild=RightChild=0;}BinaryTreeNode(const T&e){data=e;LeftChild=RightChild=0;}BinaryTreeNode(const T&e,BinaryTreeNode *l,BinaryTreeNode *r) {data=e;LeftChild=l;RightChild=r;}public:T data;BinaryTreeNode<T>*LeftChild,*RightChild;};template<class T>class BinaryTree{friend BinaryTreeNode<T>;public:BinaryTree(){root=0;}~BinaryTree(){}bool IsEmpty()const{return ((root)?false:true);}void Creat();void PreOrder(void (*Visit)(BinaryTreeNode<T>*u))// 前序遍历{PreOrder(Visit,root);}void InOrder(void (*Visit)(BinaryTreeNode<T>*u))// 中序遍历{InOrder(Visit,root);}void PostOrder(void (*Visit)(BinaryTreeNode<T>*u))// 后序遍历{PostOrder(Visit,root);}void LevelOrder(void(*Visit)(BinaryTreeNode<T>*u))// 层次遍历{PreOrder(Output,root);cout<<endl;}void InOutput()// 中序输出{InOrder(Output,root);cout<<endl;}void Postput()// 后序输出{PostOrder(Output,root);cout<<endl;}void LevelOutPut()// 层次输出{LevelOrder(Output);cout<<endl;}int Height()const// 计算树的高度{return Height(root);}int Size()const// 计算树的大小{return Size(root);}BinaryTreeNode<T>*iCreat();void swap()// 交换左右节点{swap(root);}int leave()// 计算叶子节点个数{return leave(root);}int noleave()////计算非叶子节点个数{return noleave(root);}private:BinaryTreeNode<T>*root;void PreOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t); void InOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t); void PostOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t); //void LevelOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t); static void Output(BinaryTreeNode<T>* t)// 输出树的所有节点 {cout<<t->data <<" ";}int Height(BinaryTreeNode<T>*t)const;int Size(BinaryTreeNode<T>*t)const;void swap(BinaryTreeNode<T>*t);int leave(BinaryTreeNode<T>*t);int noleave(BinaryTreeNode<T>*t);};template<class T>int BinaryTree<T>::Height(BinaryTreeNode<T>*t)const{if(!t) return 0;int hl=Height(t->LeftChild);int hr=Height(t->RightChild);if(hl>hr) return ++hl;else return ++hr;}template<class T>int BinaryTree<T>::Size(BinaryTreeNode<T>*t)const{if(!t) return0;int sl=Size(t->LeftChild);int sr=Size(t->RightChild);return (1+sl+sr);}template<class T>BinaryTreeNode<T>*BinaryTree<T>::iCreat( )T ch;cin>>ch;BinaryTreeNode<T> * root;if(ch=='#'){root=NULL;}else{root=new BinaryTreeNode<T>;root->data=ch;root->LeftChild=this->iCreat();root->RightChild=this->iCreat();}return root;}template<class T>void BinaryTree<T>::Creat(){this->root = iCreat();}template<class T>void BinaryTree<T>::PreOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t) {if(t){Visit(t);PreOrder(Visit,t->LeftChild);PreOrder(Visit,t->RightChild);}}template<class T>void BinaryTree<T>::InOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t) {if(t)InOrder(Visit,t->LeftChild);Visit(t);InOrder(Visit,t->RightChild);}}template<class T>void BinaryTree<T>::PostOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t) {if(t){PostOrder(Visit,t->LeftChild);PostOrder(Visit,t->RightChild);Visit(t);}}template<class T>void BinaryTree<T>::swap(BinaryTreeNode<T> *t){BinaryTreeNode<T> *temp;if(!t) return;else{temp=t->LeftChild;t->LeftChild=t->RightChild;t->RightChild=temp;swap(t->LeftChild);swap(t->RightChild);}}template<class T>int BinaryTree<T>::leave(BinaryTreeNode<T>*t){if(!t) return 0;if(t->LeftChild==0&&t->RightChild==0)return 1;int leafl=leave(t->LeftChild);int leafr=leave(t->RightChild);return leafl+leafr;}template<class T>int BinaryTree<T>::noleave(BinaryTreeNode<T> *t)if(!t) return 0;if(!t->LeftChild&&!t->RightChild)return 1;int leafl=noleave(t->LeftChild);int leafr=noleave(t->RightChild);return leafl+leafr+1;}#endif#include "stdafx.h"#include"binarytree.h"#include <iostream.h>void main(){cout<<"输入二叉树 :"<<endl;BinaryTree<char> Tree;Tree.Creat();//cout<<" 前序遍历 :";//Tree.PreOutput();cout<<"中序遍历 :";Tree.InOutput();cout<<"后序遍历 :";Tree.Postput();cout<<"二叉树的叶节点数目为:";cout<<Tree.leave()<<endl;Tree.swap();cout<<"交换前序遍历:";//Tree.PreOutput();}实习题目 4.任务：输入一棵二叉树的前序遍历序列和中序遍历序列，重构这棵二叉树功能要求：在题目三的基础之上，增加一个方法，重构这棵二叉树要求以图示效果，层次输出这棵二叉树//bintree.h#ifndef BINTREE_H#define BINTREE_H#include<iostream.h>#include"queue.h"template<class T>class BinaryTree;template<class T>// 二叉树的二叉链表class BinaryTreeNode{friend BinaryTree<T>;public:BinaryTreeNode(){LeftChild=RightChild=0;}//构造函数BinaryTreeNode(const T&e){data=e;LeftChild=RightChild=0;}BinaryTreeNode(const T&e,BinaryTreeNode *l,BinaryTreeNode *r){data=e;LeftChild=l;RightChild=r;}private:T data;BinaryTreeNode<T>*LeftChild,*RightChild;};template<class T>class BinaryTree{public:BinaryTree()// 构造函数空树{root=0;}~BinaryTree(){}bool IsEmpty()const{return ((root)?false:true);}//void BinaryTree<T>::LevelOrder(void(* Visit)(BinaryTreeNode<T>*u));void LevelOrder(void(BinaryTree<T>::* Visit)(BinaryTreeNode<T>*u));// 层次访问 ,在访问某一层结点时把下一层结点记忆在队列（尾）中，然后在访问在队头的结点void LevelOutPut(){if(!root)// 空树{return;}cout<<root->data;LevelOrder(Output);cout<<endl;}BinaryTreeNode<T>*createBinaryTree(T *VLR,T*LVR,int n)// 构造二叉树前中 n 为元素个数{if(n==0)return NULL;int k=0;while(VLR[0]!=LVR[k])// 在中序前序结合找根{k++;}BinaryTreeNode<T>*t=new BinaryTreeNode<T>(VLR[0]);//根结点为tt->LeftChild=createBinaryTree(VLR+1,LVR,k);//从前序VLR+1 开始对中序0~k-1 左子序列的k 个元素递归建立左子树t->RightChild=createBinaryTree(VLR+k+1,LVR+k+1,n-k-1);//从前序V LR+k+1开始对中序k+1~n-1 左子序列的 n-k-1 个元素递归建立右子树return t;}BinaryTreeNode<T>*root;void Output(BinaryTreeNode<T>* t){if(t->LeftChild||t->RightChild)// 左或又子树不为空{if(t->LeftChild)cout<<t->LeftChild->data;elsecout<<"#";if(t->RightChild)cout<<t->RightChild->data;elsecout<<"#";}}};template<class T>void BinaryTree<T>::LevelOrder(void (BinaryTree<T>::*Visit)(BinaryTreeNode<T> *u))//void BinaryTree<T>::LevelOrder(void(* Visit)(BinaryTreeNode<T>*u)){LinkedQueue<BinaryTreeNode<T>*>Q;BinaryTreeNode<T> *p=root;Q.EnQueue(p);// 根节点进队while(!Q.IsEmpty ()){Q.DeQueue(p);// 根节点出队(this->*Visit)(p);// 访问根结点if(p->LeftChild!=NULL)Q.EnQueue(p->LeftChild);// 左子女进队if(p->RightChild!=NULL)Q.EnQueue(p->RightChild); //右子女进队}}#endif//queqe.h#ifndef QUEQE_H#define QUEQE_H// 单链表的链式队列template<class T>class LinkedQueue;template<class T>class Node{friend LinkedQueue<T>;private:T data;Node<T>*link;};template<class T>class LinkedQueue{public:LinkedQueue()// 构造函数{front=rear=0;// 建立空队列}~LinkedQueue();// 析构函数bool IsEmpty()const{return ((front)?false:true);}LinkedQueue<T>&EnQueue(const T &x);//往队尾队列中插入元素 LinkedQueue<T>&DeQueue(T&x);// 从队头删除元素private:Node<T>*front;Node<T>*rear;};template<class T>LinkedQueue<T>::~LinkedQueue()//析构函数的实现{Node<T>*next;while(front){next=front->link;delete front;front=next;}}template<class T>LinkedQueue<T>&LinkedQueue<T>::EnQueue(const T &x){Node<T>*p=new Node<T>;p->data=x;p->link=0;if (front){rear->link=p;// 在列尾添加新的结点}else// 队列为空，新结点成为第一个结点{front=p;}rear=p;return *this;}template<class T>LinkedQueue<T>&LinkedQueue<T>::DeQueue( T&x)//队头结点删去{Node<T>*p=front;// 暂存队头结点x=front->data;front=front->link;// 队头修改delete p;return*this;}#endif#include "stdafx.h"#include"binarytree.h"#include <iostream.h>void main(){BinaryTree<char> Tree;//char 类型的int n;cout<<"二叉树中元素个数:";cin>>n;char *L=new char[n];char *R=new char[n];cout<<"前序序列为 :";int i=0,j=0;while(i<n){cin>>L[i];i++;}cout<<"中序序列为 :";while(j<n){cin>>R[j];j++;}Tree.root=Tree.createBinaryTree(L,R,n);cout<<"层次遍历 :";Tree.LevelOutPut();delete[]L;delete[]R;}实习题目 5.最优二叉树基本要求：对Huffman 树的方法进行扩充，实现如下功能：1）键盘输入一个字符串，统计每个字符出现的频率；2）输出每个字符的 Huffman 编码3）计算并输出WPL提高要求：改键盘输入为读文件（任何类型）//huffmantree.h#ifndef HUFFMANTREE_H#define HUFFMANTREE_H#include <iostream.h>#include "minheap.h"#include <stdlib.h>//const int MaxN = 100;template <class Type>class HuffmanTree;template <class Type>class HuffmanTreeNode// 树结点的类定义{//friend class HuffmanTree;public:int arrkey;Type data;// 结点数据HuffmanTreeNode <Type>*leftChild, *rightChild, *parent;};template <class Type>class HuffmanCodeNode{//friend class HuffmanTree;public:HuffmanTreeNode <Type> *dataptr;int bit[MaxN];int start;};template <class Type>class HuffmanTree{//friend class HuffmanTreeNode;//friend class HuffmanCodeNode;public:HuffmanTree(){};HuffmanTree(Type weight[], int n);HuffmanCode();// 求 huffman 编码protected:HuffmanTreeNode <Type> *hfTree;HuffmanCodeNode <Type> *hfCode;int currentSize;void MergeTree(HuffmanTreeNode <Type> &bt1, HuffmanTreeNode <Type>&bt2, HuffmanTreeNode <Type> *pt)// 合并二叉树{pt->leftChild = &bt1;pt->rightChild = &bt2;pt->data = bt1.data + bt2.data;pt->parent = NULL;bt1.parent = pt; bt2.parent = pt;}};template <class Type>HuffmanTree <Type> :: HuffmanTree(Type weight[], int n)//n个权值为W[1]....{HuffmanTreeNode <Type> *firstchild, *secondchild, *parent;HuffmanTreeNode <Type> *TNode;if(n > MaxN){cout<<"Error!"<<endl;exit(-1);}currentSize = n;hfCode = new HuffmanCodeNode <Type> [n];TNode = new HuffmanTreeNode <Type> [n];for(int i = 0;i < n;i++)// 森林各颗树初始化{hfCode[i].dataptr = &TNode[i];TNode[i].data = weight[i];TNode[i].arrkey = i;TNode[i].parent = TNode[i].leftChild = TNode[i].rightChild = NULL;}MinHeap <HuffmanTreeNode <Type> > hp(TNode,n);for(i = 0;i < n-1;i++){parent = new HuffmanTreeNode <Type>;firstchild = hp.RemoveMin();secondchild = hp.RemoveMin();MergeTree(*firstchild, *secondchild, parent);hp.Insert(*parent);}hfTree = parent;}template <class Type>HuffmanTree <Type> :: HuffmanCode(){HuffmanCodeNode <Type> *cd = new HuffmanCodeNode<Type>;HuffmanTreeNode <Type> *child, *parent;for(int i=0;i < currentSize;i++){cd->start = currentSize -1;child = hfCode[i].dataptr;parent = child->parent;while(parent != NULL){if(parent->leftChild == child)//向左标记为0cd->bit[cd->start] = 0;elsecd->bit[cd->start] = 1; // 向右标记为0child = parent;parent = parent->parent;cd->start--;}for(int k=0;k < currentSize;k++){hfCode[i].bit[k] = cd->bit[k];hfCode[i].start = cd->start+1;}}cout<<endl<<" 输出： "<<endl;for(i=0;i<currentSize;i++){cout<<hfCode[i].dataptr->data<<":";for(int j=hfCode[i].start;j<currentSize;j++)cout<<hfCode[i].bit[j];cout<<endl;}}#endif//minheap.h#ifndef MINHEAP_H#define MINHEAP_Htemplate <class Type>class MinHeap{//friend class Type;public:MinHeap(int maxSize);MinHeap(Type a[], int n);// 构造函数~MinHeap(){delete []heapArr;}//析构函数int Insert(Type &d);// 把数据元素插入最小堆中Type * RemoveMin();// 删除堆顶上最小元素private:Type * heapArr;// 存放堆中元素的数组Type * Arr;Type * saveNode[100];int saveNodeCount;int heapCurrentSize;// 堆中当前元素个数int heapMaxSize;// 最多元素个数void siftDown(int p);//从p下滑调整为最小堆void siftUp(int p);// 从 p 上滑调整为最小堆};template <class Type>MinHeap <Type> :: MinHeap(int maxSize)heapMaxSize = maxSize;heapArr = new Type [heapMaxSize];// 创建堆存储空间heapCurrentSize = 0;// 当前元素个数为0}template<class Type>MinHeap<Type>::MinHeap(Type a[],int n){heapMaxSize = n;heapArr = new Type[heapMaxSize];saveNodeCount=n;for(int j=0;j<n;j++){heapArr[j]=a[j];}Arr=a;heapCurrentSize=n;// 复制堆数组，建立当前大小int i=(heapCurrentSize-2)/ 2;// 找最初调整位置，即最后分支节点while(i>=0){siftDown(i);// 再向前换一个分支结点i--;}/*if (heapMaxSize%2==0){for(int k=0;k<n;k++){heapArr[k]=heapArr[k+1];}}*/}//?template <class Type>void MinHeap<Type>::siftDown(const int start)//堆下滑，从开始结点开始{int i=start,j;Type temp=heapArr[i];j=2*i+1;// 左子女位置while(j<=heapCurrentSize-1){if(j<=heapCurrentSize-1 && heapArr[j].data > heapArr[j+1].data) j++;if(temp.data <=heapArr[j].data) break;// else {heapArr[i]=heapArr[j];i=j;j=2*j+1;}//小不作调整小上移}heapArr[i]=temp;template<class Type>int MinHeap<Type>::Insert(Type&d){heapArr[heapCurrentSize]=d;heapArr[heapCurrentSize].arrkey=saveNodeCount;siftUp(heapCurrentSize);heapCurrentSize++;saveNode[saveNodeCount++]=&d;return 1;}template <class Type>void MinHeap<Type>::siftUp(int p){int j=p,i;Type temp = heapArr[j];i=(j-1)/ 2;while(j>0){if(heapArr[i].data<=temp.data)break;else{heapArr[j]=heapArr[i];j=i;i=(j-1)/ 2;}}heapArr[j]=temp;}template<class Type>Type * MinHeap<Type>::RemoveMin(){Type * temp=new HuffmanTreeNode<char>;(*temp)=heapArr[0];heapArr[0]= heapArr[heapCurrentSize-1];heapCurrentSize--;siftDown(0);if(temp->arrkey>-1 && temp->arrkey<heapMaxSize)return &Arr[temp->arrkey];else if(temp->arrkey>=heapMaxSize && temp->arrkey<100) return saveNode[temp->arrkey];}#endif#include "stdafx.h"#include "huffmantree.h"#include <iostream.h>int main(int argc, char* argv[]){char weight[MaxN];int n;cout<<" 字符个数 :";cin >> n;cout<<" 输入一串字符:";for(int i=0;i<n;i++)cin>>weight[i];HuffmanTree <char> a (weight,n);a.HuffmanCode();return 0;}实习题目 6.要求：自己设计图并编码进行存储，同时输出图的两种遍历方式的结果。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》程序设计实习题目
1. 分别以顺序表和单链表作为存储结构，实现将线性表就地逆置的操作。
（所谓“就地逆置”是指辅
助空间为0（1），即利用原表中的结点空间）。
2. 写一程序将单链表中值重复的结点删除，使得表中各结点值均不相同。
3. 已知一单链表中含有两类字符的数据元素（如：字母、数字），试编写程序将该单链表分成两个单链
表，使得每个链表中只含有同一类的字符。
4. 假设有两个按元素值递增有序的单链表A和B,试编写程序将A和B归并成一个按元素值递减有序的
单链表。
5. 利用线性结构（顺序表或链表）实现两个20位大整数的加法运算。
6. 已知两个以顺序结构存储的线性表A和B,试编写程序实现从A表中删除包含在B表中的元素。
7. 已知两个单链表A和B,试编写程序实现从A表中删除包含在B表中的元素。
8. 已知两个以顺序结构存储的线性表A和B,试编写程序实现：将在B表中但不在A表中的元素插入到
A表。
9. 已知两个单链表A和B，试编写程序实现：将在B表中但不在A表中的元素插入到A表。
10. 试编写程序，对任意输入的一个算术表达式，将式中的数字和运算符分成两类（一类是数字，一类是
运算符），并按逆序输出。
（提示：利用栈来实现）
11. 利用栈结构，编写一个程序，对以逆波兰式表示的表达式求值。
12. 编写程序，求得所有包含在串S中而不包含在串T中的字符（S中重复的字符只选一个）构成的新串
R。
13. 编写程序，求任意输入的串S中所含不同字符的总数和每种字符的个数。
14. 一个文本串可用事先给定的字母映射表进行加密。
例如：设字母映射表为：
abcdefghijkl mn opqrstuvwxyz
n g z q t c o b m u hel kpdawxfyi v r s j 则字符串“ encrypt ”被加密为“ tkzwsdf ”。
试写一程序将输入的文本串进行加密后输出。
15. 假设两个10 X 10的稀疏矩阵A和B以三元组表的方式存储，试编写程序实现矩阵的相加运算，其结
果存放在三元组表C中。
16. 对给定的整数序列，建立一棵二叉排序树，并按中序遍历输出树中结点。
17. 编写按层次顺序（同一层自左至右）遍历二叉树的算法。
18. 编写一算法，计算二叉树中叶子结点的数目。
19. 编写一算法，计算二叉树的深度。
20. 对给定的图的邻接矩阵，试编写程序，建立该图的邻接表。
21. 假设一个有向图以邻接矩阵方式存储，试编写程序，求出图中各结点的出度和入度。
22. 实现克鲁斯卡尔算法，求出给定图的最小生成树。
（只需输出各条选中的边）
23. 对一个给定的有向图，编写算法判断它是否是强连通图。
24. 编写算法，实现从二叉排序树中删除一个关键字。
25. 编写程序，实现对索引顺序表的查找。
（即分块查找）
26. 编写程序实现：以“除留余数法”为哈希函数，对任意输入的一批100 以内的整数，构造哈希表，
表长为30。
（注：解决冲突可以用开放定址法）
27. 以单链表为存储结构，实现直接插入排序。
28. 按折半查找的方法，实现直接插入排序。
（即教材中的2-路插入排序）
29. 编写程序，对任意输入的一批数据，建立一个大根堆。
30. 以单链表为存储结构，实现简单选择排序算法。
31. 编写程序，对n 个正、负整数组成的序列进行整理，将所有的负数排到非负数之前。
32. 荷兰国旗问题（三色旗问题）：设有一个仅由红、白、蓝三种颜色的条块组成的条块序列（三种色块
的数目可不同，各色块是任意排列的），试编写一个算法，使得这些条块按红、白、蓝的顺序排好（即所有红色的条块集中在序列前部，白色在中部，蓝色在后部）。
33. 以基数排序的方法，实现对任意输入的一组2 位正整数进行排序。