严蔚敏《数据结构》(C语言版)配套题库-第12章 文 件【圣才出品】
- 格式:pdf
- 大小:288.12 KB
- 文档页数:9
严蔚敏数据结构C语言版答案详解第1章绪论1.1简述下列术语:数据,数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解:数据是对客观事物的符号表示。
在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。
数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。
数据对象是性质相同的数据元素的集合,是数据的一个子集。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
存储结构是数据结构在计算机中的表示。
数据类型是一个值的集合和定义在这个值集上的一组操作的总称。
抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。
是对一般数据类型的扩展。
1.2试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。
解:抽象数据类型包含一般数据类型的概念,但含义比一般数据类型更广、更抽象。
一般数据类型由具体语言系统内部定义,直接提供给编程者定义用户数据,因此称它们为预定义数据类型。
抽象数据类型通常由编程者定义,包括定义它所使用的数据和在这些数据上所进行的操作。
在定义抽象数据类型中的数据部分和操作部分时,要求只定义到数据的逻辑结构和操作说明,不考虑数据的存储结构和操作的具体实现,这样抽象层次更高,更能为其他用户提供良好的使用接口。
1.3设有数据结构(D,R),其中{}4,3,2,1d d d d D =,{}r R =,()()(){}4,3,3,2,2,1d d d d d d r =试按图论中图的画法惯例画出其逻辑结构图。
解:1.4试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义(有理数是其分子、分母均为自然数且分母不为零的分数)。
解:ADTComplex{数据对象:D={r,i|r,i为实数}数据关系:R={<r,i>}基本操作:InitComplex(&C,re,im)操作结果:构造一个复数C,其实部和虚部分别为re和im DestroyCmoplex(&C)操作结果:销毁复数CGet(C,k,&e)操作结果:用e返回复数C的第k元的值Put(&C,k,e)操作结果:改变复数C的第k元的值为eIsAscending(C)操作结果:如果复数C的两个元素按升序排列,则返回1,否则返回0IsDescending(C)操作结果:如果复数C的两个元素按降序排列,则返回1,否则返回0Max(C,&e)操作结果:用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果:用e返回复数C的两个元素中值较小的一个}ADTComplexADTRationalNumber{数据对象:D={s,m|s,m为自然数,且m不为0}数据关系:R={<s,m>}基本操作:InitRationalNumber(&R,s,m)操作结果:构造一个有理数R,其分子和分母分别为s和mDestroyRationalNumber(&R)操作结果:销毁有理数RGet(R,k,&e)操作结果:用e返回有理数R的第k元的值Put(&R,k,e)操作结果:改变有理数R的第k元的值为eIsAscending(R)操作结果:若有理数R的两个元素按升序排列,则返回1,否则返回0IsDescending(R)操作结果:若有理数R的两个元素按降序排列,则返回1,否则返回0Max(R,&e)操作结果:用e返回有理数R的两个元素中值较大的一个Min(R,&e)操作结果:用e返回有理数R的两个元素中值较小的一个}ADTRationalNumber1.5试画出与下列程序段等价的框图。
严蔚敏数据结构C 语言版答案详解第1章绪论1.1简述下列术语:数据,数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解:数据是对客观事物的符号表示。
在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。
数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。
数据对象是性质相同的数据元素的集合,是数据的一个子集。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
存储结构是数据结构在计算机中的表示。
数据类型是一个值的集合和定义在这个值集上的一组操作的总称。
抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。
是对一般数据类型的扩展。
1.2试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。
解:抽象数据类型包含一般数据类型的概念,但含义比一般数据类型更广、更抽象。
一般数据类型由具体语言系统内部定义,直接提供给编程者定义用户数据,因此称它们为预定义数据类型。
抽象数据类型通常由编程者定义,包括定义它所使用的数据和在这些数据上所进行的操作。
在定义抽象数据类型中的数据部分和操作部分时,要求只定义到数据的逻辑结构和操作说明,不考虑数据的存储结构和操作的具体实现,这样抽象层次更高,更能为其他用户提供良好的使用接口。
1.3设有数据结构(D,R),其中{}4,3,2,1d d d d D =,{}r R =,()()(){}4,3,3,2,2,1d d d d d d r =试按图论中图的画法惯例画出其逻辑结构图。
解:1.4试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义(有理数是其分子、分母均为自然数且分母不为零的分数)。
解:ADTComplex{数据对象:D={r,i|r,i 为实数}数据关系:R={<r,i>}基本操作:InitComplex(&C,re,im) 操作结果:构造一个复数C ,其实部和虚部分别为re 和imDestroyCmoplex(&C) 操作结果:销毁复数CGet(C,k,&e)操作结果:用e 返回复数C 的第k 元的值Put(&C,k,e)操作结果:改变复数C 的第k 元的值为eIsAscending(C)操作结果:如果复数C 的两个元素按升序排列,则返回1,否则返回0IsDescending(C)操作结果:如果复数C 的两个元素按降序排列,则返回1,否则返回0 Max(C,&e)操作结果:用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果:用e返回复数C的两个元素中值较小的一个}ADTComplexADTRationalNumber{数据对象:D={s,m|s,m为自然数,且m不为0}数据关系:R={<s,m>}基本操作:InitRationalNumber(&R,s,m)操作结果:构造一个有理数R,其分子和分母分别为s和mDestroyRationalNumber(&R)操作结果:销毁有理数RGet(R,k,&e)操作结果:用e返回有理数R的第k元的值Put(&R,k,e)操作结果:改变有理数R的第k元的值为eIsAscending(R)操作结果:若有理数R的两个元素按升序排列,则返回1,否则返回0 IsDescending(R)操作结果:若有理数R的两个元素按降序排列,则返回1,否则返回0 Max(R,&e)操作结果:用e返回有理数R的两个元素中值较大的一个Min(R,&e)操作结果:用e返回有理数R的两个元素中值较小的一个}ADTRationalNumber1.5试画出与下列程序段等价的框图。
严蔚敏 数据结构C 语言版答案详解第1章 绪论1.1简述下列术语:数据,数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解:数据是对客观事物的符号表示。
在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。
b5E2RGbCAP 数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。
数据对象是性质相同的数据元素的集合,是数据的一个子集。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
存储结构是数据结构在计算机中的表示。
数据类型是一个值的集合和定义在这个值集上的一组操作的总称。
抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。
是对一般数据类型的扩展。
1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。
解:抽象数据类型包含一般数据类型的概念,但含义比一般数据类型更广、更抽象。
一般数据类型由具体语言系统内部定义,直接提供给编程者定义用户数据,因此称它们为预定义数据类型。
抽象数据类型通常由编程者定义,包括定义它所使用的数据和在这些数据上所进行的操作。
在定义抽象数据类型中的数据部分和操作部分时,要求只定义到数据的逻辑结构和操作说明,不考虑数据的存储结构和操作的具体实现,这样抽象层次更高,更能为其他用户提供良好的使用接口。
p1EanqFDPw 1.3 设有数据结构(D,R>,其中{}4,3,2,1d d d d D =,{}r R =,()()(){}4,3,3,2,2,1d d d d d d r = 试按图论中图的画法惯例画出其逻辑结构图。
解:1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义<有理数是其分子、分母均为自然数且分母不为零的分数)。
DXDiTa9E3d 解:ADT Complex{数据对象:D={r,i|r,i 为实数} 数据关系:R={<r,i>} 基本操作: InitComplex(&C,re,im>操作结果:构造一个复数C ,其实部和虚部分别为re 和imDestroyCmoplex(&C>操作结果:销毁复数CGet(C,k,&e>操作结果:用e 返回复数C 的第k 元的值Put(&C,k,e>操作结果:改变复数C的第k元的值为eIsAscending(C>操作结果:如果复数C的两个元素按升序排列,则返回1,否则返回0IsDescending(C>操作结果:如果复数C的两个元素按降序排列,则返回1,否则返回0Max(C,&e>操作结果:用e返回复数C的两个元素中值较大的一个Min(C,&e>操作结果:用e返回复数C的两个元素中值较小的一个}ADT ComplexADT RationalNumber{数据对象:D={s,m|s,m为自然数,且m不为0}数据关系:R={<s,m>}基本操作:InitRationalNumber(&R,s,m>操作结果:构造一个有理数R,其分子和分母分别为s和m DestroyRationalNumber(&R>操作结果:销毁有理数RGet(R,k,&e>操作结果:用e返回有理数R的第k元的值Put(&R,k,e>操作结果:改变有理数R的第k元的值为eIsAscending(R>操作结果:若有理数R的两个元素按升序排列,则返回1,否则返回0IsDescending(R>操作结果:若有理数R的两个元素按降序排列,则返回1,否则返回0Max(R,&e>操作结果:用e返回有理数R的两个元素中值较大的一个Min(R,&e>操作结果:用e返回有理数R的两个元素中值较小的一个}ADT RationalNumber1.5 试画出与下列程序段等价的框图。
严蔚敏数据结构课后习题及答案解析数据结构课程是计算机科学与技术专业中非常重要的一门基础课程,对于学习者来说,课后习题的巩固和答案解析是学习的重要辅助材料。
本文将针对严蔚敏老师所著的《数据结构(C语言版)》中的课后习题及答案解析进行介绍和总结。
1. 第一章:绪论(略)2. 第二章:线性表(略)3. 第三章:栈和队列3.1 课后习题3.1.1 课后习题一:给定一个整数序列,请设计一个算法,其中删除整数序列中重复出现的元素,使得每个元素只出现一次。
要求空间复杂度为O(1)。
3.1.2 课后习题二:使用栈操作实现一个队列(其中队列操作包括入队列和出队列)。
3.2 答案解析3.2.1 答案解析一:我们可以使用双指针法来实现这一算法。
设定两个指针,一个指向当前元素,另一个指向当前元素的下一个元素。
比较两个元素是否相等,如果相等,则删除下一个元素,并移动指针。
如果不相等,则继续移动指针。
这样,当指针指向序列的最后一个元素时,算法结束。
空间复杂度为O(1),时间复杂度为O(n)。
3.2.2 答案解析二:使用两个栈来实现一个队列。
一个栈用于入队列操作,另一个栈用于出队列操作。
当需要入队列时,将元素直接入栈1。
当需要出队列时,判断栈2是否为空,如果为空,则将栈1中的元素逐个弹出并压入栈2中,然后从栈2中弹出栈顶元素。
如果栈2非空,则直接从栈2中弹出栈顶元素。
这样,就可以实现使用栈操作来实现队列操作。
4. 第四章:串(略)5. 第五章:数组和广义表(略)6. 第六章:树和二叉树(略)7. 第七章:图(略)通过对严蔚敏老师所著《数据结构(C语言版)》中的课后习题及答案解析的介绍,可以帮助学习者更好地理解和掌握数据结构这门课程的知识内容。
课后习题不仅可以帮助巩固所学知识,更加于提升学习者的能力和应用水平。
希望本文对于学习者们有所帮助。
(文章结束)。
数据结构(C语言版)严蔚敏第1章绪论1.1 简述下列术语:数据,数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解:数据是对客观事物的符号表示。
在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。
数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。
数据对象是性质相同的数据元素的集合,是数据的一个子集。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
存储结构是数据结构在计算机中的表示。
数据类型是一个值的集合和定义在这个值集上的一组操作的总称。
抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。
是对一般数据类型的扩展。
1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。
解:抽象数据类型包含一般数据类型的概念,但含义比一般数据类型更广、更抽象。
一般数据类型由具体语言系统内部定义,直接提供给编程者定义用户数据,因此称它们为预定义数据类型。
抽象数据类型通常由编程者定义,包括定义它所使用的数据和在这些数据上所进行的操作。
在定义抽象数据类型中的数据部分和操作部分时,要求只定义到数据的逻辑结构和操作说明,不考虑数据的存储结构和操作的具体实现,这样抽象层次更高,更能为其他用户提供良好的使用接口。
1.3 设有数据结构(D,R),其中{}4,3,2,1d d d d D =,{}r R =,()()(){}4,3,3,2,2,1d d d d d d r =试按图论中图的画法惯例画出其逻辑结构图。
解:1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义(有理数是其分子、分母均为自然数且分母不为零的分数)。
解:ADT Complex{数据对象:D={r,i|r,i 为实数}数据关系:R={<r,i>}基本操作: InitComplex(&C,re,im)操作结果:构造一个复数C ,其实部和虚部分别为re和imDestroyCmoplex(&C)操作结果:销毁复数CGet(C,k,&e)操作结果:用e返回复数C的第k元的值Put(&C,k,e)操作结果:改变复数C的第k元的值为eIsAscending(C)操作结果:如果复数C的两个元素按升序排列,则返回1,否则返回0IsDescending(C)操作结果:如果复数C的两个元素按降序排列,则返回1,否则返回0Max(C,&e)操作结果:用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果:用e返回复数C的两个元素中值较小的一个}ADT ComplexADT RationalNumber{数据对象:D={s,m|s,m为自然数,且m不为0}数据关系:R={<s,m>}基本操作:InitRationalNumber(&R,s,m)操作结果:构造一个有理数R,其分子和分母分别为s和mDestroyRationalNumber(&R)操作结果:销毁有理数RGet(R,k,&e)操作结果:用e返回有理数R的第k元的值Put(&R,k,e)操作结果:改变有理数R的第k元的值为eIsAscending(R)操作结果:若有理数R的两个元素按升序排列,则返回1,否则返回0IsDescending(R)操作结果:若有理数R的两个元素按降序排列,则返回1,否则返回0Max(R,&e)操作结果:用e返回有理数R的两个元素中值较大的一个Min(R,&e)操作结果:用e返回有理数R的两个元素中值较小的一个}ADT RationalNumber1.5 试画出与下列程序段等价的框图。
任何的限度,都是从自己的心坎开端的。
每一奋发尽力的背地,必有加倍的弥补。
严蔚敏数据结构C语言版答案详解第1章绪论1.1 简述下列术语:数据数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型解:数据是对客观事物的符号表示在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称数据元素是数据的基本单位在计算机程序中通常作为一个整体进行考虑和处理数据对象是性质相同的数据元素的集合是数据的一个子集数据结构是相互之间存在一种或多种特定关系的数据元素的集合存储结构是数据结构在计算机中的表示数据类型是一个值的集合和定义在这个值集上的一组操作的总称抽象数据类型是指一个数学模型以及定义在该模型上的一组操作是对一般数据类型的扩展1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别解:抽象数据类型包含一般数据类型的概念但含义比一般数据类型更广、更抽象一般数据类型由具体语言系统内部定义直接提供给编程者定义用户数据因此称它们为预定义数据类型抽象数据类型通常由编程者定义包括定义它所使用的数据和在这些数据上所进行的操作在定义抽象数据类型中的数据部分和操作部分时要求只定义到数据的逻辑结构和操作说明不考虑数据的存储结构和操作的具体实现这样抽象层次更高更能为其他用户提供良好的使用接口1.3 设有数据结构(DR)其中试按图论中图的画法惯例画出其逻辑结构图解:1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义(有理数是其分子、分母均为自然数且分母不为零的分数)解:ADT Complex{数据对象:D={ri|ri为实数}数据关系:R={<ri>}基本操作:InitComplex(&Creim)操作结果:构造一个复数C其实部和虚部分别为re和imDestroyCmoplex(&C)操作结果:销毁复数CGet(Ck&e)操作结果:用e返回复数C的第k元的值Put(&Cke)操作结果:改变复数C的第k元的值为eIsAscending(C)操作结果:如果复数C的两个元素按升序排列则返回1否则返回0IsDescending(C)操作结果:如果复数C的两个元素按降序排列则返回1否则返回0Max(C&e)操作结果:用e返回复数C的两个元素中值较大的一个Min(C&e)操作结果:用e返回复数C的两个元素中值较小的一个}ADT ComplexADT RationalNumber{数据对象:D={sm|sm为自然数且m不为0}数据关系:R={<sm>}基本操作:InitRationalNumber(&Rsm)操作结果:构造一个有理数R其分子和分母分别为s和mDestroyRationalNumber(&R)操作结果:销毁有理数RGet(Rk&e)操作结果:用e返回有理数R的第k元的值Put(&Rke)操作结果:改变有理数R的第k元的值为eIsAscending(R)操作结果:若有理数R的两个元素按升序排列则返回1否则返回0IsDescending(R)操作结果:若有理数R的两个元素按降序排列则返回1否则返回0Max(R&e)操作结果:用e返回有理数R的两个元素中值较大的一个Min(R&e)操作结果:用e返回有理数R的两个元素中值较小的一个}ADT RationalNumber1.5 试画出与下列程序段等价的框图(1) product=1; i=1;while(i<=n){product *= i;i++;}(2) i=0;do {i++;} while((i!=n) && (a[i]!=x));(3) switch {case x<y: z=y-x; break;case x=y: z=abs(x*y); break;default: z=(x-y)/abs(x)*abs(y);}1.6 在程序设计中常用下列三种不同的出错处理方式:(1) 用exit语句终止执行并报告错误;(2) 以函数的返回值区别正确返回或错误返回;(3) 设置一个整型变量的函数参数以区别正确返回或某种错误返回试讨论这三种方法各自的优缺点解:(1)exit常用于异常错误处理它可以强行中断程序的执行返回操作系统(2)以函数的返回值判断正确与否常用于子程序的测试便于实现程序的局部控制(3)用整型函数进行错误处理的优点是可以给出错误类型便于迅速确定错误1.7 在程序设计中可采用下列三种方法实现输出和输入:(1) 通过scanf和printf语句;(2) 通过函数的参数显式传递;(3) 通过全局变量隐式传递试讨论这三种方法的优缺点解:(1)用scanf和printf直接进行输入输出的好处是形象、直观但缺点是需要对其进行格式控制较为烦琐如果出现错误则会引起整个系统的崩溃(2)通过函数的参数传递进行输入输出便于实现信息的隐蔽减少出错的可能(3)通过全局变量的隐式传递进行输入输出最为方便只需修改变量的值即可但过多的全局变量使程序的维护较为困难1.8 设n为正整数试确定下列各程序段中前置以记号@的语句的频度:(1) i=1; k=0;while(i<=n-1){@ k += 10*i;i++;}(2) i=1; k=0;do {@ k += 10*i;i++;} while(i<=n-1);(3) i=1; k=0;while (i<=n-1) {i++;@ k += 10*i;}(4) k=0;for(i=1; i<=n; i++) {for(j=i; j<=n; j++)@ k++;}(5) for(i=1; i<=n; i++) {for(j=1; j<=i; j++) {for(k=1; k<=j; k++)@ x += delta;}(6) i=1; j=0;while(i+j<=n) {@ if(i>j) j++;else i++;}(7) x=n; y=0; // n是不小于1的常数while(x>=(y+1)*(y+1)) {@ y++;}(8) x=91; y=100;while(y>0) {@ if(x>100) { x -= 10; y--; }else x++;}解:(1) n-1(2) n-1(3) n-1(4) n+(n-1)+(n-2)+ (1)(5) 1+(1+2)+(1+2+3)+...+(1+2+3+...+n)===(6) n(7) 向下取整(8) 11001.9 假设n为2的乘幂并且n>2试求下列算法的时间复杂度及变量count的值(以n的函数形式表示)int Time(int n) {count = 0; x=2;while(x<n/2) {x *= 2; count++;}return count;}解:count=1.11 已知有实现同一功能的两个算法其时间复杂度分别为和假设现实计算机可连续运算的时间为秒(100多天)又每秒可执行基本操作(根据这些操作来估算算法时间复杂度)次试问在此条件下这两个算法可解问题的规模(即n值的范围)各为多少?哪个算法更适宜?请说明理由解:n=40n=16则对于同样的循环次数n在这个规模下第二种算法所花费的代价要大得多故在这个规模下第一种算法更适宜1.12 设有以下三个函数:请判断以下断言正确与否:(1) f(n)是O(g(n))(2) h(n)是O(f(n))(3) g(n)是O(h(n))(4) h(n)是O(n3.5)(5) h(n)是O(nlogn)解:(1)对 (2)错 (3)错 (4)对 (5)错1.13 试设定若干n值比较两函数和的增长趋势并确定n在什么范围内函数的值大于的值解:的增长趋势快但在n较小的时候的值较大当n>438时1.14 判断下列各对函数和当时哪个函数增长更快?(1)(2)(3)(4)解:(1)g(n)快 (2)g(n)快 (3)f(n)快 (4) f(n)快1.15 试用数学归纳法证明:(1)(2)(3)(4)1.16 试写一算法自大至小依次输出顺序读入的三个整数XY和Z的值解:int max3(int xint yint z){if(x>y)if(x>z) return x;else return z;elseif(y>z) return y;else return z;}1.17 已知k阶斐波那契序列的定义为...;试编写求k阶斐波那契序列的第m项值的函数算法k和m均以值调用的形式在函数参数表中出现解:k>0为阶数n为数列的第n项int Fibonacci(int kint n){if(k<1) exit(OVERFLOW);int *px;p=new int[k+1];if(!p) exit(OVERFLOW);int ij;for(i=0;i<k+1;i++){if(i<k-1) p[i]=0;else p[i]=1;}for(i=k+1;i<n+1;i++){x=p[0];for(j=0;j<k;j++) p[j]=p[j+1];p[k]=2*p[k-1]-x;}return p[k];}1.18 假设有ABCDE五个高等院校进行田径对抗赛各院校的单项成绩均已存入计算机并构成一张表表中每一行的形式为项目名称性别校名成绩得分编写算法处理上述表格以统计各院校的男、女总分和团体总分并输出解:typedef enum{ABCDE} SchoolName;typedef enum{FemaleMale} SexType;typedef struct{char event[3]; //项目SexType sex;SchoolName school;int score;} Component;typedef struct{int MaleSum; //男团总分int FemaleSum; //女团总分int TotalSum; //团体总分} Sum;Sum SumScore(SchoolName sn Component a[]int n){Sum temp;temp.MaleSum=0;temp.FemaleSum=0;temp.TotalSum=0;int i;for(i=0;i<n;i++){if(a[i].school==sn){if(a[i].sex==Male) temp.MaleSum+=a[i].score;if(a[i].sex==Female) temp.FemaleSum+=a[i].score;}}temp.TotalSum=temp.MaleSum+temp.FemaleSum;return temp;}1.19 试编写算法计算的值并存入数组a[0..arrsize-1]的第i-1个分量中(i=12...n)假设计算机中允许的整数最大值为maxint则当n>arrsize或对某个使时应按出错处理注意选择你认为较好的出错处理方法解:#include<iostream.h>#include<stdlib.h>#define MAXINT 65535#define ArrSize 100int fun(int i);int main(){int ik;int a[ArrSize];cout<<"Enter k:";cin>>k;if(k>ArrSize-1) exit(0);for(i=0;i<=k;i++){if(i==0) a[i]=1;else{if(2*i*a[i-1]>MAXINT) exit(0);else a[i]=2*i*a[i-1];}}for(i=0;i<=k;i++){if(a[i]>MAXINT) exit(0);else cout<<a[i]<<" ";}return 0;}1.20 试编写算法求一元多项式的值的值并确定算法中每一语句的执行次数和整个算法的时间复杂度注意选择你认为较好的输入和输出方法本题的输入为和输出为解:#include<iostream.h>#include<stdlib.h>#define N 10double polynomail(int a[]int idouble xint n);int main(){double x;int ni;int a[N];cout<<"输入变量的值x:";cin>>x;cout<<"输入多项式的阶次n:";cin>>n;if(n>N-1) exit(0);cout<<"输入多项式的系数a[0]--a[n]:";for(i=0;i<=n;i++) cin>>a[i];cout<<"The polynomail value is "<<polynomail(a nxn)<<endl;return 0;}double polynomail(int a[]int idouble xint n)if(i>0) return a[n-i]+polynomail(ai-1xn)*x;else return a[n];}本算法的时间复杂度为o(n)第2章线性表2.1 描述以下三个概念的区别:头指针头结点首元结点(第一个元素结点)解:头指针是指向链表中第一个结点的指针首元结点是指链表中存储第一个数据元素的结点头结点是在首元结点之前附设的一个结点该结点不存储数据元素其指针域指向首元结点其作用主要是为了方便对链表的操作它可以对空表、非空表以及首元结点的操作进行统一处理2.2 填空题解:(1) 在顺序表中插入或删除一个元素需要平均移动表中一半元素具体移动的元素个数与元素在表中的位置有关(2) 顺序表中逻辑上相邻的元素的物理位置必定紧邻单链表中逻辑上相邻的元素的物理位置不一定紧邻(3) 在单链表中除了首元结点外任一结点的存储位置由其前驱结点的链域的值指示(4) 在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理2.3 在什么情况下用顺序表比链表好?解:当线性表的数据元素在物理位置上是连续存储的时候用顺序表比用链表好其特点是可以进行随机存取2.4 对以下单链表分别执行下列各程序段并画出结果示意图解:2.5 画出执行下列各行语句后各指针及链表的示意图L=(LinkList)malloc(sizeof(LNode)); P=L;for(i=1;i<=4;i++){P->next=(LinkList)malloc(sizeof(LNode));P=P->next; P->data=i*2-1;}P->next=NULL;for(i=4;i>=1;i--) Ins_LinkList(Li+1i*2);for(i=1;i<=3;i++) Del_LinkList(Li);解:2.6 已知L是无表头结点的单链表且P结点既不是首元结点也不是尾元结点试从下列提供的答案中选择合适的语句序列a. 在P结点后插入S结点的语句序列是__________________b. 在P结点前插入S结点的语句序列是__________________c. 在表首插入S结点的语句序列是__________________d. 在表尾插入S结点的语句序列是__________________(1) P->next=S;(2) P->next=P->next->next;(3) P->next=S->next;(4) S->next=P->next;(5) S->next=L;(6) S->next=NULL;(7) Q=P;(8) while(P->next!=Q) P=P->next;(9) while(P->next!=NULL) P=P->next;(10) P=Q;(11) P=L;(12) L=S;(13) L=P;解:a. (4) (1)b. (7) (11) (8) (4) (1)c. (5) (12)d. (9) (1) (6)2.7 已知L是带表头结点的非空单链表且P结点既不是首元结点也不是尾元结点试从下列提供的答案中选择合适的语句序列a. 删除P结点的直接后继结点的语句序列是____________________b. 删除P结点的直接前驱结点的语句序列是____________________c. 删除P结点的语句序列是____________________d. 删除首元结点的语句序列是____________________e. 删除尾元结点的语句序列是____________________(1) P=P->next;(2) P->next=P;(3) P->next=P->next->next;(4) P=P->next->next;(5) while(P!=NULL) P=P->next;(6) while(Q->next!=NULL) { P=Q; Q=Q->next; }(7) while(P->next!=Q) P=P->next;(8) while(P->next->next!=Q) P=P->next;(9) while(P->next->next!=NULL) P=P->next;(10) Q=P;(11) Q=P->next;(12) P=L;(13) L=L->next;(14) free(Q);解:a. (11) (3) (14)b. (10) (12) (8) (3) (14)c. (10) (12) (7) (3) (14)d. (12) (11) (3) (14)e. (9) (11) (3) (14)2.8 已知P结点是某双向链表的中间结点试从下列提供的答案中选择合适的语句序列a. 在P结点后插入S结点的语句序列是_______________________b. 在P结点前插入S结点的语句序列是_______________________c. 删除P结点的直接后继结点的语句序列是_______________________d. 删除P结点的直接前驱结点的语句序列是_______________________e. 删除P结点的语句序列是_______________________(1) P->next=P->next->next;(2) P->priou=P->priou->priou;(3) P->next=S;(4) P->priou=S;(5) S->next=P;(6) S->priou=P;(7) S->next=P->next;(8) S->priou=P->priou;(9) P->priou->next=P->next;(10) P->priou->next=P;(11) P->next->priou=P;(12) P->next->priou=S;(13) P->priou->next=S;(14) P->next->priou=P->priou;(15) Q=P->next;(16) Q=P->priou;(17) free(P);(18) free(Q);解:a. (7) (3) (6) (12)b. (8) (4) (5) (13)c. (15) (1) (11) (18)d. (16) (2) (10) (18)e. (14) (9) (17)2.9 简述以下算法的功能(1) Status A(LinkedList L) { //L是无表头结点的单链表if(L && L->next) {Q=L; L=L->next; P=L;while(P->next) P=P->next;P->next=Q; Q->next=NULL;}return OK;}(2) void BB(LNode *sLNode *q) {p=s;while(p->next!=q) p=p->next;p->next =s;}void AA(LNode *paLNode *pb) {//pa和pb分别指向单循环链表中的两个结点BB(papb);BB(pbpa);}解:(1) 如果L的长度不小于2将L的首元结点变成尾元结点(2) 将单循环链表拆成两个单循环链表2.10 指出以下算法中的错误和低效之处并将它改写为一个既正确又高效的算法Status DeleteK(SqList &aint iint k){//本过程从顺序存储结构的线性表a中删除第i个元素起的k个元素if(i<1||k<0||i+k>a.length) return INFEASIBLE;//参数不合法else {for(count=1;count<k;count++){//删除第一个元素for(j=a.length;j>=i+1;j--) a.elem[j-i]=a.elem[j];a.length--;}return OK;}解:Status DeleteK(SqList &aint iint k){//从顺序存储结构的线性表a中删除第i个元素起的k个元素//注意i的编号从0开始int j;if(i<0||i>a.length-1||k<0||k>a.length-i) return INFEASIBLE;for(j=0;j<=k;j++)a.elem[j+i]=a.elem[j+i+k];a.length=a.length-k;return OK;}2.11 设顺序表va中的数据元素递增有序试写一算法将x插入到顺序表的适当位置上以保持该表的有序性解:Status InsertOrderList(SqList &vaElemType x){//在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法int i;if(va.length==va.listsize)return(OVERFLOW);for(i=va.length;i>0x<va.elem[i-1];i--)va.elem[i]=va.elem[i-1];va.elem[i]=x;va.length++;return OK;}2.12 设和均为顺序表和分别为和中除去最大共同前缀后的子表若空表则;若=空表而空表或者两者均不为空表且的首元小于的首元则;否则试写一个比较大小的算法解:Status CompareOrderList(SqList &ASqList &B){int ikj;k=A.length>B.length?A.length:B.length;for(i=0;i<k;i++){if(A.elem[i]>B.elem[i]) j=1;if(A.elem[i]<B.elem[i]) j=-1;}if(A.length>k) j=1;if(B.length>k) j=-1;if(A.length==B.length) j=0;return j;}2.13 试写一算法在带头结点的单链表结构上实现线性表操作Locate(L x);解:int LocateElem_L(LinkList &LElemType x){int i=0;LinkList p=L;while(p&&p->data!=x){p=p->next;i++;}if(!p) return 0;else return i;}2.14 试写一算法在带头结点的单链表结构上实现线性表操作Length(L)解://返回单链表的长度int ListLength_L(LinkList &L){int i=0;LinkList p=L;if(p) p=p-next;while(p){p=p->next;i++;}return i;}2.15 已知指针ha和hb分别指向两个单链表的头结点并且已知两个链表的长度分别为m和n试写一算法将这两个链表连接在一起假设指针hc指向连接后的链表的头结点并要求算法以尽可能短的时间完成连接运算请分析你的算法的时间复杂度解:void MergeList_L(LinkList &haLinkList &hbLinkList &hc){LinkList papb;pa=ha;pb=hb;while(pa->next&&pb->next){pa=pa->next;pb=pb->next;}if(!pa->next){hc=hb;while(pb->next) pb=pb->next;pb->next=ha->next;}else{hc=ha;while(pa->next) pa=pa->next;pa->next=hb->next;}}2.16 已知指针la和lb分别指向两个无头结点单链表中的首元结点下列算法是从表la中删除自第i个元素起共len个元素后将它们插入到表lb中第i个元素之前试问此算法是否正确?若有错请改正之Status DeleteAndInsertSub(LinkedList laLinkedList lbint iint jint len){if(i<0||j<0||len<0) return INFEASIBLE;p=la; k=1;while(k<i){ p=p->next; k++; }q=p;while(k<=len){ q=q->next; k++; }s=lb; k=1;while(k<j){ s=s->next; k++; }s->next=p; q->next=s->next;return OK;}解:Status DeleteAndInsertSub(LinkList &la LinkList &lbint iint jint len){LinkList pqsprev=NULL;int k=1;if(i<0||j<0||len<0) return INFEASIBLE;// 在la表中查找第i个结点p=la;while(p&&k<i){prev=p;p=p->next;k++;}if(!p)return INFEASIBLE;// 在la表中查找第i+len-1个结点q=p; k=1;while(q&&k<len){q=p->next;k++;}if(!q)return INFEASIBLE;// 完成删除注意i=1的情况需要特殊处理if(!prev) la=q->next;else prev->next=q->next;// 将从la中删除的结点插入到lb中if(j=1){q->next=lb;lb=p;}else{s=lb; k=1;while(s&&k<j-1){s=s->next;k++;}if(!s)return INFEASIBLE;q->next=s->next;s->next=p; //完成插入}return OK;}2.17 试写一算法在无头结点的动态单链表上实现线性表操作Insert(Lib)并和在带头结点的动态单链表上实现相同操作的算法进行比较2.18试写一算法实现线性表操作Delete(Li)并和在带头结点的动态单链表上实现相同操作的算法进行比较2.19 已知线性表中的元素以值递增有序排列并以单链表作存储结构试写一高效的算法删除表中所有值大于mink且小于maxk的元素(若表中存在这样的元素)同时释放被删结点空间并分析你的算法的时间复杂度(注意mink和maxk是给定的两个参变量它们的值可以和表中的元素相同也可以不同)解:Status ListDelete_L(LinkList &LElemType minkElemType maxk){LinkList pqprev=NULL;if(mink>maxk)return ERROR;p=L;prev=p;p=p->next;while(p&&p->data<maxk){if(p->data<=mink){prev=p;p=p->next;}else{prev->next=p->next;q=p;p=p->next;free(q);}}return OK;}2.20 同2.19题条件试写一高效的算法删除表中所有值相同的多余元素(使得操作后的线性表中所有元素的值均不相同)同时释放被删结点空间并分析你的算法的时间复杂度解:void ListDelete_LSameNode(LinkList &L){LinkList pqprev;p=L;prev=p;p=p->next;while(p){prev=p;p=p->next;if(p&&p->data==prev->data){prev->next=p->next;q=p;p=p->next;free(q);}}}2.21 试写一算法实现顺序表的就地逆置即利用原表的存储空间将线性表逆置为解:// 顺序表的逆置Status ListOppose_Sq(SqList &L){int i;ElemType x;for(i=0;i<L.length/2;i++){x=L.elem[i];L.elem[i]=L.elem[L.length-1-i];L.elem[L.length-1-i]=x;}return OK;}2.22 试写一算法对单链表实现就地逆置解:// 带头结点的单链表的逆置Status ListOppose_L(LinkList &L){LinkList pq;p=L;p=p->next;L->next=NULL;while(p){q=p;p=p->next;q->next=L->next;L->next=q;}return OK;}2.23 设线性表试写一个按下列规则合并AB为线性表C的算法即使得当时;当时线性表AB和C均以单链表作存储结构且C表利用A表和B表中的结点空间构成注意:单链表的长度值m和n均未显式存储解:// 将合并后的结果放在C表中并删除B表Status ListMerge_L(LinkList &ALinkList &BLinkList &C){LinkList papbqaqb;pa=A->next;pb=B->next;C=A;while(pa&&pb){qa=pa; qb=pb;pa=pa->next; pb=pb->next;qb->next=qa->next;qa->next=qb;}if(!pa)qb->next=pb;pb=B;free(pb);return OK;}2.24 假设有两个按元素值递增有序排列的线性表A和B均以单链表作存储结构请编写算法将A表和B表归并成一个按元素值递减有序(即非递增有序允许表中含有值相同的元素)排列的线性表C并要求利用原表(即A表和B表)的结点空间构造C表解:// 将合并逆置后的结果放在C表中并删除B表Status ListMergeOppose_L(LinkList &ALinkList &BLinkList &C){LinkList papbqaqb;pa=A;pb=B;qa=pa; // 保存pa的前驱指针qb=pb; // 保存pb的前驱指针pa=pa->next;pb=pb->next;A->next=NULL;C=A;while(pa&&pb){if(pa->data<pb->data){qa=pa;pa=pa->next;qa->next=A->next; //将当前最小结点插入A表表头A->next=qa;}else{qb=pb;pb=pb->next;qb->next=A->next; //将当前最小结点插入A表表头A->next=qb;}}while(pa){qa=pa;pa=pa->next;qa->next=A->next;A->next=qa;}while(pb){qb=pb;pb=pb->next;qb->next=A->next;A->next=qb;}pb=B;free(pb);return OK;}2.25 假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合(即同一表中的元素值各不相同)现要求另辟空间构成一个线性表C其元素为A和B中元素的交集且表C中的元素有依值递增有序排列试对顺序表编写求C的算法解:// 将A、B求交后的结果放在C表中Status ListCross_Sq(SqList &ASqList &BSqList &C){int i=0j=0k=0;while(i<A.length && j<B.length){if(A.elem[i]<B.elem[j]) i++;elseif(A.elem[i]>B.elem[j]) j++;else{ListInsert_Sq(CkA.elem[i]);i++;k++;}}return OK;}2.26 要求同2.25题试对单链表编写求C的算法解:// 将A、B求交后的结果放在C表中并删除B表Status ListCross_L(LinkList &ALinkList &BLinkList &C){LinkList papbqaqbpt;pa=A;pb=B;qa=pa; // 保存pa的前驱指针qb=pb; // 保存pb的前驱指针pa=pa->next;pb=pb->next;C=A;while(pa&&pb){if(pa->data<pb->data){pt=pa;pa=pa->next;qa->next=pa;free(pt);}elseif(pa->data>pb->data){pt=pb;pb=pb->next;qb->next=pb;free(pt);}else{qa=pa;pa=pa->next;}}while(pa){pt=pa;pa=pa->next;qa->next=pa;free(pt);}while(pb){pt=pb;pb=pb->next;qb->next=pb;free(pt);}pb=B;free(pb);return OK;}2.27 对2.25题的条件作以下两点修改对顺序表重新编写求得表C的算法(1) 假设在同一表(A或B)中可能存在值相同的元素但要求新生成的表C中的元素值各不相同;(2) 利用A表空间存放表C解:(1)// A、B求交然后删除相同元素将结果放在C表中Status ListCrossDelSame_Sq(SqList &ASqList &BSqList &C){int i=0j=0k=0;while(i<A.length && j<B.length){if(A.elem[i]<B.elem[j]) i++;elseif(A.elem[i]>B.elem[j]) j++;else{if(C.length==0){ListInsert_Sq(CkA.elem[i]);k++;}elseif(C.elem[C.length-1]!=A.elem[i]){ListInsert_Sq(CkA.elem[i]);k++;}i++;}}return OK;}(2)// A、B求交然后删除相同元素将结果放在A表中Status ListCrossDelSame_Sq(SqList &ASqList &B){int i=0j=0k=0;while(i<A.length && j<B.length){if(A.elem[i]<B.elem[j]) i++;elseif(A.elem[i]>B.elem[j]) j++;else{if(k==0){A.elem[k]=A.elem[i];k++;}elseif(A.elem[k]!=A.elem[i]){A.elem[k]=A.elem[i];k++;}i++;}}A.length=k;return OK;}2.28 对2.25题的条件作以下两点修改对单链表重新编写求得表C的算法(1) 假设在同一表(A或B)中可能存在值相同的元素但要求新生成的表C中的元素值各不相同;(2) 利用原表(A表或B表)中的结点构成表C并释放A表中的无用结点空间解:(1)// A、B求交结果放在C表中并删除相同元素Status ListCrossDelSame_L(LinkList &ALinkList &BLinkList &C){LinkList papbqaqbpt;pa=A;pb=B;qa=pa; // 保存pa的前驱指针qb=pb; // 保存pb的前驱指针pa=pa->next;pb=pb->next;C=A;while(pa&&pb){if(pa->data<pb->data){pt=pa;pa=pa->next;qa->next=pa;free(pt);}elseif(pa->data>pb->data){pt=pb;pb=pb->next;qb->next=pb;free(pt);}else{if(pa->data==qa->data){pt=pa;pa=pa->next;qa->next=pa;free(pt);}else{qa=pa;pa=pa->next;}}}while(pa){pt=pa;pa=pa->next;qa->next=pa;free(pt);}while(pb){pt=pb;pb=pb->next;qb->next=pb;free(pt);}pb=B;free(pb);return OK;}(2)// A、B求交结果放在A表中并删除相同元素Status ListCrossDelSame_L(LinkList &A LinkList &B){LinkList papbqaqbpt;pa=A;pb=B;qa=pa; // 保存pa的前驱指针qb=pb; // 保存pb的前驱指针pa=pa->next;pb=pb->next;while(pa&&pb){if(pa->data<pb->data){pt=pa;pa=pa->next;qa->next=pa;free(pt);}elseif(pa->data>pb->data){pt=pb;pb=pb->next;qb->next=pb;free(pt);}else{if(pa->data==qa->data){pt=pa;pa=pa->next;qa->next=pa;free(pt);}else{qa=pa;pa=pa->next;}}}while(pa){pt=pa;pa=pa->next;qa->next=pa;free(pt);}while(pb){pt=pb;pb=pb->next;qb->next=pb;free(pt);}pb=B;free(pb);return OK;}2.29 已知AB和C为三个递增有序的线性表现要求对A表作如下操作:删去那些既在B表中出现又在C表中出现的元素试对顺序表编写实现上述操作的算法并分析你的算法的时间复杂度(注意:题中没有特别指明同一表中的元素值各不相同)解:// 在A中删除既在B中出现又在C中出现的元素结果放在D中Status ListUnion_Sq(SqList &DSqList &ASqList &BSqList &C){SqList Temp;InitList_Sq(Temp);ListCross_L(BCTemp);ListMinus_L(ATempD);}2.30 要求同2.29题试对单链表编写算法请释放A表中的无用结点空间解:// 在A中删除既在B中出现又在C中出现的元素并释放B、CStatus ListUnion_L(LinkList &ALinkList &BLinkList &C){ListCross_L(BC);ListMinus_L(AB);}// 求集合A-B结果放在A表中并删除B表Status ListMinus_L(LinkList &ALinkList &B){LinkList papbqaqbpt;pa=A;pb=B;qa=pa; // 保存pa的前驱指针qb=pb; // 保存pb的前驱指针pa=pa->next;pb=pb->next;while(pa&&pb){if(pb->data<pa->data){pt=pb;pb=pb->next;qb->next=pb;free(pt);}elseif(pb->data>pa->data){qa=pa;pa=pa->next;}else{pt=pa;pa=pa->next;qa->next=pa;free(pt);}}while(pb){pt=pb;pb=pb->next;qb->next=pb;free(pt);}pb=B;free(pb);return OK;}2.31 假设某个单向循环链表的长度大于1且表中既无头结点也无头指针已知s为指向链表中某个结点的指针试编写算法在链表中删除指针s所指结点的前驱结点解:// 在单循环链表S中删除S的前驱结点Status ListDelete_CL(LinkList &S){LinkList pq;if(S==S->next)return ERROR;q=S;p=S->next;while(p->next!=S){q=p;p=p->next;}q->next=p->next;free(p);return OK;}2.32 已知有一个单向循环链表其每个结点中含三个域:predata和next其中data为数据域next为指向后继结点的指针域pre也为指针域但它的值为空试编写算法将此单向循环链表改为双向循环链表即使pre成为指向前驱结点的指针域解:// 建立一个空的循环链表Status InitList_DL(DuLinkList &L){L=(DuLinkList)malloc(sizeof(DuLNode));if(!L) exit(OVERFLOW);L->pre=NULL;L->next=L;return OK;}// 向循环链表中插入一个结点Status ListInsert_DL(DuLinkList &L ElemType e){DuLinkList p;p=(DuLinkList)malloc(sizeof(DuLNode));if(!p) return ERROR;p->data=e;p->next=L->next;L->next=p;return OK;}// 将单循环链表改成双向链表Status ListCirToDu(DuLinkList &L){DuLinkList pq;q=L;p=L->next;while(p!=L){p->pre=q;q=p;}if(p==L) p->pre=q;return OK;}2.33 已知由一个线性链表表示的线性表中含有三类字符的数据元素(如:字母字符、数字字符和其他字符)试编写算法将该线性表分割为三个循环链表其中每个循环链表表示的线性表中均只含一类字符解:// 将单链表L划分成3个单循环链表Status ListDivideInto3CL(LinkList &LLinkList &s1LinkList &s2LinkList &s3){LinkList pqpt1pt2pt3;p=L->next;pt1=s1;pt2=s2;pt3=s3;while(p){if(p->data>='0' && p->data<='9'){q=p;p=p->next;q->next=pt1->next;pt1->next=q;pt1=pt1->next;}elseif((p->data>='A' && p->data<='Z') ||(p->data>='a' && p->data<='z')){q=p;p=p->next;q->next=pt2->next;pt2->next=q;pt2=pt2->next;}else{p=p->next;q->next=pt3->next;pt3->next=q;pt3=pt3->next;}}q=L;free(q);return OK;}在2.34至2.36题中"异或指针双向链表"类型XorLinkedList和指针异或函数XorP定义为:typedef struct XorNode {char data;struct XorNode *LRPtr;} XorNode*XorPointer;typede struct { //无头结点的异或指针双向链表XorPointer LeftRight; //分别指向链表的左侧和右端} XorLinkedList;XorPointer XorP(XorPointer pXorPointer q);// 指针异或函数XorP返回指针p和q的异或值2.34 假设在算法描述语言中引入指针的二元运算"异或"若a和b为指针则a⊕b的运算结果仍为原指针类型且a⊕(a⊕b)=(a⊕a)⊕b=b(a⊕b)⊕b=a⊕(b⊕b)=a则可利用一个指针域来实现双向链表L链表L中的每个结点只含两个域:data域和LRPtr域其中LRPtr域存放该结点的左邻与右邻结点指针(不存在时为NULL)的异或若设指针L.Left指向链表中的最左结点L.Right指向链表中的最右结点则可实现从左向右或从右向左遍历此双向链表的操作试写一算法按任一方向依次输出链表中各元素的值解:Status TraversingLinkList(XorLinkedList &Lchar d){XorPointer pright;if(d=='l'||d=='L'){p=L.Left;left=NULL;while(p!=NULL){VisitingData(p->data);left=p;p=XorP(leftp->LRPtr);}}elseif(d=='r'||d=='R'){p=L.Right;right=NULL;while(p!=NULL){VisitingData(p->data);right=p;p=XorP(p->LRPtrright);}}else return ERROR;return OK;}2.35 采用2.34题所述的存储结构写出在第i个结点之前插入一个结点的算法2.36 采用2.34题所述的存储结构写出删除第i个结点的算法2.37 设以带头结点的双向循环链表表示的线性表试写一时间复杂度O(n)的算法将L改造为解:// 将双向链表L=(a1a2...an)改造为(a1a3...an。
严蔚敏数据结构C 语言版答案详解第1章绪论1.1简述下列术语:数据,数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解:数据是对客观事物的符号表示。
在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。
数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。
数据对象是性质相同的数据元素的集合,是数据的一个子集。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
存储结构是数据结构在计算机中的表示。
数据类型是一个值的集合和定义在这个值集上的一组操作的总称。
抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。
是对一般数据类型的扩展。
1.2试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。
解:抽象数据类型包含一般数据类型的概念,但含义比一般数据类型更广、更抽象。
一般数据类型由具体语言系统内部定义,直接提供给编程者定义用户数据,因此称它们为预定义数据类型。
抽象数据类型通常由编程者定义,包括定义它所使用的数据和在这些数据上所进行的操作。
在定义抽象数据类型中的数据部分和操作部分时,要求只定义到数据的逻辑结构和操作说明,不考虑数据的存储结构和操作的具体实现,这样抽象层次更高,更能为其他用户提供良好的使用接口。
1.3设有数据结构(D,R),其中{}4,3,2,1d d d d D =,{}r R =,()()(){}4,3,3,2,2,1d d d d d d r =试按图论中图的画法惯例画出其逻辑结构图。
解:1.4试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义(有理数是其分子、分母均为自然数且分母不为零的分数)。
解:ADTComplex{数据对象:D={r,i|r,i 为实数}数据关系:R={<r,i>}基本操作:InitComplex(&C,re,im) 操作结果:构造一个复数C ,其实部和虚部分别为re 和imDestroyCmoplex(&C) 操作结果:销毁复数CGet(C,k,&e)操作结果:用e 返回复数C 的第k 元的值Put(&C,k,e)操作结果:改变复数C 的第k 元的值为eIsAscending(C)操作结果:如果复数C 的两个元素按升序排列,则返回1,否则返回0IsDescending(C)操作结果:如果复数C 的两个元素按降序排列,则返回1,否则返回0 Max(C,&e)操作结果:用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果:用e返回复数C的两个元素中值较小的一个}ADTComplexADTRationalNumber{数据对象:D={s,m|s,m为自然数,且m不为0}数据关系:R={<s,m>}基本操作:InitRationalNumber(&R,s,m)操作结果:构造一个有理数R,其分子和分母分别为s和mDestroyRationalNumber(&R)操作结果:销毁有理数RGet(R,k,&e)操作结果:用e返回有理数R的第k元的值Put(&R,k,e)操作结果:改变有理数R的第k元的值为eIsAscending(R)操作结果:若有理数R的两个元素按升序排列,则返回1,否则返回0 IsDescending(R)操作结果:若有理数R的两个元素按降序排列,则返回1,否则返回0 Max(R,&e)操作结果:用e返回有理数R的两个元素中值较大的一个Min(R,&e)操作结果:用e返回有理数R的两个元素中值较小的一个}ADTRationalNumber1.5试画出与下列程序段等价的框图。
数据结构(C语言版)严蔚敏课后习题答案数据结构(C语言版)严蔚敏课后习题答案一、线性表1. 顺序表顺序表是一种存储结构,它将元素顺序存放在一块连续的存储区域中。
C语言中常用数组来实现顺序表。
以下是一些常见题目的解答:题目1:已知顺序表中存储了n个整数,请编写一个算法,将这个顺序表中的所有负数挑选出来,并将它们按照原有顺序存放在新的顺序表中。
解答:```#include <stdio.h>#define MAX_SIZE 100int main() {int A[MAX_SIZE], neg[MAX_SIZE];int n, i, j = 0;printf("Enter the number of elements: ");scanf("%d", &n);printf("Enter the elements: ");for (i = 0; i < n; i++) {scanf("%d", &A[i]);if (A[i] < 0) {neg[j] = A[i];j++;}}printf("Negative numbers: ");for (i = 0; i < j; i++) {printf("%d ", neg[i]);}return 0;}```题目2:假设顺序表A和B中的元素递增有序排列,编写一个算法合并这两个顺序表,并使合并后的顺序表仍然递增有序。
解答:```#include <stdio.h>#define MAX_SIZE 100int main() {int A[MAX_SIZE], B[MAX_SIZE], C[MAX_SIZE * 2]; int m, n, i, j, k;printf("Enter the number of elements in the first list: "); scanf("%d", &m);printf("Enter the elements in increasing order: ");for (i = 0; i < m; i++) {scanf("%d", &A[i]);C[i] = A[i];}printf("Enter the number of elements in the second list: "); scanf("%d", &n);printf("Enter the elements in increasing order: ");for (i = 0; i < n; i++) {scanf("%d", &B[i]);C[m + i] = B[i];}// Merge A and B into Ci = j = k = 0;while (i < m && j < n) { if (A[i] < B[j]) {C[k] = A[i];i++;} else {C[k] = B[j];j++;}k++;}while (i < m) {C[k] = A[i];i++;k++;}while (j < n) {C[k] = B[j];j++;k++;}printf("Merged list in increasing order: ");for (i = 0; i < m + n; i++) {printf("%d ", C[i]);}return 0;}```2. 链表链表是一种动态的数据结构,它通过结点之间的指针联系起来。
第1章绪论1.1 简述下列术语:数据,数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解:数据是对客观事物的符号表示。
在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。
数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。
数据对象是性质相同的数据元素的集合,是数据的一个子集。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
存储结构是数据结构在计算机中的表示。
数据类型是一个值的集合和定义在这个值集上的一组操作的总称。
抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。
是对一般数据类型的扩展。
1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。
解:抽象数据类型包含一般数据类型的概念,但含义比一般数据类型更广、更抽象。
一般数据类型由具体语言系统内部定义,直接提供给编程者定义用户数据,因此称它们为预定义数据类型。
抽象数据类型通常由编程者定义,包括定义它所使用的数据和在这些数据上所进行的操作。
在定义抽象数据类型中的数据部分和操作部分时,要求只定义到数据的逻辑结构和操作说明,不考虑数据的存储结构和操作的具体实现,这样抽象层次更高,更能为其他用户提供良好的使用接口。
1.3 设有数据结构(D,R),其中{}4,3,2,1d d d d D =,{}r R =,()()(){}4,3,3,2,2,1d d d d d d r =试按图论中图的画法惯例画出其逻辑结构图。
解:1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义(有理数是其分子、分母均为自然数且分母不为零的分数)。
解:ADT Complex{数据对象:D={r,i|r,i 为实数}数据关系:R={<r,i>}基本操作: InitComplex(&C,re,im)操作结果:构造一个复数C ,其实部和虚部分别为re和imDestroyCmoplex(&C)操作结果:销毁复数CGet(C,k,&e)操作结果:用e返回复数C的第k元的值Put(&C,k,e)操作结果:改变复数C的第k元的值为eIsAscending(C)操作结果:如果复数C的两个元素按升序排列,则返回1,否则返回0IsDescending(C)操作结果:如果复数C的两个元素按降序排列,则返回1,否则返回0Max(C,&e)操作结果:用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果:用e返回复数C的两个元素中值较小的一个}ADT ComplexADT RationalNumber{数据对象:D={s,m|s,m为自然数,且m不为0}数据关系:R={<s,m>}基本操作:InitRationalNumber(&R,s,m)操作结果:构造一个有理数R,其分子和分母分别为s和mDestroyRationalNumber(&R)操作结果:销毁有理数RGet(R,k,&e)操作结果:用e返回有理数R的第k元的值Put(&R,k,e)操作结果:改变有理数R的第k元的值为eIsAscending(R)操作结果:若有理数R的两个元素按升序排列,则返回1,否则返回0IsDescending(R)操作结果:若有理数R的两个元素按降序排列,则返回1,否则返回0Max(R,&e)操作结果:用e返回有理数R的两个元素中值较大的一个Min(R,&e)操作结果:用e返回有理数R的两个元素中值较小的一个}ADT RationalNumber1.5 试画出与下列程序段等价的框图。
严蔚敏数据结构C语言版答案详解第1章绪论1.1简述下列术语:数据,数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解:数据是对客观事物的符号表示。
在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。
数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。
数据对象是性质相同的数据元素的集合,是数据的一个子集。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
存储结构是数据结构在计算机中的表示。
数据类型是一个值的集合和定义在这个值集上的一组操作的总称。
抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。
是对一般数据类型的扩展。
1.2试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。
解:抽象数据类型包含一般数据类型的概念,但含义比一般数据类型更广、更抽象。
一般数据类型由具体语言系统内部定义,直接提供给编程者定义用户数据,因此称它们为预定义数据类型。
抽象数据类型通常由编程者定义,包括定义它所使用的数据和在这些数据上所进行的操作。
在定义抽象数据类型中的数据部分和操作部分时,要求只定义到数据的逻辑结构和操作说明,不考虑数据的存储结构和操作的具体实现,这样抽象层次更高,更能为其他用户提供良好的使用接口。
1.3设有数据结构(D,R),其中{}4,3,2,1d d d d D =,{}r R =,()()(){}4,3,3,2,2,1d d d d d d r =试按图论中图的画法惯例画出其逻辑结构图。
解:1.4试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义(有理数是其分子、分母均为自然数且分母不为零的分数)。
解:ADTComplex{数据对象:D={r,i|r,i为实数}数据关系:R={<r,i>}基本操作:InitComplex(&C,re,im)操作结果:构造一个复数C,其实部和虚部分别为re和im DestroyCmoplex(&C)操作结果:销毁复数CGet(C,k,&e)操作结果:用e返回复数C的第k元的值Put(&C,k,e)操作结果:改变复数C的第k元的值为eIsAscending(C)操作结果:如果复数C的两个元素按升序排列,则返回1,否则返回0IsDescending(C)操作结果:如果复数C的两个元素按降序排列,则返回1,否则返回0Max(C,&e)操作结果:用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果:用e返回复数C的两个元素中值较小的一个}ADTComplexADTRationalNumber{数据对象:D={s,m|s,m为自然数,且m不为0}数据关系:R={<s,m>}基本操作:InitRationalNumber(&R,s,m)操作结果:构造一个有理数R,其分子和分母分别为s和m DestroyRationalNumber(&R)操作结果:销毁有理数RGet(R,k,&e)操作结果:用e返回有理数R的第k元的值Put(&R,k,e)操作结果:改变有理数R的第k元的值为eIsAscending(R)操作结果:若有理数R的两个元素按升序排列,则返回1,否则返回0IsDescending(R)操作结果:若有理数R的两个元素按降序排列,则返回1,否则返回0Max(R,&e)操作结果:用e返回有理数R的两个元素中值较大的一个Min(R,&e)操作结果:用e返回有理数R的两个元素中值较小的一个}ADTRationalNumber1.5试画出与下列程序段等价的框图。
数据结构c语言版严蔚敏课后习题答案数据结构是计算机科学中非常重要的一门学科,它研究的是数据的组织、存储和管理方式。
而C语言作为一种广泛应用于系统编程和嵌入式开发的高级编程语言,与数据结构的学习息息相关。
本文将针对《数据结构(C语言版)》严蔚敏教材的课后习题提供一些答案,希望能够帮助读者更好地理解和掌握数据结构。
第一章:绪论在第一章中,主要介绍了数据结构的基本概念和基本术语。
课后习题主要是一些概念性的问题,例如数据结构与算法的关系、数据的逻辑结构和物理结构等。
这些问题的答案可以通过仔细阅读教材中的相关内容来得到。
第二章:线性表线性表是数据结构中最基本、最常用的一种结构。
课后习题主要涉及线性表的基本操作,如插入、删除、查找等。
这些问题的答案可以通过编写相应的C语言代码来实现。
第三章:栈和队列栈和队列是线性表的特殊形式,具有后进先出(LIFO)和先进先出(FIFO)的特点。
课后习题主要涉及栈和队列的基本操作,如进栈、出栈、入队、出队等。
这些问题的答案同样可以通过编写相应的C语言代码来实现。
第四章:串串是由零个或多个字符组成的有限序列,是一种特殊的线性表。
课后习题主要涉及串的模式匹配、串的替换等操作。
这些问题的答案可以通过使用C语言的字符串处理函数来实现。
第五章:数组和广义表数组是一种线性表的顺序存储结构,广义表是线性表的扩展。
课后习题主要涉及数组和广义表的创建、访问和操作等。
这些问题的答案可以通过编写相应的C语言代码来实现。
第六章:树树是一种非线性的数据结构,具有层次关系。
课后习题主要涉及树的遍历、节点的插入和删除等操作。
这些问题的答案可以通过使用C语言的指针和递归来实现。
第七章:图图是一种非线性的数据结构,由节点和边组成。
课后习题主要涉及图的遍历、最短路径、最小生成树等操作。
这些问题的答案可以通过使用C语言的图算法来实现。
通过以上的简要介绍,读者可以了解到《数据结构(C语言版)》严蔚敏教材的课后习题主要涵盖了线性表、栈和队列、串、数组和广义表、树、图等各个方面。
说明: 1. 本文是对严蔚敏?数据构造(c语言版)习题集?一书中所有算法设计题目的解决方案,主要作者为kaoyan.计算机版版主一具.以下网友:siice,龙抬头,iamkent,zames,birdthinking等为答案的修订和完善工作提出了珍贵意见,在此表示感;2. 本解答中的所有算法均采用类c语言描述,设计原那么为面向交流、面向阅读,作者不保证程序能够上机正常运行(这种保证实际上也没有任何意义);3. 本解答原那么上只给出源代码以及必要的注释,对于一些难度较高或思路特殊的题目将给出简要的分析说明,对于作者无法解决的题目将给出必要的讨论.目前尚未解决的题目有: 5.20, 10.40;4. 请读者在自己已经解决了某个题目或进展了充分的思考之后,再参考本解答,以保证复习效果;5. 由于作者水平所限,本解答中一定存在不少这样或者那样的错误和缺乏,希望读者们在阅读中多动脑、勤思考,争取发现和纠正这些错误,写出更好的算法来.请将你发现的错误或其它值得改良之处向作者报告: 第一章绪论1.16void print_descending(int x,int y,int z)//按从大到小顺序输出三个数{scanf("%d,%d,%d",&x,&y,&z);if(x<y) x<->y; //<->为表示交换的双目运算符,以下同if(y<z) y<->z;if(x<y) x<->y; //冒泡排序printf("%d %d %d",x,y,z);}//print_descending1.17Status fib(int k,int m,int &f)//求k阶斐波那契序列的第m项的值f{int tempd;if(k<2||m<0) return ERROR;if(m<k-1) f=0;else if (m==k-1) f=1;else{for(i=0;i<=k-2;i++) temp[i]=0;temp[k-1]=1; //初始化for(i=k;i<=m;i++) //求出序列第k至第m个元素的值{sum=0;for(j=i-k;j<i;j++) sum+=temp[j];temp[i]=sum;}f=temp[m];}return OK;}//fib分析:通过保存已经计算出来的结果,此方法的时间复杂度仅为O(m^2).如果采用递归编程(大多数人都会首先想到递归方法),那么时间复杂度将高达O(k^m).1.18typedef struct{char *sport;enum{male,female} gender;char schoolname; //校名为'A','B','C','D'或'E'char *result;int score;} resulttype;typedef struct{int malescore;int femalescore;int totalscore;} scoretype;void summary(resulttype result[ ])//求各校的男女总分和团体总分,假设结果已经储存在result[ ]数组中{scoretype score;i=0;while(result[i].sport!=NULL){switch(result[i].schoolname){case 'A':score[ 0 ].totalscore+=result[i].score; if(result[i].gender==0) score[ 0 ].malescore+=result[i].score; else score[ 0 ].femalescore+=result[i].score;break;case 'B':score.totalscore+=result[i].score;if(result[i].gender==0) score.malescore+=result[i].score;else score.femalescore+=result[i].score;break;……………… }i++;}for(i=0;i<5;i++){printf("School %d:\n",i);printf("Total score of male:%d\n",score[i].malescore);printf("Total score of female:%d\n",score[i].femalescore);printf("Total score of all:%d\n\n",score[i].totalscore);}}//summary1.19Status algo119(int a[ARRSIZE])//求i!*2^i序列的值且不超过maxint{last=1;for(i=1;i<=ARRSIZE;i++){a[i-1]=last*2*i;if((a[i-1]/last)!=(2*i)) reurn OVERFLOW;last=a[i-1];return OK;}}//algo119分析:当某一项的结果超过了maxint时,它除以前面一项的商会发生异常.1.20void polyvalue(){float ad;float *p=a;printf("Input number of terms:");scanf("%d",&n);printf("Input the %d coefficients from a0 to a%d:\n",n,n);for(i=0;i<=n;i++) scanf("%f",p++);printf("Input value of x:");scanf("%f",&x);p=a;xp=1;sum=0; //xp用于存放x的i次方for(i=0;i<=n;i++){sum+=xp*(*p++);xp*=x;}printf("Value is:%f",sum);}//polyvalue第二章线性表2.10Status DeleteK(SqList &a,int i,int k)//删除线性表a中第i个元素起的k个元素{if(i<1||k<0||i+k-1>a.length) return INFEASIBLE;for(count=1;i+count-1<=a.length-k;count++) //注意循环完毕的条件a.elem[i+count-1]=a.elem[i+count+k-1];a.length-=k;return OK;}//DeleteK2.11Status Insert_SqList(SqList &va,int x)//把x插入递增有序表va中{if(va.length+1>va.listsize) return ERROR;va.length++;for(i=va.length-1;va.elem[i]>x&&i>=0;i--)va.elem[i+1]=va.elem[i];va.elem[i+1]=x;return OK;}//Insert_SqList2.12int Listp(SqList A,SqList B)//比拟字符表A和B,并用返回值表示结果,值为正,表示A>B;值为负,表示A<B;值为零,表示A=B {for(i=1;A.elem[i]||B.elem[i];i++)if(A.elem[i]!=B.elem[i]) return A.elem[i]-B.elem[i];return 0;}//Listp2.13LNode* Locate(LinkList L,int x)//链表上的元素查找,返回指针{for(p=l->next;p&&p->data!=x;p=p->next);return p;}//Locate2.14int Length(LinkList L)//求链表的长度{for(k=0,p=L;p->next;p=p->next,k++);return k;}//Length2.15void ListConcat(LinkList ha,LinkList hb,LinkList &hc)//把链表hb接在ha后面形成链表hc{while(p->next) p=p->next;p->next=hb;}//ListConcat2.16见书后答案.2.17Status Insert(LinkList &L,int i,int b)//在无头结点链表L的第i个元素之前插入元素b{p=L;q=(LinkList*)malloc(sizeof(LNode));q.data=b;if(i==1){q.next=p;L=q; //插入在链表头部}else{while(--i>1) p=p->next;q->next=p->next;p->next=q; //插入在第i个元素的位置}}//Insert2.18Status Delete(LinkList &L,int i)//在无头结点链表L中删除第i个元素{if(i==1) L=L->next; //删除第一个元素else{p=L;while(--i>1) p=p->next;p->next=p->next->next; //删除第i个元素}}//Delete2.19Status Delete_Between(Linklist &L,int mink,int maxk)//删除元素递增排列的链表L中值大于mink且小于maxk的所有元素{p=L;while(p->next->data<=mink) p=p->next; //p是最后一个不大于mink的元素if(p->next) //如果还有比mink更大的元素{q=p->next;while(q->data<maxk) q=q->next; //q是第一个不小于maxk的元素p->next=q;}}//Delete_Between2.20Status Delete_Equal(Linklist &L)//删除元素递增排列的链表L中所有值一样的元素{p=L->next;q=p->next; //p,q指向相邻两元素while(p->next){p=p->next;q=p->next; //当相邻两元素不相等时,p,q都向后推一步}else{while(q->data==p->data){free(q);q=q->next;}p->next=q;p=q;q=p->next; //当相邻元素相等时删除多余元素}//else}//while}//Delete_Equal2.21void reverse(SqList &A)//顺序表的就地逆置{for(i=1,j=A.length;i<j;i++,j--)A.elem[i]<->A.elem[j];}//reverse2.22void LinkList_reverse(Linklist &L)//链表的就地逆置;为简化算法,假设表长大于2{p=L->next;q=p->next;s=q->next;p->next=NULL;while(s->next){q->next=p;p=q;q=s;s=s->next; //把L的元素逐个插入新表表头}q->next=p;s->next=q;L->next=s;}//LinkList_reverse分析:本算法的思想是,逐个地把L的当前元素q插入新的链表头部,p为新表表头.2.23void merge1(LinkList &A,LinkList &B,LinkList &C)//把链表A和B合并为C,A和B的元素间隔排列,且使用原存储空间{p=A->next;q=B->next;C=A;while(p&&q){s=p->next;p->next=q; //将B的元素插入if(s){t=q->next;q->next=s; //如A非空,将A的元素插入}p=s;q=t;}//while}//merge12.24void reverse_merge(LinkList &A,LinkList &B,LinkList &C)//把元素递增排列的链表A和B合并为C,且C中元素递减排列,使用原空间{pa=A->next;pb=B->next;pre=NULL; //pa和pb分别指向A,B的当前元素while(pa||pb){pc=pa;q=pa->next;pa->next=pre;pa=q; //将A的元素插入新表}else{pc=pb;q=pb->next;pb->next=pre;pb=q; //将B的元素插入新表}pre=pc;}C=A;A->next=pc; //构造新表头}//reverse_merge分析:本算法的思想是,按从小到大的顺序依次把A和B的元素插入新表的头部pc处,最后处理A或B的剩余元素.2.25void SqList_Intersect(SqList A,SqList B,SqList &C)//求元素递增排列的线性表A和B的元素的交集并存入C中{i=1;j=1;k=0;while(A.elem[i]&&B.elem[j]){if(A.elem[i]<B.elem[j]) i++;if(A.elem[i]>B.elem[j]) j++;if(A.elem[i]==B.elem[j]){C.elem[++k]=A.elem[i]; //当发现了一个在A,B中都存在的元素,i++;j++; //就添加到C中}}//while}//SqList_Intersect2.26void LinkList_Intersect(LinkList A,LinkList B,LinkList &C)//在链表构造上重做上题{p=A->next;q=B->next;pc=(LNode*)malloc(sizeof(LNode));while(p&&q){if(p->data<q->data) p=p->next;else if(p->data>q->data) q=q->next;else{s=(LNode*)malloc(sizeof(LNode));s->data=p->data;pc->next=s;pc=s;p=p->next;q=q->next;}}//whileC=pc;}//LinkList_Intersect2.27void SqList_Intersect_True(SqList &A,SqList B)//求元素递增排列的线性表A和B的元素的交集并存回A中{i=1;j=1;k=0;while(A.elem[i]&&B.elem[j]){if(A.elem[i]<B.elem[j]) i++;else if(A.elem[i]>B.elem[j]) j++;A.elem[++k]=A.elem[i]; //当发现了一个在A,B中都存在的元素i++;j++; //且C中没有,就添加到C中}}//whilewhile(A.elem[k]) A.elem[k++]=0;}//SqList_Intersect_True2.28void LinkList_Intersect_True(LinkList &A,LinkList B)//在链表构造上重做上题{p=A->next;q=B->next;pc=A;while(p&&q){if(p->data<q->data) p=p->next;else if(p->data>q->data) q=q->next;else if(p->data!=pc->data){pc=pc->next;pc->data=p->data;p=p->next;q=q->next;}}//while}//LinkList_Intersect_True2.29void SqList_Intersect_Delete(SqList &A,SqList B,SqList C){i=0;j=0;k=0;m=0; //i指示A中元素原来的位置,m为移动后的位置while(i<A.length&&j<B.length&& k<C.length){if(B.elem[j]<C.elem[k]) j++;else if(B.elem[j]>C.elem[k]) k++;else{same=B.elem[j]; //找到了一样元素samewhile(B.elem[j]==same) j++;while(C.elem[k]==same) k++; //j,k后移到新的元素while(i<A.length&&A.elem[i]<same)A.elem[m++]=A.elem[i++]; //需保存的元素移动到新位置while(i<A.length&&A.elem[i]==same) i++; //跳过一样的元素}}//whilewhile(i<A.length)A.elem[m++]=A.elem[i++];//A的剩余元素重新存储。
数据结构(C语言版)(第2版)课后习题答案李冬梅2015.3目录第1章绪论 (1)第2章线性表 (5)第3章栈和队列 (13)第4章串、数组和广义表 (26)第5章树和二叉树 (33)第6章图 (43)第7章查找 (54)第8章排序 (65)第1章绪论1.简述下列概念:数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。
答案:数据:是客观事物的符号表示,指所有能输入到计算机中并被计算机程序处理的符号的总称。
如数学计算中用到的整数和实数,文本编辑所用到的字符串,多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。
数据元素:是数据的基本单位,在计算机中通常作为一个整体进行考虑和处理。
在有些情况下,数据元素也称为元素、结点、记录等。
数据元素用于完整地描述一个对象,如一个学生记录,树中棋盘的一个格局(状态)、图中的一个顶点等。
数据项:是组成数据元素的、有独立含义的、不可分割的最小单位。
例如,学生基本信息表中的学号、姓名、性别等都是数据项。
数据对象:是性质相同的数据元素的集合,是数据的一个子集。
例如:整数数据对象是集合N={0,±1,±2,…},字母字符数据对象是集合C={‘A’,‘B’,…,‘Z’,‘a’,‘b’,…,‘z’},学生基本信息表也可是一个数据对象。
数据结构:是相互之间存在一种或多种特定关系的数据元素的集合。
换句话说,数据结构是带“结构”的数据元素的集合,“结构”就是指数据元素之间存在的关系。
逻辑结构:从逻辑关系上描述数据,它与数据的存储无关,是独立于计算机的。
因此,数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。
存储结构:数据对象在计算机中的存储表示,也称为物理结构。
抽象数据类型:由用户定义的,表示应用问题的数学模型,以及定义在这个模型上的一组操作的总称。
具体包括三部分:数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。
严蔚敏数据结构C语言版答案详解第1章绪论1.1简述下列术语:数据,数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解:数据是对客观事物的符号表示。
在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。
数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。
数据对象是性质相同的数据元素的集合,是数据的一个子集。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
存储结构是数据结构在计算机中的表示。
数据类型是一个值的集合和定义在这个值集上的一组操作的总称。
抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。
是对一般数据类型的扩展。
1.2试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。
解:抽象数据类型包含一般数据类型的概念,但含义比一般数据类型更广、更抽象。
一般数据类型由具体语言系统内部定义,直接提供给编程者定义用户数据,因此称它们为预定义数据类型。
抽象数据类型通常由编程者定义,包括定义它所使用的数据和在这些数据上所进行的操作。
在定义抽象数据类型中的数据部分和操作部分时,要求只定义到数据的逻辑结构和操作说明,不考虑数据的存储结构和操作的具体实现,这样抽象层次更高,更能为其他用户提供良好的使用接口。
1.3设有数据结构(D,R),其中{}4,3,2,1d d d d D =,{}r R =,()()(){}4,3,3,2,2,1d d d d d d r =试按图论中图的画法惯例画出其逻辑结构图。
解:1.4试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义(有理数是其分子、分母均为自然数且分母不为零的分数)。
解:ADTComplex{数据对象:D={r,i|r,i为实数}数据关系:R={<r,i>}基本操作:InitComplex(&C,re,im)操作结果:构造一个复数C,其实部和虚部分别为re和im DestroyCmoplex(&C)操作结果:销毁复数CGet(C,k,&e)操作结果:用e返回复数C的第k元的值Put(&C,k,e)操作结果:改变复数C的第k元的值为eIsAscending(C)操作结果:如果复数C的两个元素按升序排列,则返回1,否则返回0IsDescending(C)操作结果:如果复数C的两个元素按降序排列,则返回1,否则返回0Max(C,&e)操作结果:用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果:用e返回复数C的两个元素中值较小的一个}ADTComplexADTRationalNumber{数据对象:D={s,m|s,m为自然数,且m不为0}数据关系:R={<s,m>}基本操作:InitRationalNumber(&R,s,m)操作结果:构造一个有理数R,其分子和分母分别为s和m DestroyRationalNumber(&R)操作结果:销毁有理数RGet(R,k,&e)操作结果:用e返回有理数R的第k元的值Put(&R,k,e)操作结果:改变有理数R的第k元的值为eIsAscending(R)操作结果:若有理数R的两个元素按升序排列,则返回1,否则返回0IsDescending(R)操作结果:若有理数R的两个元素按降序排列,则返回1,否则返回0Max(R,&e)操作结果:用e返回有理数R的两个元素中值较大的一个Min(R,&e)操作结果:用e返回有理数R的两个元素中值较小的一个}ADTRationalNumber1.5试画出与下列程序段等价的框图。
第12章 文 件
一、选择题
1.哈希文件使用哈希函数将记录的关键字值计算转化为记录的存放地址,因为哈希函数是一对一的关系,则选择好的()方法是哈希文件的关键。
A.哈希函数B.除余法中的质数C.冲突处理D.哈希函数和冲突处理【答案】D
【解析】哈希表是根据文件中关键字的特点设计一种哈希函数和处理冲突的方法将记录散列到存储设备上。
2.下述文件中适合于磁带存储的是()。
A.顺序文件B.索引文件C.哈希文件D.多关键字文件
【答案】A
【解析】磁带存储是一种顺序存储,顺序文件(sequential file)是记录按其在文件中的逻辑顺序依次进入存储介质而建立的,即顺序文件中物理记录的顺序和逻辑记录的顺序是一致的。
因此顺序文件适合磁带存储。
二、判断题
1.倒排文件是对次关键字建立索引。
()
【答案】√
【解析】倒排文件是对每一个次关键字项建立次关键字索引(称为倒排表),将所有具有相同次关键字的记录的物理记录号都填入倒排表为此次关键字的表中。
2.倒排序文件的优点是维护简单。
()
【答案】×
【解析】倒排文件的优点是检索记录较快。
特别是对某些询问,不用读取记录,就可得到解答。
3.哈希表与哈希文件的唯一区别是哈希文件引入了“桶”的概念。
()
【答案】×
【解析】哈希文件是使用一个函数(算法)来完成一种将关键字映射到存储器地址的映射,根据用户给出的关键字,经函数计算得到目标地址,再进行目标的检索。
哈希表是根据关键码值而直接进行访问的数据结构。
4.文件系统采用索引结构是为了节省存储空间。
()
【答案】×
【解析】是为了缩短查找的时间,牺牲了一部分存储空间。
5.对处理大量数据的外存介质而言,索引顺序存取方法是一种方便的文件组织方法。
()
【答案】×
【解析】索引顺序存取方法插入操作比较麻烦,对于处理大量数据,会有大量的记录进入溢出区,而基本区中又浪费很多空间。
6.对磁带机而言,ISAM是一种方便的文件组织方法。
()
【答案】×
【解析】ISAM是一种专为磁盘存取设计的文件组织方式。
7.直接访问文件也能顺序访问,只是一般效率不高。
()
【答案】×
【解析】直接访问文件不能进行顺序访问,只能按关键字随机存取。
在ISAM文件上检索记录时,先从主索引出发找到相应的柱面索引,再从柱面索引找到记录所在柱面的磁道索引,最后从磁道索引找到记录所在磁道的第一个记录的位置,由此出发在该磁道上进行顺序查找直至找到为止。
8.倒排文件的目的是为了多关键字查找。
()
【答案】√
【解析】多关键字文件的特点是,在对文件进行检索操作时,不仅对主关键字进行简单询问,还经常需要对次关键字进行其它类型的询问检索。
常见的多关键字文件为:多重表文件和倒排文件。
三、填空题
1.文件可按其记录的类型不同而分成两类,即_______和_______文件。
【答案】操作系统文件;数据库
2.从用户的观点看,文件的逻辑结构通常可以区分为两类:一类是如NdBASE中数据库文件那样的文件组织结构,称为___(1)___文件;另一种是诸如用各种文字处理软件编辑成的文本文件,称为___(2)___文件。
从文件在存储器上的存放方式来看,文件的物理结构往往可区分为三类,即___(3)___,___(4)___和___(5)___。
B+树适用于组织___(6)___的索引结构,m阶B+树每个结点至多有___(7)___个儿子,除根结点外每个
结点至少有___(8)___个儿子,根结点至少有___(9)___个儿子,有k个儿子的结点必
有___(10)___个关键码。
【答案】数据库;文本;顺序组织;随机组织;链组织;随机组织;
m;⎡m/2⎤;2;k
3.文件由_______组成;记录由_______组成。
【答案】记录;数据项
4.索引顺序文件既可以顺序存取,也可以_______存取。
【答案】随机
5.建立索引文件的目的是_______。
【答案】提高查找速度
6.检索是为了在文件中寻找满足一定条件的记录而设置的操作。
检索可以按
___________检索。
也可以按_______检索;按_______检索又可以有_______检索和_______检索。
【答案】关键字;记录号;记录号;顺序;直接
7.VSAM系统是由_______、_______、_______构成的。
【答案】索引集;顺序集;数据集
8.VSAM(虚拟存储存取方法)文件的优点是:动态地_______,不需要文件进行
_______,并能较快地_______进行查找。
【答案】分配和释放存储空间;重组;对插入的记录
四、应用题
1.文件存储结构的基本形式有哪些?一个文件采用何种存储结构应考虑哪些因素?
答:文件的基本组织方式有顺序组织、索引组织、散列组织和链组织,常用的结构有顺序结构、索引结构、散列结构。
(1)顺序结构,相应文件为顺序文件,其记录按存入文件的先后次序顺序存放。
顺序文传本质上就是顺序表。
若逻辑上相邻的两个记录在存储位置上相邻,则为连续文件;若记录之间以指针相链接,则称为串联文件。
顺序文件只能顺序存取,要更新某个记录,必须复制整个文件。
顺序文件连续存取的速度快,主要适用于顺序存取,批量修改的情况。
(2)带索引的结构,相应文件为索引文件。
索引文件包括索引表和数据表,索引表中的索引项包括数据表中数据的关键字和相应地址,索引表有序,其物理顺序体现了文件的逻辑次序,实现了文件的线性结构。
索引文件只能是磁盘文件,既能顺序存取,又能随机存取。
(3)散列结构,也称计算寻址结构,相应文件称为散列文件,其记录是根据关键字值经哈希函数计算确定其地址,存取速度快,不需索引,节省存储空间。
不能顺序存取,只能随机存取。
文件采用何种存储结构应综合考虑各种因素,如:存储介质类型、记录的类型、大小和关键字的数目以及对文件作何种操作。
2.索引顺序存取方法(ISAM)中,主文件已按关键字排序,为何还需要主关键字索引?
答:ISAM是专为磁盘存取设计的文件组织方式。
即使主文件关键字有序,但因磁盘是以盘组、柱面和磁道(盘面)三级地址存取的设备,因此通常对磁盘上的数据文件建立盘组、柱面和磁道(盘面)三级索引。
在ISAM文件上检索记录时,先从主索引(柱面索引的索引)找到相应柱面索引。
再从柱面索引找到记录所在柱面的磁道索引,最后从磁道索引找到记录所在磁道的第一个记录的位置,由此出发在该磁道上进行顺序查找直到查到为止;反之,若找遍该磁道而未找到所查记录,则文件中无此记录。
3.分析ISAM文件(Indexed Sequential Access Methord)和VSAM文件(Virtual storageAccess Methord)的应用场合、优缺点等。
答:ISAM是一种专为磁盘存取设计的文件组织形式,采用静态索引结构,对磁盘上的数据文件建立盘组、柱面、磁道三级索引。
ISAM文件中记录按关键字顺序存放,插入记录时需移动记录并将同一磁道上最后的一个记录移至溢出区,同时修改磁道索引项,删除记录只需在存储位置作标记,不需移动记录和修改指针。
经过多次插入和删除记录后,文件结构变得不合理,需周期整理ISAM文件。
VSAM文件采用B+树动态索引结构,文件只有控制区间和控制区域等逻辑存储单位,与外存储器中柱面、磁道等具体存储单位没有必然联系。
VSAM文件结构包括索引集、顺序集和数据集三部分,记录存于数据集中,顺序集和索引集构成B+树,作为文件的索引部分可实现顺链查找和从根结点开始的随机查找。
优缺点:与ISAM文件相比,VSAM文件有如下优点:动态分配和释放存储空间,不。