山东大学数据结构第1-3章作业
数据结构1-3习题答案
试编写程序完成: 15个学生 个学生, 3.2 试编写程序完成:有15个学生,每个学生的 信息包括学号、姓名、性别、年龄、班级和3 信息包括学号、姓名、性别、年龄、班级和3 门课程成绩,从键盘输入15个学生的信息, 15个学生的信息 门课程成绩,从键盘输入15个学生的信息,要 求打印出3门课程的总平均成绩, 求打印出3门课程的总平均成绩,以及最高分 的学生的信息(包括学号、姓名、性别、年龄、 的学生的信息(包括学号、姓名、性别、年龄、 班级、 门课程成绩、平均分)。 班级、3门课程成绩、平均分)。
判断下述计算过程是否是一个算法: 2.4 判断下述计算过程是否是一个算法: Step1: 开始 Step2: n<=0; Step3: n=n+1; 重复步骤3; Step4: 重复步骤3; 结束; Step5: 结束; 该计算过程不是一个算法, 答:该计算过程不是一个算法,因为其不满足算法的 有穷性。 有穷性。
在下面两列中,左侧是算法(关于问题规模) 2.8 在下面两列中,左侧是算法(关于问题规模) 的执行时间,右侧是一些时间复杂度。 的执行时间,右侧是一些时间复杂度。请用连 线的方式表示每个算法的时间复杂度。 线的方式表示每个算法的时间复杂度。 100n3 6n2-12n+1 1024 n+2log2n n(n+1)(n+2)/6 2n+1+100n
线 性 表 存 储 方 式
顺序存储:初始化、插入、删除、 顺序存储:初始化、插入、删除、查找运算
: 存 插入、删除 插入、
存储:初始化、插入、删除、 存储:初始化、插入、 Nhomakorabea除、查找运算
:插入、删除 插入、 存储
存
重点:熟练掌握顺序表和单链表上实现的各种 重点: 基本算法及相关的时间性能分析 难点: 难点:能够使用本章所学到的基本知识设计有 效算法解决与线性表相关的应用问题。 效算法解决与线性表相关的应用问题。
数据结构第三章的习题答案
数据结构第三章的习题答案数据结构第三章的习题答案在学习数据结构的过程中,习题是巩固知识和提高能力的重要方式。
第三章的习题主要涉及线性表、栈和队列的实现和操作。
本文将对这些习题进行解答,并给出详细的步骤和思路。
1. 第一题要求实现一个线性表的插入操作。
线性表是一种常用的数据结构,它的特点是元素之间存在一对一的关系。
要实现插入操作,首先需要定义线性表的数据结构,可以使用数组或链表来实现。
然后,根据插入位置,将插入位置之后的元素依次后移,为要插入的元素腾出空间。
最后,将要插入的元素放入插入位置。
2. 第二题要求实现一个栈的压栈和出栈操作。
栈是一种后进先出(LIFO)的数据结构,可以使用数组或链表来实现。
压栈操作就是将元素放入栈顶,出栈操作就是将栈顶元素取出并删除。
要实现这两个操作,可以使用一个指针来指示栈顶位置,每次压栈时将指针加一,出栈时将指针减一。
需要注意的是,栈满时不能再进行压栈操作,栈空时不能进行出栈操作。
3. 第三题要求实现一个队列的入队和出队操作。
队列是一种先进先出(FIFO)的数据结构,同样可以使用数组或链表来实现。
入队操作就是将元素放入队尾,出队操作就是将队头元素取出并删除。
与栈不同的是,队列需要维护队头和队尾两个指针。
每次入队时将元素放入队尾,并将队尾指针后移一位;出队时将队头元素取出,并将队头指针后移一位。
需要注意的是,队列满时不能再进行入队操作,队列空时不能进行出队操作。
4. 第四题要求实现一个栈的括号匹配算法。
括号匹配是一种常见的应用场景,例如编程语言中的括号匹配。
要实现这个算法,可以使用栈来辅助。
遍历字符串中的每个字符,如果是左括号,则将其压入栈中;如果是右括号,则将栈顶元素取出并判断是否与右括号匹配。
如果匹配,则继续遍历下一个字符;如果不匹配,则说明括号不匹配,返回错误。
最后,如果栈为空,则说明括号匹配成功;如果栈不为空,则说明括号不匹配,返回错误。
5. 第五题要求使用栈实现一个逆波兰表达式的计算器。
数据结构第一章课后习题与答案资料
数据结构第一章课后习题与答案资料1.什么是数据结构?答:数据结构是指数据对象以及数据对象之间的关系、操作和约束的一种逻辑结构。
它关注如何将数据以及数据之间的关系组织起来,以便更高效地进行操作和使用。
2.数据结构的分类有哪些?答:数据结构可以分为线性数据结构和非线性数据结构。
线性数据结构包括数组、链表、栈和队列;非线性数据结构包括树和图。
3.什么是算法?答:算法是指解决特定问题的一系列步骤和规则。
它可以描述为一个有限的指令集,用于将输入数据转换为输出结果。
4.算法的特征有哪些?答:算法具有以下特征:•输入:算法必须有输入,可以是零个或多个。
•输出:算法必须有输出,可以是零个或多个。
•有穷性:算法必须在有限步骤内结束。
•确定性:算法的每一步骤必须明确且无歧义。
•可行性:算法的每一步骤必须可行,即可以执行。
5.算法的时间复杂度是什么?如何表示时间复杂度?答:算法的时间复杂度是指算法执行所需的时间。
它通常用大O符号表示。
常见的时间复杂度有O(1)、O(n)、O(n^2)等。
6.算法的空间复杂度是什么?如何表示空间复杂度?答:算法的空间复杂度是指算法执行所需的额外空间。
它通常用大O符号表示。
常见的空间复杂度有O(1)、O(n)、O(n^2)等。
7.什么是数据的逻辑结构?答:数据的逻辑结构是指数据对象之间的关系。
常见的逻辑结构有线性结构、树形结构和图形结构。
8.什么是数据的存储结构?答:数据的存储结构是指数据在计算机内存中的表示方式。
常见的存储结构有顺序存储结构和链式存储结构。
9.顺序存储结构和链式存储结构有什么区别?答:顺序存储结构将数据存储在一块连续的内存空间中,可以随机访问元素,但插入和删除操作需要移动大量元素。
链式存储结构将数据存储在不连续的内存空间中,通过指针相连,插入和删除操作只需要修改指针,但访问元素需要遍历链表。
10.数组和链表的区别是什么?答:数组是一种顺序存储结构,元素在内存中连续存储,可以通过下标直接访问元素;链表是一种链式存储结构,元素在内存中不连续存储,通过指针相连。
2020年山东大学网络教育数据结构作业及答案
2020年山东大学数据结构课后作业答案山东大学继续(网络)教育学院---数据结构课后作业答案一、单选题(共20题,50.0分)1、在一个长度为n的顺序表的任一位置插入一个新元素的渐进时间复杂度为()。
A、O(n)B、O(n/2)C、O(1)D、O(n2)我的答案:A得分:2.5分2、带头结点的单链表first为空的判定条件是:()。
A、first == NULL;B、first->link == NULL;C、first->link == first;D、first != NULL;我的答案:B得分:2.5分3、从逻辑上可以把数据结构分为()两大类。
A、动态结构、静态结构B、顺序结构、链式结构C、线性结构、非线性结构D、初等结构、构造型结构我的答案:B得分:2.5分4、在系统实现递归调用时需利用递归工作记录保存实际参数的值。
在传值参数情形,需为对应形式参数分配空间,以存放实际参数的副本;在引用参数情形,需保存实际参数的(),在被调用程序中可直接操纵实际参数。
A、空间B、副本C、返回地址D、地址我的答案:D得分:2.5分5、以下数据结构中,哪一个是线性结构()。
A、广义表B、二叉树C、稀疏矩阵D、串6、以下属于逻辑结构的是()。
A、顺序表B、哈希表C、有序表D、单链表我的答案:C得分:2.5分7、对于长度为9的有序顺序表,若采用折半搜索,在等概率情况下搜索成功的平均搜索长度为()的值除以9。
A、20B、18C、25D、22我的答案:C得分:2.5分8、在有向图中每个顶点的度等于该顶点的()。
A、入度B、出度C、入度与出度之和D、入度与出度之差我的答案:C得分:2.5分9、在基于排序码比较的排序算法中,()算法的最坏情况下的时间复杂度不高于O(nlog2n)。
A、起泡排序B、希尔排序C、归并排序D、快速排序我的答案:C得分:2.5分10、当α的值较小时,散列存储通常比其他存储方式具有()的查找速度。
数据结构1-4章习题答案
第一章绪论一、选择题1.D2.C3.C4.B5.D6.C7.D8.C9.A 10.D11.D 12.B二、填空题1. 逻辑结构存储结构运算2. 集合结构线性结构树形结构图状结构3. 有穷性. 确定性. 可行性. 输入. 输出4. 顺序存储. 链式存储5. 数据元素6. 线性结构非线性结构三、简答题1. 尽管算法的含义与程序非常相似,但两者还是有区别的。
首先,一个程序不一定满有穷性,因为它不是一个算法。
其次,程序中的指令必须是计算机可以执行的,而算法中的指令却无此限制。
如果一个算法采用机器可执行的语言来书写,那么它就是一个程序。
2. 数据结构是指数据对象以及该数据对象集合中的数据元素之间的相互关系(数据元素的组织形式)。
例如:队列的逻辑结构是线性表(先进后出);队列在计算机中既可以采用顺序存储也可以采用链式存储;队列可进行删除数据元素. 插入数据元素. 判断是否为空队列,以及队列置空等操作。
3. 数据元素之间的逻辑关系,也称为数据的逻辑结构。
数据元素以及它们之间的相互关系在计算机存储器内的表示(又称映像)称为数据的存储结构,也称数据的物理结构。
4. 算法是对特定问题求解步骤的一种描述,它是指令的有限序列,其中每一条指令表示一个或者多个操作。
此外,一个算法还具有下列5个特性:(1)有穷性:一个算法必须在执行有穷步之后结束,即算法必须在有限时间内完成。
(2)确定性:算法中每一步必须有明确的含义,不会产生二义性。
并且,在任何条件下,算法只有唯一的一条执行路径,即对于相同的输入只能得出相同的输出。
(3)可行性:一个算法是能执行的,即算法中的每一步都可以通过已经实现的基本运算执行有限次得以实现。
(4)输入:一个算法有零个或者多个输入,它们是算法开始时对算法给出的初始量。
(5)输出:一个算法有一个或者多个输出,它们是与输入有特定关系的量5. 举例说明四种基本结构的区别:集合: 数据元素之间无任何关系,如集合A={x,5,t,&};线性结构: 数据元素之间存在一个对一个的关系,如线性表L=(2,3,4,5,7,10);树形结构: 数据元素之间存在一个对多个的关系,如文件系统目录管理;图状结构: 数据元素之间存在多个对多个的关系,如教学计划课程安排顺序图。
数据结构第1-3章作业参考答案
数据结构第1~3章作业参考答案【1.4】【解法一】⑴抽象数据类型复数:ADT Complex{数据对象:D={ci|ci∈R, i=1,2, 其中R为实数集}数据关系:R={<c1,c2>| ci∈D, i=1,2, 其中c1为复数实部, c2为复数虚部}基本操作:InitComplex (&C,v1,v2)操作结果:构造一个复数C,元素c1, c2分别被赋以参数v1, v2的值。
DestroyComplex(&C)初始条件:复数C已存在。
操作结果:销毁复数C。
GetReal(C, &e)初始条件:复数C已存在。
操作结果:用e返回复数C实部的值。
Get Imaginary(C, &e)初始条件:复数C已存在。
操作结果:用e返回复数C虚部的值。
SetReal(&C, e)初始条件:复数C已存在。
操作结果:用e更新复数C实部的值。
Set Imaginary(&C, e)初始条件:复数C已存在。
操作结果:用e更新复数C虚部的值。
AdditionComplex (&C, C1, C2)初始条件:复数C1,C2已存在。
操作结果:复数C1与复数C2相加,用复数C返回其和。
SubstractComplex(&C, C1, C2)初始条件:复数C1,C2已存在。
操作结果:复数C1减去复数C2,用复数C返回其差。
MultipleComplex(&C, C1, C2 )初始条件:复数C1,C2已存在。
操作结果:复数C1与复数C2相乘,用复数C返回其积。
DividedComplex(&C, C1, C2)初始条件:复数C1,C2已存在,且C2≠0。
操作结果:复数C1除以复数C2,用复数C返回其商。
ModulusComplex(C, &e)初始条件:复数C已存在。
操作结果:求复数C的模,用e返回。
ConjugateComplex(&C, C1)初始条件:复数C1已存在。
数据结构第1章习题解答
第1章习题解答1.1什么是数据结构?一个数据结构结构的二元组定义形式是什么样的?举例解释其含义。
[解答]概括地说,数据结构是互相有关联的数据元素的集合。
也就是说,数据结构是由某个数据元素的集合和该集合中的数据元素之间的关系组成的,因此数据结构可以用一个二元组来表示。
例如,B=(D,R),其中D是某一数据元素的集合,R是D上的关系的有限集。
R所表示的是集合D的数据元素之间的逻辑关系,它表示的可能是数据元素之间客观存在的某种联系,也可能是为了处理问题的需要而人为组织的数据元素之间的某种关系,因此,称之为数据的逻辑结构。
例如,一个农历节气表,就构成了一个数据结构,其数据元素是一年的农历二十四节气,数据元素之间的关系是节气的时间先后关系。
又如,一个某年级学生的成绩排序表,也是一个数据结构,其数据元素是包含成绩项的该年级的学生记录,数据元素之间的关系是学生之间的成绩高低关系。
为了在计算机中进行数据处理,必须把从实际问题中抽象出来的数据的逻辑结构映象到计算机的存储器中,即要把抽象出来的数据元素集合D 和数据元素之间的关系存储到计算机的存储器中,称之为数据的物理结构或存储结构,它是数据的逻辑结构在计算机中的表示。
1.2假设R是集合M上的一个关系,R的定义是什么?对实际问题而言,其含义是什么?[解答]如果R是对集合M自身的笛卡尔积所取的一个子集,那么我们就说“R是集合M上的一个关系”。
对实际问题而言,它表示的是集合M中元素的某种相关性。
例如,对于参加一个羽毛球比赛的运动员集合,可以用一个二元关系表示出各场比赛的胜负关系。
对于一组课程的集合,可以用一个二元关系表示出各门课程之间的先修和后续关系等等。
1.3设有集合M={d1,d2,d3,d4,d5}上的一个关R={(d1,d2),(d2,d4),(d4,d5),(d2,d5),(d1,d4),(d1,d5),(d3,d5),(d1,d3)},试说明关系R具有什么样的性质。
山大-数据结构习题
第3章数据结构3.1数据结构的基本概念一、部分例题及解题思路选择题1.数据结构是指()。
A.数据元素的组织形式B.数据类型C.数据存储结构D.数据定义2.数据在计算机存储器内表示时,物理地址与逻辑地址不相同的,称之为()。
A.存储结构B.逻辑结构C.链式存储结构D.顺序存储结构3.树形结构是数据元素之间存在一种()。
A.一对一关系B.多对多关系C.多对一关系D.一对多关系4.设语句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)5.算法分析的目的是(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-4章习题答案
数据结构1-4章习题答案一、名词解释抽象数据类型、数据结构、数据结构的逻辑结构、数据结构的物理结构、算法、算法评价、时间复杂度、大O表示法、线性表、栈、队列、广义表、稀疏矩阵二、填空1、抽象数据类型是由一组数据结构和在该组数据结构上的一组操作所组成。
2、在定义某种数据结构时,其数据域的数据类型可分为简单类型和结构体类型两种,为增强其通用性,应将其再定义为通用数据类型。
3、如果将线性数据结构关系描述为1:1,那么树型和图型数据结构应分别为1:N、M:N5、算法应具备以下5个特性:有穷性、正确性、可行性、输入和输出。
6、在分析各种算法的时间复杂度时,一般只讨论相应的数量级,用f(n)表示,请问其中n的含义是处理问题的样本量7、对于一个以顺序实现的循环队列Q[m],队首、队尾指针分别为f 和r,其盘空的条件是f=r,盘满的条件是(r+1)%m=f8、循环链表的主要优点是最大限度的利用空间9、链表对于数据元素的插入和删除不需要移动结点,只需改变相关结点的指针域的值。
10、在一个链式栈中,若栈顶指针等于NULL,则为空栈11、主程序第一次调用递归函数被称为外部调用,递归函数自己调用自己被称为内部调用,它们都需要利用栈保存调用后的返回地址地址。
12、某算法在求解一个10阶方程组时,运算次数是500,求解一个30阶方程组时,运算次数是4500,则该算法的时间复杂度为O(N2)三、选择题1、对一个线性表的存取操作很少,而插入和删除操作较多时应采用B存储结构。
A.顺序存储B.链式存储C.索引存储D.散列式存储2、对一个线性表的随机存取操作较多时,应采用B存储结构。
A.静态顺序存储B.动态顺序存储C.动态链接存储D.静态链接存储3、对一个顺序存储结构的栈,栈满的判断条件是(D)A.S.top==-1B.S.top==0C.S.top==Ma某SizeD.S.top==Ma某Size-14、若循环队列有n个顺序存储单元,front、rear分别为队首和队尾指针则判断队满的条件是(C)A.(front+1)%n==rearB.(front-1)%n==rearC.(rear+1)%n==frontD.(rear-1)%n==front5、下列是顺序存储线性表排序的算法voidSort(Lit&L){}问:此算法的时间复杂性为:BA.O(n)B.(n2)C.(n某i)D.(n某j) inti,j;ElemType某;for(i=1;i某=L.lit[i];for(j=i-1;j>=0;j--)if(某L.lit[j+1]=L.lit[j];elebreak;L.lit[j+1]=某;四、简答题1、简述线性表的顺序存储和链接存储实现的异同。
数据结构 第3章答案(已核)
数据结构第3章答案(已核)数据结构第3章答案(已核)数据结构是计算机科学中非常重要的一门课程,它研究如何组织和存储数据,以便于高效地访问和处理。
在第3章中,我们学习了一些与树相关的重要概念和算法。
本文将对该章节的内容进行总结和解答。
一、树(Tree)树是一种非线性的数据结构,它由一组节点(Node)和一组连接这些节点的边(Edge)组成。
树的一个节点被称为根节点,它没有父节点;其他节点可以有一个或多个子节点。
树的每个节点除了根节点外都有且只有一个父节点。
树有许多种类,如二叉树、平衡树等。
二、二叉树(Binary Tree)二叉树是一种特殊的树结构,每个节点最多有两个子节点,分别称为左子节点和右子节点。
在二叉树中,左子树和右子树也是二叉树。
二叉树有许多重要的性质和应用,比如二叉搜索树、平衡二叉树等。
三、二叉搜索树(Binary Search Tree)二叉搜索树是一种特殊的二叉树,它的左子树中的所有节点的值都小于根节点的值,而右子树中的所有节点的值都大于根节点的值。
这个特性使得在二叉搜索树中进行插入、删除和查找操作非常高效。
四、平衡二叉树(AVL Tree)平衡二叉树也是一种特殊的二叉搜索树,它的左子树和右子树的高度差不超过1。
通过对插入和删除操作进行树的旋转,可以保持平衡二叉树的平衡性,使得操作的时间复杂度保持在O(log n)。
五、堆(Heap)堆是一种特殊的树结构,它可以分为最大堆和最小堆。
最大堆中,父节点的值大于等于子节点的值;最小堆中,父节点的值小于等于子节点的值。
堆常用于实现优先队列等数据结构,有助于高效地找出最大或最小元素。
六、哈夫曼树(Huffman Tree)哈夫曼树是一种特殊的二叉树,用于实现哈夫曼编码。
在哈夫曼树中,频率较高的字符具有较短的编码,而频率较低的字符具有较长的编码。
哈夫曼树常用于数据压缩领域,可以有效地减少数据的存储空间。
七、图(Graph)图是一种复杂的数据结构,它由节点和连接节点的边组成。
数据结构(C语言版)第一二章习题答案
抽出时间去学习,凡事从小做起,不怕单调和重复,长期的积累坚持,想不成功,也难。
第1章绪论习题1.简述下列概念:数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型2.试举一个数据结构的例子叙述其逻辑结构和存储结构两方面的含义和相互关系3.简述逻辑结构的四种基本关系并画出它们的关系图4.存储结构由哪两种基本的存储方法实现?5.选择题(1)在数据结构中从逻辑上可以把数据结构分成()A.动态结构和静态结构 B.紧凑结构和非紧凑结构C.线性结构和非线性结构 D.内部结构和外部结构(2)与数据元素本身的形式、内容、相对位置、个数无关的是数据的()A.存储结构 B.存储实现C.逻辑结构 D.运算实现(3)通常要求同一逻辑结构中的所有数据元素具有相同的特性这意味着()A.数据具有同一特点B.不仅数据元素所包含的数据项的个数要相同而且对应数据项的类型要一致C.每个数据元素都一样D.数据元素所包含的数据项的个数要相等(4)以下说法正确的是()A.数据元素是数据的最小单位B.数据项是数据的基本单位C.数据结构是带有结构的各数据项的集合D.一些表面上很不相同的数据可以有相同的逻辑结构(5)以下与数据的存储结构无关的术语是()A.顺序队列 B. 链表 C. 有序表 D. 链栈(6)以下数据结构中()是非线性数据结构A.树 B.字符串 C.队 D.栈6.试分析下面各程序段的时间复杂度(1)x=90; y=100;while(y>0)if(x>100){x=x-10;y--;}else x++;(2)for (i=0; i<n; i++)for (j=0; j<m; j++)a[i][j]=0;(3)s=0;for i=0; i<n; i++)for(j=0; j<n; j++)s+=B[i][j];sum=s;(4)i=1;while(i<=n)i=i*3;(5)x=0;for(i=1; i<n; i++)for (j=1; j<=n-i; j++)x++;(6)x=n; //n>1y=0;while(x≥(y+1)* (y+1))y++;(1)O(1)(2)O(m*n)(3)O(n2)(4)O(log3n)(5)因为x++共执行了n-1+n-2+......+1= n(n-1)/2所以执行时间为O(n2)(6)O()第2章线性表1.选择题(1)一个向量第一个元素的存储地址是100每个元素的长度为2则第5个元素的地址是()A.110 B.108 C.100 D.120 (2)在n个结点的顺序表中算法的时间复杂度是O(1)的操作是()A.访问第i个结点(1≤i≤n)和求第i个结点的直接前驱(2≤i≤n)B.在第i个结点后插入一个新结点(1≤i≤n)C.删除第i个结点(1≤i≤n)D.将n个结点从小到大排序(3)向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变平均要移动的元素个数为()A.8 B.63.5 C.63 D.7(4)链接存储的存储结构所占存储空间()A.分两部分一部分存放结点值另一部分存放表示结点间关系的指针B.只有一部分存放结点值C.只有一部分存储表示结点间关系的指针D.分两部分一部分存放结点值另一部分存放结点所占单元数(5)线性表若采用链式存储结构时要求内存中可用存储单元的地址()A.必须是连续的 B.部分地址必须是连续的C.一定是不连续的 D.连续或不连续都可以(6)线性表L在()情况下适用于使用链式结构实现A.需经常修改L中的结点值B.需不断对L进行删除插入C.L中含有大量的结点D.L中结点结构复杂(7)单链表的存储密度()A.大于1 B.等于1 C.小于1 D.不能确定(8)将两个各有n个元素的有序表归并成一个有序表其最少的比较次数是()A.n B.2n-1 C.2n D.n-1(9)在一个长度为n的顺序表中在第i个元素(1≤i≤n+1)之前插入一个新元素时须向后移动()个元素A.n-i B.n-i+1 C.n-i-1 D.i(10) 线性表L=(a1a2......an)下列说法正确的是()A.每个元素都有一个直接前驱和一个直接后继B.线性表中至少有一个元素C.表中诸元素的排列必须是由小到大或由大到小D.除第一个和最后一个元素外其余每个元素都有一个且仅有一个直接前驱和直接后继(11) 若指定有n个元素的向量则建立一个有序单链表的时间复杂性的量级是()A.O(1) B.O(n) C.O(n2) D.O(nlog2n)(12) 以下说法错误的是()A.求表长、定位这两种运算在采用顺序存储结构时实现的效率不比采用链式存储结构时实现的效率低B.顺序存储的线性表可以随机存取C.由于顺序存储要求连续的存储区域所以在存储管理上不够灵活D.线性表的链式存储结构优于顺序存储结构(13) 在单链表中要将s所指结点插入到p所指结点之后其语句应为()A.s->next=p+1; p->next=s;B.(*p).next=s; (*s).next=(*p).next;C.s->next=p->next; p->next=s->next;D.s->next=p->next; p->next=s;(14) 在双向链表存储结构中删除p所指的结点时须修改指针()A.p->next->prior=p->prior; p->prior->next=p->next;B.p->next=p->next->next; p->next->prior=p;C.p->prior->next=p; p->prior=p->prior->prior;D.p->prior=p->next->next; p->next=p->prior->prior;(15) 在双向循环链表中在p指针所指的结点后插入q所指向的新结点其修改指针的操作是()A.p->next=q; q->prior=p; p->next->prior=q; q->next=q;B.p->next=q; p->next->prior=q; q->prior=p; q->next=p->next;C.q->prior=p; q->next=p->next; p->next->prior=q; p->next=q;D.q->prior=p; q->next=p->next; p->next=q; p->next->prior=q;2.算法设计题(1)将两个递增的有序链表合并为一个递增的有序链表要求结果链表仍使用原来两个链表的存储空间不另外占用其它的存储空间表中不允许有重复的数据void MergeList_L(LinkList &LaLinkList &LbLinkList &Lc){pa=La->next; pb=Lb->next;Lc=pc=La; //用La的头结点作为Lc的头结点while(pa && pb){if(pa->data<pb->data){ pc->next=pa;pc=pa;pa=pa->next;}else if(pa->data>pb->data) {pc->next=pb; pc=pb; pb=pb->next;} else {// 相等时取La的元素删除Lb的元素pc->next=pa;pc=pa;pa=pa->next;q=pb->next;delete pb ;pb =q;}}pc->next=pa?pa:pb; //插入剩余段delete Lb; //释放Lb的头结点}(2)将两个非递减的有序链表合并为一个非递增的有序链表要求结果链表仍使用原来两个链表的存储空间不另外占用其它的存储空间表中允许有重复的数据void union(LinkList& LaLinkList& LbLinkList& Lc) {pa = La->next; pb = Lb->next; // 初始化Lc=pc=La; //用La的头结点作为Lc的头结点Lc->next = NULL;while ( pa || pb ) {if ( !pa ) { q = pb; pb = pb->next; }else if ( !pb ) { q = pa; pa = pa->next; }else if (pa->data <= pb->data ) { q = pa; pa = pa->next; } else { q = pb; pb = pb->next; }q->next = Lc->next; Lc->next = q; // 插入}delete Lb; //释放Lb的头结点}(3)已知两个链表A和B分别表示两个集合其元素递增排列请设计算法求出A与B的交集并存放于A链表中void Mix(LinkList& LaLinkList& LbLinkList& Lc) {pa=la->next;pb=lb->next;∥设工作指针pa和pb;Lc=pc=La; //用La的头结点作为Lc的头结点while(pa&&pb)if(pa->data==pb->data)∥交集并入结果表中{ pc->next=pa;pc=pa;pa=pa->next;u=pb;pb=pb->next; delete u;}else if(pa->data<pb->data) {u=pa;pa=pa->next; delete u;} else {u=pb; pb=pb->next; delete u;}while(pa){ u=pa; pa=pa->next; delete u;}∥释放结点空间while(pb) {u=pb; pb=pb->next; delete u;}∥释放结点空间pc->next=null;∥置链表尾标记delete Lb; ∥注:本算法中也可对B表不作释放空间的处理(4)已知两个链表A和B分别表示两个集合其元素递增排列请设计算法求出两个集合A和B 的差集(即仅由在A中出现而不在B中出现的元素所构成的集合)并以同样的形式存储同时返回该集合的元素个数void Difference(LinkedList AB*n)∥A和B均是带头结点的递增有序的单链表分别存储了一个集合本算法求两集合的差集存储于单链表A中*n是结果集合中元素个数调用时为0{p=A->next;∥p和q分别是链表A和B的工作指针q=B->next; pre=A;∥pre为A中p所指结点的前驱结点的指针while(p!=null && q!=null)if(p->data<q->data){pre=p;p=p->next;*n++;} ∥ A链表中当前结点指针后移else if(p->data>q->data)q=q->next;∥B链表中当前结点指针后移else {pre->next=p->next;∥处理AB中元素值相同的结点应删除u=p; p=p->next; delete u;} ∥删除结点(5)设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C其中B表的结点为A表中值小于零的结点而C表的结点为A表中值大于零的结点(链表A的元素类型为整型要求B、C表利用A表的结点)(6)设计一个算法通过一趟遍历在单链表中确定值最大的结点ElemType Max (LinkList L ){if(L->next==NULL) return NULL;pmax=L->next; //假定第一个结点中数据具有最大值p=L->next->next;while(p != NULL ){//如果下一个结点存在if(p->data > pmax->data) pmax=p;p=p->next;}return pmax->data;(7)设计一个算法通过遍历一趟将链表中所有结点的链接方向逆转仍利用原表的存储空间void inverse(LinkList &L) {// 逆置带头结点的单链表 Lp=L->next; L->next=NULL;while ( p) {q=p->next; // q指向*p的后继p->next=L->next;L->next=p; // *p插入在头结点之后p = q;}}(8)设计一个算法删除递增有序链表中值大于mink且小于maxk的所有元素(mink和maxk是给定的两个参数其值可以和表中的元素相同也可以不同)void delete(LinkList &Lint minkint maxk) {p=L->next; //首元结点while (p && p->data<=mink){ pre=p; p=p->next; } //查找第一个值>mink的结点 if (p) {while (p && p->data<maxk) p=p->next;// 查找第一个值≥maxk 的结点q=pre->next; pre->next=p; // 修改指针while (q!=p){ s=q->next; delete q; q=s; } // 释放结点空间 }//if}(9)已知p指向双向循环链表中的一个结点其结点结构为data、prior、next三个域写出算法change(p)交换p所指向的结点和它的前缀结点的顺序知道双向循环链表中的一个结点与前驱交换涉及到四个结点(p结点前驱结点前驱的前驱结点后继结点)六条链void Exchange(LinkedList p)∥p是双向循环链表中的一个结点本算法将p所指结点与其前驱结点交换{q=p->llink;q->llink->rlink=p;∥p的前驱的前驱之后继为pp->llink=q->llink;∥p的前驱指向其前驱的前驱q->rlink=p->rlink;∥p的前驱的后继为p的后继q->llink=p;∥p与其前驱交换p->rlink->llink=q;∥p的后继的前驱指向原p的前驱p->rlink=q;∥p的后继指向其原来的前驱}∥算法exchange结束(10)已知长度为n的线性表A采用顺序存储结构请写一时间复杂度为O(n)、空间复杂度为O(1)的算法该算法删除线性表中所有值为item的数据元素[题目分析] 在顺序存储的线性表上删除元素通常要涉及到一系列元素的移动(删第i个元素第i+1至第n个元素要依次前移)本题要求删除线性表中所有值为item的数据元素并未要求元素间的相对位置不变因此可以考虑设头尾两个指针(i=1j=n)从两端向中间移动凡遇到值item的数据元素时直接将右端元素左移至值为item的数据元素位置void Delete(ElemType A[ ]int n)∥A是有n个元素的一维数组本算法删除A中所有值为item的元素{i=1;j=n;∥设置数组低、高端指针(下标)while(i<j){while(i<j && A[i]!=item)i++;∥若值不为item左移指针if(i<j)while(i<j && A[j]==item)j--;∥若右端元素值为item 指针左移if(i<j)A[i++]=A[j--];}[算法讨论] 因元素只扫描一趟算法时间复杂度为O(n)删除元素未使用其它辅助空间最后线性表中的元素个数是j。
数据结构(山东联盟) 智慧树网课章节测试答案
1、选择题:算法的时间复杂度取决于。
选项:A:选择题的规模B:待处理选择题的初态C:选择题的难度D:A 和B答案: 【选择题的规模】2、选择题:数据在计算机内存中的表示是指()选项:A:数据的存储结构B:数据结构C:数据的逻辑结构D:数据元素之间的关系答案: 【数据的存储结构】3、选择题:算法指的是()选项:A:计算机程序B:解决选择题的计算方法C:排序算法D:解决选择题的有限运算序列答案: 【解决选择题的有限运算序列】4、选择题:在数据结构中,与所使用的计算机无关的数据结构是()选项:A:逻辑B:存储C:逻辑和存储D:物理答案: 【逻辑】7、选择题:某线性表采用顺序存储结构,每个元素占4个存储章,首地址为100,则第12个元素的存储地址为( )。
选项:A:144B:145C:147D:148答案: 【144】8、选择题:算法能正确地实现预定功能的特性称为算法的()。
选项:A:正确性B:可读性C:健壮性D:高效性答案: 【正确性】1、选择题:链表不具备的特点是()。
选项:A:可随机访问任意一个结点B:插入和删除不需要移动任何元素C:不必事先估计存储空间D:所需空间与其长度成正比答案: 【可随机访问任意一个结点】3、选择题:线性表的顺序存储表示优于链式存储表示。
选项:A:对B:错答案: 【错】4、选择题:顺序存储结构的缺点是不便于修改,插入和删除需要移动很多结点。
选项:A:对B:错答案: 【对】5、选择题:在设头、尾指针的单链表中,与长度n有关的操作是( )。
选项:A:删除第一个结点B:删除最后一个结点C:在第一个结点之前插入一个结点D:在p结点之后插入一个结点答案: 【删除最后一个结点】6、选择题:设指针q指向单链表中结点A,指针p指向单链表中结点A的后继结点B,指针s指向被插入的结点X,则在结点A和结点B间插入结点X的操作序列为( )。
选项:A:s->next=p->next;p->next=-s;B:q->next=s; s->next=p;C:p->next=s->next;s->next=p;D:p->next=s;s->next=q;答案: 【q->next=s; s->next=p;】7、选择题:对于只在表的首、尾两端进行插入操作的线性表,宜采用的存储结构为( )。
《数据结构》教材课后习题+答案
《数据结构》教材课后习题+答案数据结构第一章介绍数据结构是计算机科学中重要的概念,它涉及到组织和存储数据的方法和技术。
数据结构的选择对于算法的效率有着重要的影响。
本教材为读者提供了丰富的课后习题,以帮助读者巩固所学知识并提高解决问题的能力。
下面是一些选定的习题及其答案,供读者参考。
第二章线性表习题一:给定一个顺序表L,编写一个算法,实现将其中元素逆置的功能。
答案一:算法思路:1. 初始化两个指针i和j,分别指向线性表L的首尾两个元素2. 对于L中的每一个元素,通过交换i和j所指向的元素,将元素逆置3. 当i>=j时,停止逆置算法实现:```pythondef reverse_list(L):i, j = 0, len(L)-1while i < j:L[i], L[j] = L[j], L[i]i += 1j -= 1```习题二:给定两个线性表A和B,编写一个算法,将线性表B中的元素按顺序插入到线性表A中。
答案二:算法思路:1. 遍历线性表B中的每一个元素2. 将B中的元素依次插入到A的末尾算法实现:```pythondef merge_lists(A, B):for element in B:A.append(element)```第三章栈和队列习题一:编写一个算法,判断一个表达式中的括号是否匹配。
表达式中的括号包括小括号"()"、中括号"[]"和大括号"{}"。
答案一:算法思路:1. 遍历表达式中的每一个字符2. 当遇到左括号时,将其推入栈中3. 当遇到右括号时,判断栈顶元素是否与其匹配4. 当遇到其他字符时,继续遍历下一个字符5. 最后判断栈是否为空,若为空则表示括号匹配算法实现:```pythondef is_matching(expression):stack = []for char in expression:if char in "([{":stack.append(char)elif char in ")]}":if not stack:return Falseelif (char == ")" and stack[-1] == "(") or (char == "]" and stack[-1] == "[") or (char == "}" and stack[-1] == "{"):stack.pop()else:return Falsereturn not stack```习题二:利用两个栈实现一个队列。
数据结构1-5章习题参考答案
第1章绪论一、填空题01、【操作对象】【关系和运算】02、【数据元素】【关系】03、【逻辑结构】【存储结构】【运算】04、【线性结构】【非线性结构】05、【一对一】【一对多】【多对多】06、【没有】【没有】07、【前驱】【1】【后续】【任意多个】08、【任意多个】09、【顺序】【链式】【索引】【散列】10、【集合】【线性结构】【树形结构】【图状结构】11、【插入】【删除】【修改】【查找】【排序】12、【时间】【空间】13、【时间复杂度】【空间复杂度】14、【映射】15、【有穷性】【确定性】【可行性】16、【n+1】【n】【n(n+3)/2】【n(n+1)/2】17、【n(n+1)(n+2)/6】【O(n3)】18、【O(n2 log)】19、【O(nn2 log)】20、【O(22log n)】21、【(n+3)(n-2)/2】22、【n(n-1)/2】二、判断题01-05、×××√×06-10、×√×××11-12、√×三、单项选择题B01 BD02 A03 C04 C05A06 C07 B08 A09 C10B11 A12 C13 D14 A15C16四、分析下面各程序段的时间复杂度01、O(nm )02、O(2n)03、答:O(2n)04、答:O(n3 log)五、设有数据逻辑结构S=(D,R),试按各小题所给条件画出这些逻辑结构的图示,并确定相对于关系R,哪些结点是开始结点,哪些结点是终端结点?01、此图为线性结构d1→d2→d3→d4d1—无直接前驱,是首结点d4—无直接后继是尾结点02、此图为树形结构d1—无直接前驱,是根结点d2,d5,d7,d9—无直接后继是叶子结点03、此图为图形结构d1,d2—无直接前驱,是开始结点d6,d7—无直接后继是终端结点六、简述题01、什么是数据结构?答:数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和运算等的学科。
数据结构习题及答案-第1章 绪论
第1章绪论一、选择题1. 算法的计算量的大小称为计算的()。
【北京邮电大学2000 二、3 (20/8分)】A.效率 B. 复杂性 C. 现实性 D. 难度2. 算法的时间复杂度取决于()【中科院计算所 1998 二、1 (2分)】A.问题的规模 B. 待处理数据的初态 C. A和B3.计算机算法指的是(1),它必须具备(2)这三个特性。
(1) A.计算方法 B. 排序方法 C. 解决问题的步骤序列 D. 调度方法(2) A.可执行性、可移植性、可扩充性 B. 可执行性、确定性、有穷性C. 确定性、有穷性、稳定性D. 易读性、稳定性、安全性【南京理工大学 1999 一、1(2分)【武汉交通科技大学 1996 一、1( 4分)】4.一个算法应该是()。
【中山大学 1998 二、1(2分)】A.程序 B.问题求解步骤的描述 C.要满足五个基本特性 D.A和C.5. 下面关于算法说法错误的是()【南京理工大学 2000 一、1(1.5分)】A.算法最终必须由计算机程序实现B.为解决某问题的算法同为该问题编写的程序含义是相同的C. 算法的可行性是指指令不能有二义性D. 以上几个都是错误的6. 下面说法错误的是()【南京理工大学 2000 一、2 (1.5分)】(1)算法原地工作的含义是指不需要任何额外的辅助空间(2)在相同的规模n下,复杂度O(n)的算法在时间上总是优于复杂度O(2n)的算法(3)所谓时间复杂度是指最坏情况下,估算算法执行时间的一个上界(4)同一个算法,实现语言的级别越高,执行效率就越低A.(1) B.(1),(2) C.(1),(4) D.(3)7.从逻辑上可以把数据结构分为()两大类。
【武汉交通科技大学 1996 一、4(2分)】A.动态结构、静态结构 B.顺序结构、链式结构C.线性结构、非线性结构 D.初等结构、构造型结构8.以下与数据的存储结构无关的术语是()。
【北方交通大学 2000 二、1(2分)】A.循环队列 B. 链表 C. 哈希表 D. 栈9.以下数据结构中,哪一个是线性结构()?【北方交通大学 2001 一、1(2分)】A.广义表 B. 二叉树 C. 稀疏矩阵 D. 串10.以下那一个术语与数据的存储结构无关?()【北方交通大学 2001 一、2(2分)】A.栈 B. 哈希表 C. 线索树 D. 双向链表11.在下面的程序段中,对x的赋值语句的频度为()【北京工商大学 2001 一、10(3分)】FOR i:=1 TO n DOFOR j:=1 TO n DOx:=x+1;A. O(2n) B.O(n) C.O(n2) D.O(log2n)12.程序段 FOR i:=n-1 DOWNTO 1 DOFOR j:=1 TO i DOIF A[j]>A[j+1]THEN A[j]与A[j+1]对换;其中 n为正整数,则最后一行的语句频度在最坏情况下是()A. O(n)B. O(nlogn)C. O(n3)D. O(n2) 【南京理工大学1998一、1(2分)】13.以下哪个数据结构不是多型数据类型()【中山大学 1999 一、3(1分)】A.栈 B.广义表 C.有向图 D.字符串14.以下数据结构中,()是非线性数据结构【中山大学 1999 一、4】A.树 B.字符串 C.队 D.栈15. 下列数据中,()是非线性数据结构。
2022年智慧树数据结构(山东大学)单元测试答案
1数据结构的形式定义是(D, S),其中D是数据元素的有限集,S是D上的关系有限集。
(答案)对2在数据结构中,从层次上可以把数据结构分成(答案)逻辑结构和存储结构3线性表若采用链式存储结构时,要求内存中可用的存储单元的地址(答案)连续不连续都可以4下面程序的时间复杂度为(答案)O(m×n)5若需要利用形参直接访问实参,则应把形参变量说明为参数。
(答案)引用第二章测试1带头结点的单链表L为空的判定条件是(答案)L→next= =NULL2非空的循环单链表L的尾结点(由p所指向)满足(答案)p→next= =L3在一个单链表中,已知q所指结点是p所指结点的前驱结点,若在q和p之间插入s结点,则执行。
(答案)p→next=s; s→next=q4在一个单链表中,若删除p所指结点的后继结点,则执行(答案)q=p→next; p→next=q→next5在一个具有n个结点的有序单链表中插入一个新结点并仍然有序的算法的时间复杂度为(答案)O(n)1、一个栈的入栈序列是A,B,C,D,E,则栈的不可能的输出序列是。
(答案)DCEAB2、在一个链队中,假设f和r分别为队首和队尾指针,则插入s所指结点的运算是。
(答案)r->next=s; r=s3、一个队列的入队序列是1,2,3,4,则队列的输出序列是。
(答案)1,2,3,44、一个中缀算术表达式为1+(3-x)*y,则其对应的后缀算术表达式为。
(答案)13x-y*+5、一个栈的入栈序列是A,B,C,D,E,f,出栈的序列是B,D,C,F,E,A,则栈的容量至少应()(答案)3第四章测试1如下图所示的4棵二叉树中,不是完全二叉树。
(答案)C2在线索化二叉树中,t所指结点没有左子树的充要条件是(答案)t->ltag= =13对一个满二叉树,m个树叶,n个结点,深度为h,则(答案)n=2h-14一个具有1025个结点二叉树的高h 为()(答案)11~10255一颗非空的二叉树的先序遍历序列和后序便利序列正好相反,则该二叉树满足()(答案)只有一个叶子结点第五章测试1(答案)22对于如下图所示的图,若从顶点a出发深度优先搜索遍历,得到的顶点序列为。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
第一章作业第章作试编个递归数来输个素的 5. 试编写一个递归函数,用来输出n 个元素的所有子集。
例如,三个元素{a, b, c} 的所有子集是:{ }(空集),{a}, {b}, {c}, {a, b}, {a, c}, {,}{,,}b, c} 和a, b, c。
基本思想:用一个一维数组x[1:n]表示大小为n的数组的一个子集。
如果第j个元素包含在子集中,那么x[j]=1 ,否则x[j]=0;x[j]0例如原数组为{a,b},那么他的子集为{0,0},{0,1},{1,0},{1,1}。
分别对应子集{Ø},{}{}{}{b},{a},{a,b}.函数实现:#include <iostream.h>// 定义全局变量,n在主函数种初始化//定义全局变量在主函数种初始化int x[20], // 子集向量,假设大小为20n; // 数组元素个数void Subsets(int i,int n){// 输出数组a[i:n].的所有子集只有[]在每次递归调用时改变[],被确定为了或// x[i:n] 在每次递归调用时改变,x[1:i-1],已经被确定为了0 1 if (i == n) {// x[n] 可以是0或1// 输出不包含元素n的子集x[n] 0;x[n]=0;for (int j = 1; j <= n; j++)cout << x[j] << " ";cout << endl;cout<<endl;//输出包含元素n的子集x[n] = 1;[]1for (j = 1; j <= n; j++)cout << x[j] << " ";cout << endl;return;// 子集中不包含元素i的情况x[i] = 0;// 递归调用产生不含有元素i的所有子集Subsets(i+1,n);//子集中包含元素i的情况x[i] 1;x[i]=1;//递归调用产生含有元素i的所有子集Subsets(i+1,n);Subsets(i+1n);}#include <iostream>int x[100]; // 子集向量,假设大小为100int x[100];//template <class T>void Subsets(int i ,int n ,T a[]){// 输出数组a[i:n].的所有子集{//a[i:n]// 只有x[i:n] 在每次递归调用时改变,x[1:i-1],已经被确定为了0 或1 if (i == n) {// x[n] 可以是0或1//// 输出不包含元素n的子集x[n] = 0;int temp=0;for (int j = 1; j <= n; j++)f(){ if(x[j]!=0) {cout << a[j] << " ";temp=1;}} if(temp==0)cout<<"空集";cout << endl;输出包含元素的子集//nx[n] = 1;for (j = 1; j <= n; j++) { if(x[j]!=0) cout << a[j] << " ";} cout << endl;cout<<endl;return;}// 子集中不包含元素i的情况x[i] = 0;// 递归调用产生不含有元素i的所有子集Subsets(i+1,n,a);//子集中包含元素i的情况x[i] 1;x[i]=1;//递归调用产生含有元素i的所有子集Subsets(i+1,n,a);Subsets(i+1n a);}void main(void){cout<<"输入数组大小n=";int n;;cin>>n;while(n>100){cout<<"请输入一个在1到100内的数"<<endl;cin>>n;}cout<<"输入"<<n<<"个数组元素:";输个数元素;char y[n+1];//实例化for(int i=1;i<=n;i++)i[i]cin>>y[i] ;Subsets(1,n,y);}第三章习题2.假设一个线性表的描述满足公式(3-1)类的定义增加个函数1)扩充LinearList类的定义,增加一个函数Reverse,该函数将表中元素的次序变反。
反序操作是就地进行的(即在数组element本身的空间内)。
注意,在反序操作进行之前,表中第k个元素(如果存在)位于element[k-1],完成反序之后,该元素位于element[length-k]。
element[length k]2)证明上述函数的复杂性与线性表的长度成线性关系。
请编写另外一个就地处理的反序函数,它能对4)请编写另外个就地处理的反序函数,它能对LinearList类型的对象进行反序操作。
该函数不是LinearList类的成员函数,但它应利用成员函数来产生反序线性表。
生反序线性表5)上述函数的时间复杂性是多少?(1)template<class T>&(){ LinearList<T>& LinearList<T>::Reverse(){(;g;)for(int i=1;i<length/2;i++)Swap(element[i-1],element[length-i]);t*thireturn *this;}(2)O(length)()(4)template<class T>(){ void Reverse(LinearList<T>& L){int n=L.length();T x;;for(int i=0;i<n-1;i++){L.Delete(n,x);L.Insert(i,x);}}(5)O(n2)7.7. 设A和B均为LinearList对象。
假定A和B中的元素都是按序排列的(如从左至右按递增次序排列)。
1) 试编写一个成员函数Merge(A, B),用以创建一个新的有序线性表,该表中包含了A和B的所有个新的有序线性表该表中包含了元素。
2) 考察所编写的函数的时间复杂性。
2)考察所编写的函数的时间复杂性template <class T>pLinearList<T>& LinearList<T>::g(,) Merge(const LinearList<T>& A, const LinearList<T>& B) {// Merge the two sorted lists A and Bint al A.Length();al=A.Length();int bl= B.Length();length al bl; // length of resultlength=al+bl;//length of resultif (length > MaxSize) throw NoMem();// inadequate space for result//inadequate space for resultint ca = 0; // cursor for A=0;//cursor for Bint cb= 0; // cursor for Bint ct = 0; // cursor for *thiswhile ((ca < al) && (cb< bl)) {(()()){if (A.element[ca] <= B.element[cb])[][];element[ct++] = A.element[ca++];else element[ct++] = B.element[cb++];}// take care of left oversif (ca al) // A is finishedif(ca==al)//A is finishedfor (int q = cb; q < bl; q++)element[ct++] B.element[q];element[ct++]=B element[q];Else for (int q = ca; q < al; q++)element[ct++] = A.element[q];element[ct++]=A element[q]; return *this;}时间复杂性:Θ(al+bl).27.1)扩充Chain的类定义,增加函数Reverse,用于对x中的元素反序。
要求反序操作就地进行,中的元素反序要求反序操作就地进行不需要分配任何新的节点。
2)函数的时间复杂性是多少?…first 算法思想算法思想: 设pr 指针first 所指节点的前驱;p 指针first 所指p 节点的后继。
重复:改变first 所指节点中的link 指针指向其前驱沿链后移位置pr ,first ,p 沿链后移一位置template <class T>Chain<T>& Chain<T>::Reverse(){ if (first= =0)return *this;C*f*ChainNode<T> *p= first->link; *pr=0; while(p){first>link prfirst->link=pr;pr= first ;first=p;p=p->link;}first->link=pr;Return *this;;}28.完成练习27,区别是Reverse不作为Chain的成员函数。
要求利用Chain的成员函数来完成成员函数要求利用反序操作。
新的函数将拥有两个参数A和B,A作为输入的链表,B是把A反序后得到的链表。
作为输入的链表反序后得到的链表在反序完成时,A变成一个空的链表。
template<class T>template class TVoid Reverse(Chain<T>& A,Chain<T>& B){ T x;B.first=0;;While (!A.IsEmpty()){A d l t(1){A.delete(1,x);B.Insert(0,x);}}31.令A和B都是Chain类型,假定A和B的元素都是按序排列的(即从左至右按递增次序排列),编写一个函数Merge,用以创建一个新的有序线性表C,该表中包含了A和B的所有元素。