数据结构_严蔚敏_第6章

数据结构（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. 第一章：绪论（略）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语言版）》中的课后习题及答案解析的介绍，可以帮助学习者更好地理解和掌握数据结构这门课程的知识内容。

课后习题不仅可以帮助巩固所学知识，更加于提升学习者的能力和应用水平。

希望本文对于学习者们有所帮助。

（文章结束）。

《数据结构》第二版严蔚敏课后习题作业参考答案(1-7章)【第一章绪论】1. 数据结构是计算机科学中的重要基础知识，它研究的是如何组织和存储数据，以及如何通过高效的算法进行数据的操作和处理。

本章主要介绍了数据结构的基本概念和发展历程。

【第二章线性表】1. 线性表是由一组数据元素组成的数据结构，它的特点是元素之间存在着一对一的线性关系。

本章主要介绍了线性表的顺序存储结构和链式存储结构，以及它们的操作和应用。

【第三章栈与队列】1. 栈是一种特殊的线性表，它的特点是只能在表的一端进行插入和删除操作。

本章主要介绍了栈的顺序存储结构和链式存储结构，以及栈的应用场景。

2. 队列也是一种特殊的线性表，它的特点是只能在表的一端进行插入操作，而在另一端进行删除操作。

本章主要介绍了队列的顺序存储结构和链式存储结构，以及队列的应用场景。

【第四章串】1. 串是由零个或多个字符组成的有限序列，它是一种线性表的特例。

本章主要介绍了串的存储结构和基本操作，以及串的模式匹配算法。

【第五章数组与广义表】1. 数组是一种线性表的顺序存储结构，它的特点是所有元素都具有相同数据类型。

本章主要介绍了一维数组和多维数组的存储结构和基本操作，以及广义表的概念和表示方法。

【第六章树与二叉树】1. 树是一种非线性的数据结构，它的特点是一个节点可以有多个子节点。

本章主要介绍了树的基本概念和属性，以及树的存储结构和遍历算法。

2. 二叉树是一种特殊的树，它的每个节点最多只有两个子节点。

本章主要介绍了二叉树的存储结构和遍历算法，以及一些特殊的二叉树。

【第七章图】1. 图是一种非线性的数据结构，它由顶点集合和边集合组成。

本章主要介绍了图的基本概念和属性，以及图的存储结构和遍历算法。

【总结】1. 数据结构是计算机科学中非常重要的一门基础课程，它关注的是如何高效地组织和存储数据，以及如何通过算法进行数据的操作和处理。

本文对《数据结构》第二版严蔚敏的课后习题作业提供了参考答案，涵盖了第1-7章的内容。

《数据结构（C语言版第2版）》（严蔚敏著）第六章练习题答案第6章图1．选择题（1）在一个图中，所有顶点的度数之和等于图的边数的（）倍。

A．1/2B．1C．2D．4答案：C（2）在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的（）倍。

A．1/2B．1C．2D．4答案：B解释：有向图所有顶点入度之和等于所有顶点出度之和。

（3）具有n个顶点的有向图最多有（）条边。

A．n B．n(n-1)C．n(n+1)D．n2答案：B解释：有向图的边有方向之分，即为从n个顶点中选取2个顶点有序排列，结果为n(n-1)。

（4）n个顶点的连通图用邻接距阵表示时，该距阵至少有（）个非零元素。

A．n B．2(n-1)C．n/2D．n2答案：B所谓连通图一定是无向图,有向的叫做强连通图连通n个顶点,至少只需要n-1条边就可以了,或者说就是生成树由于无向图的每条边同时关联两个顶点,因此邻接矩阵中每条边被存储了两次（也就是说是对称矩阵）,因此至少有2(n-1)个非零元素（5）G是一个非连通无向图，共有28条边，则该图至少有（）个顶点。

A．7B．8C．9D．10答案：C解释：8个顶点的无向图最多有8*7/2=28条边，再添加一个点即构成非连通无向图，故至少有9个顶点。

（6）若从无向图的任意一个顶点出发进行一次深度优先搜索可以访问图中所有的顶点，则该图一定是（）图。

A．非连通B．连通C．强连通D．有向答案：B解释：即从该无向图任意一个顶点出发有到各个顶点的路径，所以该无向图是连通图。

（7）下面（）算法适合构造一个稠密图G的最小生成树。

A．Prim算法B．Kruskal算法C．Floyd算法D．Dijkstra算法答案：A解释：Prim算法适合构造一个稠密图G的最小生成树，Kruskal算法适合构造一个稀疏图G的最小生成树。

（8）用邻接表表示图进行广度优先遍历时，通常借助（）来实现算法。

A．栈 B.队列 C.树D．图答案：B解释：广度优先遍历通常借助队列来实现算法，深度优先遍历通常借助栈来实现算法。

期末复习 第一章 绪论 复习1、计算机算法必须具备输入、输出、可行性、确定性、有穷性５个特性。

2、算法分析的两个主要方面是空间复杂度和时间复杂度。

3、数据元素是数据的基本单位。

4、数据项是数据的最小单位。

5、数据结构是带结构的数据元素的集合。

6、数据的存储结构包括顺序、链接、散列和索引四种基本类型。

基础知识数据结构算 法概 念逻辑结构 存储结构数据运算数据：计算机处理的信息总称 数据项：最小单位 数据元素：最基本单位数据对象：元素集合数据结构：相互之间存在一种或多种特定关系的数据元素集合。

概念：数据元素之间的关系 线性结构：一对一非线性结构 树：一对多 图：多对多顺序存储结构 链表存储结构 索引。

散列。

算法描述：指令的有限有序序列算法特性 有穷性 确定性 可行性 输入 输出 算法分析时间复杂度 空间复杂度第二章 线性表 复习1、在双链表中，每个结点有两个指针域，包括一个指向前驱结点的指针 、一个指向后继结点的指针2、线性表采用顺序存储，必须占用一片连续的存储单元3、线性表采用链式存储，便于进行插入和删除操作4、线性表采用顺序存储和链式存储优缺点比较。

5、简单算法第三章 栈和队列 复习线性表顺序存储结构链表存储结构概 念基本特点基本运算定义逻辑关系：前趋 后继节省空间 随机存取 插、删效率低 插入 删除单链表双向 链表 特点一个指针域+一个数据域 多占空间 查找费时 插、删效率高 无法查找前趋结点运算特点：单链表+前趋指针域运算插入删除循环 链表特点：单链表的尾结点指针指向附加头结点。

运算：联接1、 栈和队列的异同点。

2、 栈和队列的基本运算3、 出栈和出队4、 基本运算第四章 串 复习栈存储结构栈的概念：在一端操作的线性表 运算算法栈的特点：先进后出 LIFO初始化 进栈push 出栈pop队列顺序队列 循环队列队列概念：在两端操作的线性表 假溢出链队列队列特点：先进先出 FIFO基本运算顺序：链队：队空：front=rear队满：front=(rear+1)%MAXSIZE队空：frontrear ∧初始化 判空 进队 出队取队首元素第五章 数组和广义表 复习串存储结构运 算概 念顺序串链表串定义：由n(≥1)个字符组成的有限序列 S=”c 1c 2c 3 ……cn ”串长度、空白串、空串。

数据结构教材出版社：清华大学出版社作者：严蔚敏吴伟民ISBN ：978-7-302-02368-5目录第1章绪论1.1 什么是数据结构1.2 基本概念和术语1.3 抽象数据类型的表现与实现1.4 算法和算法分析第2章线性表2.1 线性表的类型定义2.2 线性表的顺序表示和实现2.3 线性表的链式表示和实现2.4 一元多项式的表示及相加第3章栈和队列3.1 栈3.2 栈的应有和举例3.3 栈与递归的实现3.4 队列3.5 离散事件模拟第4章串4.1 串类型的定义4.2 串的表示和实现4.3 串的模式匹配算法4.4 串操作应用举例第5章数组和广义表5.1 数组的定义5.2 数组的顺序表现和实现5.3 矩阵的压缩存储5.4 广义表的定义5.5 广义表的储存结构5.6 m元多项式的表示5.7 广义表的递归算法第6章树和二叉树6.1 树的定义和基本术语6.2 二叉树6.2.1 二叉树的定义6.2.2 二叉树的性质6.2.3 二叉树的存储结构6.3 遍历二叉树和线索二叉树6.3.1 遍历二叉树6.3.2 线索二叉树6.4 树和森林6.4.1 树的存储结构6.4.2 森林与二叉树的转换6.4.3 树和森林的遍历6.5 树与等价问题6.6 赫夫曼树及其应用6.6.1 最优二叉树（赫夫曼树）6.6.2 赫夫曼编码6.7 回溯法与树的遍历6.8 树的计数第7章图7.1 图的定义和术语7.2 图的存储结构7.2.1 数组表示法7.2.2 邻接表7.2.3 十字链表7.2.4 邻接多重表7.3 图的遍历7.3.1 深度优先搜索7.3.2 广度优先搜索7.4 图的连通性问题7.4.1 无向图的连通分量和生成树7.4.2 有向图的强连通分量7.4.3 最小生成树7.4.4 关节点和重连通分量7.5 有向无环图及其应用7.5.1 拓扑排序7.5.2 关键路径7.6 最短路径7.6.1 从某个源点到其余各顶点的最短路径7.6.2 每一对顶点之间的最短路径第8章动态存储管理8.1 概述8.2 可利用空间表及分配方法8.3 边界标识法8.3.1 可利用空间表的结构8.3.2 分配算法8.3.3 回收算法8.4 伙伴系统8.4.1 可利用空间表的结构8.4.2 分配算法8.4.3 回收算法8.5 无用单元收集8.6 存储紧缩第9章查找9.1 静态查找表9.1.1 顺序表的查找9.1.2 有序表的查找9.1.3 静态树表的查找9.1.4 索引顺序表的查找9.2 动态查找表9.2.1 二叉排序树和平衡二叉树9.2.2 B树和B+树9.2.3 键树9.3 哈希表9.3.1 什么是哈希表9.3.2 哈希函数的构造方法9.3.3 处理冲突的方法9.3.4 哈希表的查找及其分析第10章内部排序10.1 概述10.2 插入排序10.2.1 直接插入排序10.2.2 其他插入排序10.2.3 希尔排序10.3 快速排序10.4 选择排序10.4.1 简单选择排序10.4.2 树形选择排序10.4.3 堆排序10.5 归并排序10.6 基数排序10.6.1 多关键字的排序10.6.2 链式基数排序10.7 各种内部排序方法的比较讨论第11章外部排序11.1 外存信息的存取11.2 外部排序的方法11.3 多路平衡归并的实现11.4 置换一选择排序11.5 最佳归并树第12章文件12.1 有关文件的基本概念12.2 顺序文件12.3 索引文件12.4 ISAM文件和VSAM文件12.4.1 ISAM文件12.4.2 VSAM文件12.5 直接存取文件（散列文件）12.6 多关键字文件12.6.1 多重表文件12.6.2 倒排文件附录A 名词索引附录B 函数索引参考书目。

严蔚敏课后习题第六章答案严蔚敏课后习题第六章答案第一题：什么是数据结构？数据结构是计算机科学中研究数据组织和存储方式的一门学科。

它关注如何将数据以合适的方式组织和存储，以便能够高效地访问和操作数据。

第二题：数据结构的分类有哪些？数据结构可以分为线性结构和非线性结构两大类。

线性结构包括数组、链表、栈和队列等，它们的特点是数据元素之间存在一对一的关系。

非线性结构包括树和图等，它们的特点是数据元素之间存在一对多或多对多的关系。

第三题：什么是数组？数组是一种线性结构，它由相同类型的数据元素组成，这些元素在内存中按照一定的顺序连续存储。

第四题：什么是链表？链表是一种线性结构，它由一系列节点组成，每个节点包含数据元素和指向下一个节点的指针。

第五题：数组和链表的区别是什么？数组和链表的主要区别在于数据存储方式和操作的效率。

数组的元素在内存中连续存储，可以通过下标直接访问任意位置的元素，插入和删除元素的操作比较耗时，需要移动其他元素。

链表的节点在内存中不连续存储，只能通过指针进行访问，插入和删除元素的操作比较快速，只需要改变指针的指向。

第六题：什么是栈？栈是一种特殊的线性结构，它只允许在一端进行插入和删除操作，这一端被称为栈顶。

栈的特点是后进先出，即最后插入的元素最先删除。

栈的应用场景包括函数调用、表达式求值和括号匹配等。

第七题：什么是队列？队列是一种特殊的线性结构，它只允许在一端进行插入操作，在另一端进行删除操作，这一端被称为队尾，另一端被称为队头。

队列的特点是先进先出，即最先插入的元素最先删除。

队列的应用场景包括排队、消息传递和广度优先搜索等。

第八题：什么是树？树是一种非线性结构，它由节点和边组成，每个节点可以有多个子节点。

树的特点是层次结构，根节点位于最上方，叶子节点位于最下方。

树的应用场景包括文件系统、数据库索引和组织结构等。

第九题：什么是图？图是一种非线性结构，它由顶点和边组成，每个顶点可以与其他顶点相连。

第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 试画出与下列程序段等价的框图。

第一章绪论一、选择题1.组成数据的基本单位是A数据项B数据类型C数据元素D数据变量2.数据结构是研究数据的以及它们之间的相互关系;A理想结构,物理结构B理想结构,抽象结构C物理结构,逻辑结构D抽象结构,逻辑结构3.在数据结构中,从逻辑上可以把数据结构分成A动态结构和静态结构B紧凑结构和非紧凑结构C线性结构和非线性结构D内部结构和外部结构4.数据结构是一门研究非数值计算的程序设计问题中计算机的①以及它们之间的②和运算等的学科;① A数据元素B计算方法C逻辑存储D数据映像② A结构B关系C运算D算法5.算法分析的目的是;A 找出数据结构的合理性B研究算法中的输入和输出的关系C分析算法的效率以求改进D分析算法的易懂性和文档性6.计算机算法指的是①,它必须具备输入、输出和②等5个特性;① A计算方法B排序方法C解决问题的有限运算序列D调度方法② A可执行性、可移植性和可扩充性B可行性、确定性和有穷性C确定性、有穷性和稳定性D易读性、稳定性和安全性二、判断题1.数据的机内表示称为数据的存储结构;2.算法就是程序;3.数据元素是数据的最小单位;4.算法的五个特性为：有穷性、输入、输出、完成性和确定性;5.算法的时间复杂度取决于问题的规模和待处理数据的初态;三、填空题1.数据逻辑结构包括________、________、_________ 和_________四种类型,其中树形结构和图形结构合称为_____;2.在线性结构中,第一个结点____前驱结点,其余每个结点有且只有______个前驱结点；最后一个结点______后续结点,其余每个结点有且只有_______个后续结点;3.在树形结构中,树根结点没有_______结点,其余每个结点有且只有_______个前驱结点；叶子结点没有________结点,其余每个结点的后续结点可以_________;4.在图形结构中,每个结点的前驱结点数和后续结点数可以_________;5.线性结构中元素之间存在________关系,树形结构中元素之间存在______关系,图形结构中元素之间存在_______关系;6.算法的五个重要特性是_______、_______、______、_______、_______;7.数据结构的三要素是指______、_______和________;8.链式存储结构与顺序存储结构相比较,主要优点是________________________________;9.设有一批数据元素,为了最快的存储某元素,数据结构宜用_________结构,为了方便插入一个元素,数据结构宜用____________结构;四、算法分析题1.求下列算法段的语句频度及时间复杂度参考答案：一、选择题1. C 3. C 4. A、B 5. C 、B二、判断题:1、√2、×3、×4、×5、√三、填空题1、线性、树形、图形、集合；非线性网状2、没有；1；没有；13、前驱；1；后继；任意多个4、任意多个5、一对一；一对多；多对多6、有穷性；确定性；可行性；输入；输出7、数据元素；逻辑结构；存储结构8、插入、删除、合并等操作较方便9、顺序存储；链式存储四、算法分析题fori=1; i<=n; i++forj =1; j <=i ; j++x=x+1;分析：该算法为一个二重循环,执行次数为内、外循环次数相乘,但内循环次数不固定,与外循环有关,因些,时间频度Tn=1+2+3+…+n=nn+1/2有1/4≤Tn/n2≤1,故它的时间复杂度为Ｏn2, 即Ｔn与n2 数量级相同; 2、分析下列算法段的时间频度及时间复杂度for i=1;i<=n;i++for j=1;j<=i;j++for k=1;k<=j;k++x=i+j-k;分析算法规律可知时间频度Tn=1+1+2+1+2+3+...+1+2+3+…+n由于有1/6 ≤ Tn/ n3 ≤1,故时间复杂度为Ｏn3第二章线性表一、选择题1.一个线性表第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是A110 B108C100 D1202. 向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变,平均要移动个元素;A64B63 C D73.线性表采用链式存储结构时,其地址;A 必须是连续的B 部分地址必须是连续的C 一定是不连续的D 连续与否均可以4. 在一个单链表中,若p所指结点不是最后结点,在p之后插入s所指结点,则执行As->next=p;p->next=s; B s->next=p->next;p->next=s;Cs->next=p->next;p=s; Dp->next=s;s->next=p;5.在一个单链表中,若删除p所指结点的后续结点,则执行Ap->next=p->next->next; Bp=p->next; p->next=p->next->next;Cp->next=p->next; Dp =p->next->next;6.下列有关线性表的叙述中,正确的是A线性表中的元素之间隔是线性关系B线性表中至少有一个元素C线性表中任何一个元素有且仅有一个直接前趋D线性表中任何一个元素有且仅有一个直接后继7.线性表是具有n个的有限序列n≠0A表元素B字符C数据元素D数据项二、判断题1.线性表的链接存储,表中元素的逻辑顺序与物理顺序一定相同;2.如果没有提供指针类型的语言,就无法构造链式结构;3.线性结构的特点是只有一个结点没有前驱,只有一个结点没有后继,其余的结点只有一个前驱和后继;4.语句p=p->next完成了指针赋值并使p指针得到了p指针所指后继结点的数据域值;5.要想删除p指针的后继结点,我们应该执行q=p->next ；p->next=q->next；freeq;三、填空题1.已知P为单链表中的非首尾结点,在P结点后插入S结点的语句为：_______________________ ;2.顺序表中逻辑上相邻的元素物理位置相邻, 单链表中逻辑上相邻的元素物理位置_________相邻;3.线性表L＝a1,a2,...,an采用顺序存储,假定在不同的n＋1个位置上插入的概率相同,则插入一个新元素平均需要移动的元素个数是________________________4.在非空双向循环链表中,在结点q的前面插入结点p的过程如下：p->prior=q->prior;q->prior->next=p;p->next=q;______________________;5.已知L是无表头结点的单链表,是从下列提供的答案中选择合适的语句序列,分别实现：1表尾插入s结点的语句序列是_______________________________2 表尾插入s结点的语句序列是_______________________________1.p->next=s;2.p=L;3.L=s;4.p->next=s->next;5.s->next=p->next;6.s->next=L;7.s->next=null;8.whilep->next= Q p=p-next;9.whilep->next=null p=p->next;四、算法设计题1.试编写一个求已知单链表的数据域的平均值的函数数据域数据类型为整型;2.已知带有头结点的循环链表中头指针为head,试写出删除并释放数据域值为x的所有结点的c函数;3.某百货公司仓库中有一批电视机,按其价格从低到高的次序构成一个循环链表,每个结点有价格、数量和链指针三个域;现出库销售m台价格为h的电视机,试编写算法修改原链表;4.某百货公司仓库中有一批电视机,按其价格从低到高的次序构成一个循环链表,每个结点有价格、数量和链指针三个域;现新到m台价格为h的电视机,试编写算法修改原链表;5.线性表中的元素值按递增有序排列,针对顺序表和循环链表两种不同的存储方式,分别编写C函数删除线性表中值介于a与ba≤b之间的元素;6.设A=a0,a1,a2,...,an-1,B=b0,b1,b2,...,bm-1是两个给定的线性表,它们的结点个数分别是n和m,且结点值均是整数;若n=m,且ai= bi 0≤i<n ,则A=B；若n<m ,且ai=bi 0≤i<n ,则A<B；若存在一个j, j<m ,j<n ,且ai=bi 0≤i<j , 若aj<bj,则A<B,否则A>B;试编写一个比较A和B的C函数,该函数返回-1或0或1,分别表示A<B或A=B或A>B;7.试编写算法,删除双向循环链表中第k个结点;8.线性表由前后两部分性质不同的元素组成a0,a1,...,an-1,b0,b1,...,bm-1,m和n为两部分元素的个数,若线性表分别采用数组和链表两种方式存储,编写算法将两部分元素换位成b0,b1,...,bm-1,a0,a1,...,an-1,分析两种存储方式下算法的时间和空间复杂度;9.用循环链表作线性表a0,a1,...,an-1和b0,b1,...,bm-1的存储结构,头指针分别为ah和bh,设计C函数,把两个线性表合并成形如a0,b0,a1,b1,…的线性表,要求不开辟新的动态空间,利用原来循环链表的结点完成合并操作,结构仍为循环链表,头指针为head,并分析算法的时间复杂度;10.试写出将一个线性表分解为两个带有头结点的循环链表,并将两个循环链表的长度放在各自的头结点的数据域中的C函数;其中,线性表中序号为偶数的元素分解到第一个循环链表中,序号为奇数的元素分解到第二个循环链表中;11.试写出把线性链表改为循环链表的C函数;12.己知非空线性链表中x结点的直接前驱结点为y,试写出删除x结点的C函数;参考答案：一、选择题1. B 3. D 4. B 5. A 7、C二、判断题:参考答案：1、×2、√3、×4、×5、√三、填空题1、s->next=p->next; p->next=s;2、一定；不一定3、n/24、q->prior=p;5、16 32 2 91 7四、算法设计题1、include ""include ""typedef struct node{int data;struct node link;}NODE;int averNODE head{int i=0,sum=0,ave; NODE p;p=head;whilep=NULL{p=p->link;++i;sum=sum+p->data;}ave=sum/i;return ave;}2、include ""include ""typedef struct node{int data; / 假设数据域为整型/struct node link;}NODE;void del_linkNODE head,int x / 删除数据域为x的结点/ {NODE p,q,s;p=head;q=head->link;whileq=head{ifq->data==x{p->link=q->link;s=q;q=q->link;frees;}else{p=q;q=q->link;}}}3、void delNODE head,float price,int num {NODE p,q,s;p=head;q=head->next;whileq->price<price&&q=head{p=q;q=q->next;}ifq->price==priceq->num=q->num-num; elseprintf"无此产品"; ifq->num==0{p->next=q->next; freeq;}}4、include ""include ""typedef struct node {float price;int num;struct node next;}NODE;void insNODE head,float price,int num {NODE p,q,s;p=head;q=head->next;whileq->price<price&&q=head{p=q;q=q->next;}ifq->price==priceq->num=q->num+num;else{s=NODE mallocsizeofNODE;s->price=price;s->num=num;s->next=p->next;p->next=s;}}5、顺序表：算法思想：从0开始扫描线性表,用k记录下元素值在a与b之间的元素个数,对于不满足该条件的元素,前移k个位置,最后修改线性表的长度;void delelemtype list,int n,elemtype a,elemtype b{int i=0,k=0；whilei<n{iflisti>=a&&listi<=b k++;elselisti-k=listi;i++;}n=n-k; / 修改线性表的长度/}循环链表:void delNODE head,elemtype a,elemtype b{NODE p,q;p= head;q=p->link; / 假设循环链表带有头结点/ whileq=head && q->data<a{p=q;q=q->link;}whileq=head && q->data<b{r=q;q=q->link;freer;}ifp=qp->link=q;}6、define MAXSIZE 100int listAMAXSIZE,listBMAXSIZE; int n,m;int compareint a,int b{int i=0;whileai==bi&&i<n&&i<mi++;ifn==m&&i==n return0;ifn<m&&i==n return-1;ifn>m&&i==m return1;ifi<n&&i<mifai<bi return-1;else ifai>bi return1;}7、void delDUNODE head,int i{DUNODE p;{head=head->next;head->prior=NULL;return0;}Else{forj=0;j<i&&p=NULL;j++p=p->next;ifp==NULL||j>i return1;p->prior->next=p->next;p->next->prior=p->proir;freep;return0;}8.顺序存储:void convertelemtype list,int l,int h / 将数组中第l个到第h个元素逆置/ {elemtype temp;fori=h;i<=l+h/2;i++{temp=listi;listi=listl+h-i;listl+h-i=temp;}}void exchangeelemtype list,int n,int m; {convertlist,0,n+m-1;convertlist,0,m-1;convertlist,m,n+m-1;}该算法的时间复杂度为On+m,空间复杂度为O1 链接存储:不带头结点的单链表typedef struct node{elemtype data;struct node link;}NODE;void convertNODE head,int n,int m{NODE p,q,r;int i;p=head;q=head;fori=0;i<n-1;i++q=q->link; /q指向an-1结点/r=q->link;q->link=NULL;whiler->link=NULLr=r->link; /r指向最后一个bm-1结点/head=q;r->link=p;}该算法的时间复杂度为On+m,但比顺序存储节省时间不需要移动元素,只需改变指针,空间复杂度为O1typedef struct node{elemtype data;struct node link;}NODE;NODE unionNODE ah,NODE bh {NODE a,b,head,r,q;head=ah;a=ah;b=bh;whilea->link=ah&&b->link=bh {r=a->link;q=b->link;a->link=b;b->link=r;a=r;}ifa->link==ah /a的结点个数小于等于b的结点个数/{a->link=b;whileb->link=bhb=b->link;b->link=head;}ifb->link==bh /b的结点个数小于a的结点个数/{r=a->link;a->link=b;b->link=r;}returnhead;}该算法的时间复杂度为On+m,其中n和m为两个循环链表的结点个数.10.typedef struct node{elemtype data;struct node link;}NODE;void analyzeNODE a{NODE rh,qh,r,q,p；int i=0,j=0；/i为序号是奇数的结点个数j为序号是偶数的结点个数/ p=a；rh=NODE mallocsizeofNODE；/rh为序号是奇数的链表头指针/qh=NODE mallocsizeofNODE; /qh为序号是偶数的链表头指针/r=rh;q=qh;whilep=NULL{r->link=p;r=p;i++;p=p->link;ifp=NULL{q->link=p;q=p;j++;p=p->link;}}rh->data=i;r->link=rh;qh->data=j;q->link=qh;}11.typedef struct node {elemtype data;struct node link;}NODE;void changeNODE head {NODE p;p=head;ifhead=NULL{whilep->link=NULLp=p->link;p->link=head;}}12.typedef struct node {elemtype data;struct node link;}NODE;void delNODE x,NODE y{NODE p,q;elemtype d1;p=y;q=x;whileq->next=NULL / 把后一个结点数据域前移到前一个结点/ {p->data=q->data;q=q->link;p=q;p->link=NULL; / 删除最后一个结点/freeq;}第三章栈和队列一、选择题1. 一个栈的入栈序列是a,b,c,d,e,则栈的不可能的输出序列是;A edcbaBdecbaCdceab Dabcde2.栈结构通常采用的两种存储结构是;A 线性存储结构和链表存储结构B散列方式和索引方式C链表存储结构和数组D线性存储结构和非线性存储结构3.判定一个栈ST最多元素为m0为空的条件是;A ST-〉top=0 BST-〉top==0CST-〉top=m0 DST-〉top=m04.判定一个栈ST最多元素为m0为栈满的条件是;AST->top=0 BST->top==0CST->top=m0-1DST->top==m0-15.一个队列的入列序列是1,2,3,4,则队列的输出序列是;A4,3,2,1B1,2,3,4C1,4,3,2D3,2,4,16.循环队列用数组A0,m-1存放其元素值,已知其头尾指针分别是front和rear则当前队列中的元素个数是Arear-front+m%m B rear-front+1 Crear-front-1Drear-front7.栈和队列的共同点是A 都是先进后出B都是先进先出C只允许在端点处插入和删除元素D没有共同点8.表达式ab+c-d的后缀表达式是;Aabcd+-Babc+d- Cabc+d-D-+abcd个元素a1,a2,a3和a4依次通过一个栈,在a4进栈前,栈的状态,则不可能的出栈序是Aa4,a3,a2,a1 Ba3,a2,a4,a1Ca3,a1,a4,a2 Da3,a4,a2,a110.以数组Q0..m－1存放循环队列中的元素,变量rear和qulen分别指示循环队列中队尾元素的实际位置和当前队列中元素的个数,队列第一个元素的实际位置是Arear－qulen Brear－qulen＋mCm－qulen D1＋rear＋m－qulen% m二、填空题1.栈的特点是_______________________,队列的特点是__________________________;2.线性表、栈和队列都是_____________________结构,可以在线性表的______________位置插入和删除元素,对于栈只能在________插入和删除元素,对于队列只能在_______插入元素和_________删除元素;3.一个栈的输入序列是12345,则栈有输出序列12345是____________;正确/错误4.设栈S和队列Q的初始状态皆为空,元素a1,a2,a3,a4,a5和a6依次通过一个栈,一个元素出栈后即进入队列Q,若6个元素出队列的顺序是a3,a5,a4,a6,a2,a1则栈S至少应该容纳_____个元素;三、算法设计题1.假设有两个栈s1和s2共享一个数组stackM,其中一个栈底设在stack0处,另一个栈底设在stackM-1处;试编写对任一栈作进栈和出栈运算的C函数pushx,i和popi,i=l,2;其中i=1表示左边的栈,,i=2表示右边的栈;要求在整个数组元素都被占用时才产生溢出;2.利用两个栈s1,s2模拟一个队列时,如何用栈的运算来实现该队列的运算写出模拟队列的插入和删除的C函数;一个栈s1用于插入元素,另一个栈s2用于删除元素.参考答案：一、选择题1. C 3. B 4. B 5. B 7、C 8、C 9、C 10、D二、填空题1、先进先出；先进后出2、线性；任何；栈顶；队尾；对头3、正确的4、3三、算法设计题1.define M 100elemtype stackM;int top1=0,top2=m-1;int pushelemtype x,int i{iftop1-top2==1 return1; /上溢处理/elseifi==1 stacktop1++=x;ifi==2stacktop2--=x;return0;}int popelemtype px,int iifi==1iftop1==0 return1; else{top1--;px=stacktop1;return0;}elseifi==2iftop2==M-1 return1; else{top2++;px=stacktop2;return0;}}elemtype s1MAXSIZE,s2MAZSIZE; int top1,top2;void enqueueelemtype x{iftop1==MAXSIZE return1;else{pushs1,x;return0;}}void dequeueelemtype px{elemtype x;top2=0;whileemptys1{pops1,&x;pushs2,x;pops2,&x;whileemptys2{pops2,&x;pushs1,x;}}第四章串一、选择题1.下列关于串的叙述中,正确的是A一个串的字符个数即该串的长度B一个串的长度至少是1C空串是由一个空格字符组成的串D两个串S1和S2若长度相同,则这两个串相等2.字符串"abaaabab"的nextval值为A0,1,01,1,0,4,1,0,1 B0,1,0,0,0,0,2,1,0,1C0,1,0,1,0,0,0,1,1 D0,1,0,1,0,1,0,1,13.字符串满足下式,其中head和tail的定义同广义表类似,如head‘xyz’=‘x’,tail‘xyz’= ‘yz’,则s= ; concatheadtails,headtailtails= ‘dc’; Aabcd Bacbd Cacdb Dadcb4.串是一种特殊的线性表,其特殊性表现在A可以顺序存储B数据元素是一个字符C可以链式存储D数据元素可以是多个字符5．设串S1=‘ABCDEFG’,s2=‘PQRST’,函数CONCATX,Y返回X和Y串的连接串,SUBSTRS,I,J 返回串S从序号I开始的J个字符组成的字串,LENGTHS返回串S的长度,则CONCATSUBSTRS1,2,LENGTHS2,SUBSTRS1,LENGTHS2,2的结果串是ABCDEF B BCDEFG CBCPQRST DBCDEFEF二、算法设计1.分别在顺序存储和一般链接存储两种方式下,用C语言写出实现把串s1复制到串s2的串复制函数strcpys1,s2;2.在一般链接存储一个结点存放一个字符方式下,写出采用简单算法实现串的模式匹配的C 语言函数int L_indext,p;参考答案：一、选择题1. A 3. D 4. D 5. D二、算法设计1.顺序存储：include ""define MAXN 100char sMAXN;int S_strlenchar s{int i;fori=0;si='\0';i++;returni;}void S_strcpychar s1,char s2 include "" typedef struct node{char data;struct node link;}NODE;int L_indexNODE t,NODE p{NODE t1,p1,t2;int i;t1=t;i=1;whilet1=NULL{p1=p;t2=t1->link;whilep1->data==t1->data&&p1=NULL{p1=p1->link;t1=t1->link;}ifp1==NULL returni;i++;t1=t2;}return0;}第五章数组和广义表一、选择题1. 常对数组进行的两种基本操作是A建立与删除B索引和修改C查找和修改D查找与索引2.二维数组M的元素是4个字符每个字符占一个存储单元组成的串,行下标i的范围从0到4,列下标j的范围从0到5,M按行存储时元素M35的起始地址与M按列存储时元素的起始地址相同;AM24BM34CM35DM443.数组A810中,每个元素A的长度为3个字节,从首地址SA开始连续存放在存储器内,存放该数组至少需要的单元数是;A80B100C240D2704.数组A810中,每个元素A的长度为3个字节,从首地址SA开始连续存放在存储器内,该数组按行存放时,元素A74的起始地址为;ASA+141BSA+144CSA+222DSA+2255.数组A810中,每个元素A的长度为3个字节,从首地址SA开始连续存放在存储器内,该数组按列存放时,元素A47的起始地址为;ASA+141BSA+180CSA+222DSA+2256.稀疏矩阵一般的压缩存储方法有两种,即;A 二维数组和三维数组B三元组和散列C三元组和十字链表D散列和十字链表7.若采用三元组压缩技术存储稀疏矩阵,只要把每个元素的行下标和列下标互换,就完成了对该矩阵的转置运算,这种观点;A正确B错误8.设矩阵A是一个对称矩阵,为了节省存储,将其下三角部分按行序存放在一维数组B1,nn-1/2中,对下三角部分中任一元素ai,ji<=j,在一组数组B的下标位置k的值是;Aii-1/2+j-1Bii-1/2+jCii+1/2+j-1 Dii+1/2+j二、填空题1.己知二维数组Amn采用行序为主方式存储,每个元素占k个存储单元,并且第一个元素的存储地址是LOCA00,则A00的地址是_____________________;2.二维数组A1020采用列序为主方式存储,每个元素占一个存储单元,并且A00的存储地址是200,则A612的地址是________________;3.有一个10阶对称矩阵A,采用压缩存储方式以行序为主,且A00=1,则A85的地址是__________________;4.设n行n列的下三角矩阵A已压缩到一维数组S1..nn+1/2中,若按行序为主存储,则Aij对应的S中的存储位置是________________;5.若A是按列序为主序进行存储的4×6的二维数组,其每个元素占用3个存储单元,并且A00的存储地址为1000,元素A13的存储地址为___________,该数组共占用_______________个存储单元;三、算法设计1.如果矩阵A中存在这样的一个元素Aij满足条件:Aij是第i行中值最小的元素,且又是第j 列中值最大的元素,则称之为该矩阵的一个马鞍点;编写一个函数计算出1×n的矩阵A的所有马鞍点;只猴子要选大王,选举办法如下:所有猴子按1,2,...,n编号围坐一圈,从1号开始按1、2、...、m报数,凡报m号的退出到圈外,如此循环报数,直到圈内剩下只猴子时,这只猴子就是大王;n 和m由键盘输入,打印出最后剩下的猴子号;编写一程序实现上述函数;3.数组和广义表的算法验证程序编写下列程序:1求广义表表头和表尾的函数head和tail;2计算广义表原子结点个数的函数count_GL;3计算广义表所有原子结点数据域设数据域为整型〉之和的函数sum_GL;参考答案：一、选择题1. C 3. C 4. C 5. B 7、B 8、B二、填空题1、locA00+ni+jk2、3323、424、ii+1/2+j+15、1039；72三、算法设计题1.算法思想：依题意,先求出每行的最小值元素,放入minm之中,再求出每列的最大值元素,放入maxn之中,若某元素既在mini中,又在maxj中,则该元素Aij便是马鞍点,找出所有这样的元素,即找到了所有马鞍点;因此,实现本题功能的程序如下:include <>define m 3define n 4void minmaxint amn{int i1,j,have=0;int minm,maxn;fori1=0;i1<m;i1++/计算出每行的最小值元素,放入minm之中/{mini1=ai10;forj=1;j<n;j++ifai1j<mini1 mini1=ai1j;}forj=0;j<n;j++/计算出每列的最大值元素,放入maxn之中/{maxj=a0j;fori1=1;i1<m;i1++ifai1j>max j maxj=ai1j;}fori1=0;i1<m;i1++forj=0;j<n;j++ifmini1==maxj{printf"%d,%d:%d\n",i1,j,ai1j;have=1;}ifhave printf"没有鞍点＼n";}2.算法思想:本题用一个含有n个元素的数组a,初始时ai中存放猴子的编号i,计数器似的值为0;从ai开始循环报数,每报一次,计数器的值加1,凡报到m时便打印出ai值退出圈外的猴子的编号,同时将ai的值改为O以后它不再参加报数,计数器值重新置为0;该函数一直进行到n 只猴子全部退出圈外为止,最后退出的猴子就是大王;因此,现本题功能的程序如下:include ""main{int a100;int count,d,j,m,n; scanf"%d %d",&m,&n;/ n>=m/ forj=0;j<n;j++aj=j+1;count=0;d=0;whiled<nforj=0;j<n;j++ifaj=0{count++;ifcount==m{printf"% d ",aj;aj=0;count=0;}}}3.include ""include ""typedef struct node { int tag;union{struct node sublist; char data;}dd;struct node link;}NODE;NODE creat_GLchar s {NODE h;char ch;s++;ifch='\0'{h=NODEmallocsizeofNODE; ifch==''{h->tag=1;h->=creat_GLs;}Else{h->tag=0;h->=ch;}}elseh=NULL;ch=s;s++;ifh=NULLifch==','h->link =creat_GLs; elseh->link=NULL; returnh;}void prn_GLNODE p {ifp=NULL{ifp->tag==1{printf"";ifp-> ==NULL printf" ";elseprn_GLp-> ;}elseprintf"%c",p->;ifp->tag==1printf"";ifp->link=NULL{printf",";prn_GLp->link;}}}NODE copy_GLNODE p{NODE q;ifp==NULL returnNULL;q=NODE mallocsizeofNODE; q->tag=p->tag;ifp->tagq-> =copy_GLp-> ;elseq-> =p->;q->link=copy_GLp->link;returnq;}NODE headNODE p /求表头函数/{returnp->;}NODE tailNODE p /求表尾函数/{returnp->link;}int sumNODE p /求原子结点的数据域之和函数/ { int m,n;ifp==NULL return0;else{ ifp->tag==0 n=p->;elsen=sump->;ifp->link=NULLm=sump->link;else m=0;returnn+m;}}int depthNODE p /求表的深度函数/ {int h,maxdh;NODE q;ifp->tag==0 return0;elseifp->tag==1&&p->==NULL return 1; else{maxdh=0;whilep=NULL{ifp->tag==0 h=0; else{q=p->;h=depthq;}ifh>maxdhmaxdh=h; p=p->link;}returnmaxdh+1;}}main{NODE hd,hc;char s100,p;p=getss;hd=creat_GL&p; prn_GLheadhd;prn_GLtailhd;hc=copy_GLhd;printf"copy after:";prn_GLhc;printf"sum:%d\n",sumhd;printf"depth:%d\n",depthhd;}第六章树和二叉树一、选择题1.在线索化二叉树中,t所指结点没有左子树的充要条件是At-〉left==NULL Bt-〉ltag==1Ct-〉ltag=1且t-〉left=NULLD以上都不对2.二叉树按某种顺序线索化后,任一结点均有指向其前趋和后继的线索,这种说法A正确B错误C不同情况下答案不确定3.二叉树的前序遍历序列中,任意一个结点均处在其子女结点的前面,这种说法A正确B错误C不同情况下答案不确定4.由于二叉树中每个结点的度最大为2,所以二叉树是一种特殊的树,这种说法A正确B错误C不同情况下答案不确定5.设高度为h的二叉树上只有度为0和度为2的结点,则此类二叉树中所包含的结点数至少为;A2h B2h-1C2h+1Dh+16.已知某二叉树的后序遍历序列是dabec;中序遍历序列是debac,它的前序遍历序列是;Aacbed BdecabCdeabc Dcedba7.如果T2是由有序树T转换而来的二叉树,那么T中结点的前序就是T2中结点的A前序B中序C后序D层次序8.某二叉树的前序遍历结点访问顺序是abdgcefh,中序遍历的结点访问顺序是dgbaechf,则其后序遍历的结点访问顺序是;Abdgcefha Bgdbecfha Cbdgaechf Dgdbehfca9.二叉树为二叉排序树的充分必要条件是其任一结点的值均大于其左孩子的值、小于其右孩子的值;这种说法A正确B错误C不同情况下答案不确定10.按照二叉树的定义,具有3个结点的二叉树有种;A3B4C5D611.在一非空二叉树的中序遍历序列中,根结点的右边A只有右子树上的所有结点B只有右子树上的部分结点C只有左子树上的部分结点D只有左子树上的所有结点12.树最适合用来表示;A有序数据元素B无序数据元素C元素之间具有分支层次关系的数据D元素之间无联系的数据13.任何一棵二叉树的叶结点在先序、中序和后序遍历序列中的相对次序A不发生改变B发生改变C不能确定D.以上都不对14.实现任意二叉树的后序遍历的非递归算法而不使用栈结构,最佳方案是二叉树采用存储结构;A二叉链表B广义表存储结构C三叉链表D顺序存储结构15.对一个满二叉树,m个树叶,n个结点,深度为h,则An=h+m Bh+m=2nCm=h-1Dn=2h-116.如果某二叉树的前序为stuwv,中序为uwtvs,那么该二叉树的后序为Auwvts BvwutsCwuvts Dwutsv17.具有五层结点的二叉平衡树至少有个结点;A10B12C15D17二、判断题1.二叉树中任何一个结点的度都是2;2.由二叉树结点的先根序列和后根序列可以唯一地确定一棵二叉树;3.一棵哈夫曼树中不存在度为1的结点;4.平衡二叉排序树上任何一个结点的左、右子树的高度之差的绝对值不大于2三、填空题1.指出树和二叉树的三个主要差别___________,___________,_______________;2.从概念上讲,树与二叉树是两种不同的数据结构,将树转化为二叉树的基本目的是____________3.若结点A有三个兄弟包括A本身,并且B是A的双亲结点,B的度是_______________4.若一棵具有n个结点的二叉树采用标准链接存储结构,那么该二叉树所有结点共有_______个空指针域;5.已知二叉树的前序序列为ABDEGCFHIJ,中序序列为DBGEAHFIJC,写出后序序列_______________;6.已知二叉树的后序序列为FGDBHECA,中序序列为BFDGAEHC ,并写出前序序列_________________;7.找出满足下列条件的二叉树1先序和中序遍历,得到的结点访问顺序一样;_________________________2后序和中序遍历,得到的结点访问顺序一样;_________________________3先序和后序遍历,得到的结点访问顺序一样;__________________________8.一棵含有n个结点的k叉树,可能达到的最大深度和最小深度各是多少____________________9.一棵二叉树有67个结点,这些结点的度要么是0,要么是2;这棵二叉树中度为2的结点有______________________个;10.含有100个结点的树有_______________________________________条边;四、问答题1.一棵深度为h的满m叉树具有如下性质:第h层上的结点都是叶结点,其余各层上每个结点都有m棵非空子树;若按层次从上到下,每层从左到右的顺序从1开始对全部结点编号,试计算:1第k层结点数1≤k≤h;2整棵树结点数;3编号为i的结点的双亲结点的编号;4编号为i的结点的第j个孩子结点若有的编号;2.证明：一个满k叉树上的叶子结点数n0和非叶子结点数n1之间满足以下关系：n0=k-1n1+13.已知一组元素为50,28,78,65,23,36,13,42,71,请完成以下操作:1画出按元素排列顺序逐点插入所生成的二叉排序树BT;2分别计算在BT中查找各元素所要进行的元素间的比较次数及平均比较次数;3画出在BT中删除23〉后的二叉树;4.有七个带权结点,其权值分别为3,7,8,2,6,10,14,试以它们为叶结点构造一棵哈夫曼树请按照每个结点的左子树根结点的权小于等于右子树根结点的权的次序构造〉,并计算出带权路径长度WPL及该树的结点总数;5.有一电文共使用五种字符a,b,c,d,e,其出现频率依次为4,7,5,2,9;1试画出对应的编码哈夫曼树要求左子树根结点的权小于等于右子树根结点的权;2求出每个字符的晗夫曼编码;3求出传送电文的总长度;4并译出编码系列101的相应电文;五、算法设计已知一棵具有n个结点的完全二叉树被顺序存储在一维数组An中,试编写一个算法输出Ai结点的双亲和所有孩子;参考答案：一、选择题1. B 3. A 4. B 5. B 7、A 8、D 9、B 10、C 11、A 12、C 13、A 14、C 15、D 16、C 17 C。

数据结构c语言版严蔚敏课后习题答案数据结构是计算机科学中非常重要的一门学科，它研究的是数据的组织、存储和管理方式。

而C语言作为一种广泛应用于系统编程和嵌入式开发的高级编程语言，与数据结构的学习息息相关。

本文将针对《数据结构（C语言版）》严蔚敏教材的课后习题提供一些答案，希望能够帮助读者更好地理解和掌握数据结构。

第一章：绪论在第一章中，主要介绍了数据结构的基本概念和基本术语。

课后习题主要是一些概念性的问题，例如数据结构与算法的关系、数据的逻辑结构和物理结构等。

这些问题的答案可以通过仔细阅读教材中的相关内容来得到。

第二章：线性表线性表是数据结构中最基本、最常用的一种结构。

课后习题主要涉及线性表的基本操作，如插入、删除、查找等。

这些问题的答案可以通过编写相应的C语言代码来实现。

第三章：栈和队列栈和队列是线性表的特殊形式，具有后进先出（LIFO）和先进先出（FIFO）的特点。

课后习题主要涉及栈和队列的基本操作，如进栈、出栈、入队、出队等。

这些问题的答案同样可以通过编写相应的C语言代码来实现。

第四章：串串是由零个或多个字符组成的有限序列，是一种特殊的线性表。

课后习题主要涉及串的模式匹配、串的替换等操作。

这些问题的答案可以通过使用C语言的字符串处理函数来实现。

第五章：数组和广义表数组是一种线性表的顺序存储结构，广义表是线性表的扩展。

课后习题主要涉及数组和广义表的创建、访问和操作等。

这些问题的答案可以通过编写相应的C语言代码来实现。

第六章：树树是一种非线性的数据结构，具有层次关系。

课后习题主要涉及树的遍历、节点的插入和删除等操作。

这些问题的答案可以通过使用C语言的指针和递归来实现。

第七章：图图是一种非线性的数据结构，由节点和边组成。

课后习题主要涉及图的遍历、最短路径、最小生成树等操作。

这些问题的答案可以通过使用C语言的图算法来实现。

通过以上的简要介绍，读者可以了解到《数据结构（C语言版）》严蔚敏教材的课后习题主要涵盖了线性表、栈和队列、串、数组和广义表、树、图等各个方面。

数据结构（ 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 ’} ，学生基本信息表也可是一个数据对象。

数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。

换句话说，数据结构是带“结构”的数据元素的集合，“结构”就是指数据元素之间存在的关系。

逻辑结构：从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。

因此，数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。

存储结构：数据对象在计算机中的存储表示，也称为物理结构。

抽象数据类型：由用户定义的，表示应用问题的数学模型，以及定义在这个模型上的一组操作的总称。

具体包括三部分：数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。

第六章树和二叉树6.33int Is_Descendant_C(int u,int v)//在孩子存储结构上判断u是否v的子孙,是则返回1,否则返回0{if(u==v) return 1;else{if(L[v])if (Is_Descendant(u,L[v])) return 1;if(R[v])if (Is_Descendant(u,R[v])) return 1; //这是个递归算法}return 0;}//Is_Descendant_C6.34int Is_Descendant_P(int u,int v)//在双亲存储结构上判断u是否v的子孙,是则返回1,否则返回0{for(p=u;p!=v&&p;p=T[p]);if(p==v) return 1;else return 0;}//Is_Descendant_P6.35这一题根本不需要写什么算法,见书后注释:两个整数的值是相等的.6.36int Bitree_Sim(Bitree B1,Bitree B2)//判断两棵树是否相似的递归算法{if(!B1&&!B2) return 1;elseif(B1&&B2&&Bitree_Sim(B1->lchild,B2->lchild)&&Bitree_Sim(B1->rchild,B2->rc hild))return 1;else return 0;}//Bitree_Sim6.37void PreOrder_Nonrecursive(Bitree T)//先序遍历二叉树的非递归算法{InitStack(S);Push(S,T); //根指针进栈while(!StackEmpty(S)){while(Gettop(S,p)&&p){visit(p->data);push(S,p->lchild);} //向左走到尽头pop(S,p);if(!StackEmpty(S)){pop(S,p);push(S,p->rchild); //向右一步}}//while}//PreOrder_Nonrecursive6.38typedef struct {BTNode* ptr;enum {0,1,2} mark;} PMType; //有mark域的结点指针类型void PostOrder_Stack(BiTree T)//后续遍历二叉树的非递归算法,用栈{PMType a;InitStack(S); //S的元素为PMType类型Push (S,{T,0}); //根结点入栈while(!StackEmpty(S)){Pop(S,a);switch(a.mark){case 0:Push(S,{a.ptr,1}); //修改mark域if(a.ptr->lchild) Push(S,{a.ptr->lchild,0}); //访问左子树break;case 1:Push(S,{a.ptr,2}); //修改mark域if(a.ptr->rchild) Push(S,{a.ptr->rchild,0}); //访问右子树break;case 2:visit(a.ptr); //访问结点,返回}}//while}//PostOrder_Stack分析:为了区分两次过栈的不同处理方式,在堆栈中增加一个mark域,mark=0表示刚刚访问此结点,mark=1表示左子树处理结束返回,mark=2表示右子树处理结束返回.每次根据栈顶元素的mark域值决定做何种动作.6.39typedef struct {int data;EBTNode *lchild;EBTNode *rchild;EBTNode *parent;enum {0,1,2} mark;} EBTNode,EBitree; //有mark域和双亲指针域的二叉树结点类型void PostOrder_Nonrecursive(EBitree T)//后序遍历二叉树的非递归算法,不用栈{p=T;while(p)switch(p->mark){case 0:p->mark=1;if(p->lchild) p=p->lchild; //访问左子树break;case 1:p->mark=2;if(p->rchild) p=p->rchild; //访问右子树break;case 2:visit(p);p->mark=0; //恢复mark值p=p->parent; //返回双亲结点}}//PostOrder_Nonrecursive分析:本题思路与上一题完全相同,只不过结点的mark值是储存在结点中的,而不是暂存在堆栈中,所以访问完毕后要将mark域恢复为0,以备下一次遍历.6.40typedef struct {int data;PBTNode *lchild;PBTNode *rchild;PBTNode *parent;} PBTNode,PBitree; //有双亲指针域的二叉树结点类型void Inorder_Nonrecursive(PBitree T)//不设栈非递归遍历有双亲指针的二叉树{p=T;while(p->lchild) p=p->lchild; //向左走到尽头while(p){visit(p);if(p->rchild) //寻找中序后继:当有右子树时{p=p->rchild;while(p->lchild) p=p->lchild; //后继就是在右子树中向左走到尽头}else if(p->parent->lchild==p) p=p->parent; //当自己是双亲的左孩子时后继就是双亲else{p=p->parent;while(p->parent&&p->parent->rchild==p) p=p->parent;p=p->parent;} //当自己是双亲的右孩子时后继就是向上返回直到遇到自己是在其左子树中的祖先}//while}//Inorder_Nonrecursive6.41int c,k; //这里把k和计数器c作为全局变量处理void Get_PreSeq(Bitree T)//求先序序列为k的结点的值{if(T){c++; //每访问一个子树的根都会使前序序号计数器加1if(c==k){printf("Value is %d\n",T->data);exit (1);}else{Get_PreSeq(T->lchild); //在左子树中查找Get_PreSeq(T->rchild); //在右子树中查找}}//if}//Get_PreSeqmain(){...scanf("%d",&k);c=0; //在主函数中调用前,要给计数器赋初值0Get_PreSeq(T,k);...}//main6.42int LeafCount_BiTree(Bitree T)//求二叉树中叶子结点的数目{if(!T) return 0; //空树没有叶子else if(!T->lchild&&!T->rchild) return 1; //叶子结点else return Leaf_Count(T->lchild)+Leaf_Count(T->rchild);//左子树的叶子数加上右子树的叶子数}//LeafCount_BiTree6.43void Bitree_Revolute(Bitree T)//交换所有结点的左右子树{T->lchild<->T->rchild; //交换左右子树if(T->lchild) Bitree_Revolute(T->lchild);if(T->rchild) Bitree_Revolute(T->rchild); //左右子树再分别交换各自的左右子树}//Bitree_Revolute6.44int Get_Sub_Depth(Bitree T,int x)//求二叉树中以值为x的结点为根的子树深度{if(T->data==x){printf("%d\n",Get_Depth(T)); //找到了值为x的结点,求其深度exit 1;}else{if(T->lchild) Get_Sub_Depth(T->lchild,x);if(T->rchild) Get_Sub_Depth(T->rchild,x); //在左右子树中继续寻找}}//Get_Sub_Depthint Get_Depth(Bitree T)//求子树深度的递归算法{if(!T) return 0;else{m=Get_Depth(T->lchild);n=Get_Depth(T->rchild);return (m>n?m:n)+1;}//Get_Depth6.45void Del_Sub_x(Bitree T,int x)//删除所有以元素x为根的子树{if(T->data==x) Del_Sub(T); //删除该子树else{if(T->lchild) Del_Sub_x(T->lchild,x);if(T->rchild) Del_Sub_x(T->rchild,x); //在左右子树中继续查找}//else}//Del_Sub_xvoid Del_Sub(Bitree T)//删除子树T{if(T->lchild) Del_Sub(T->lchild);if(T->rchild) Del_Sub(T->rchild);free(T);}//Del_Sub6.46void Bitree_Copy_Nonrecursive(Bitree T,Bitree &U)//非递归复制二叉树{InitStack(S1);InitStack(S2);push(S1,T); //根指针进栈U=(BTNode*)malloc(sizeof(BTNode));U->data=T->data;q=U;push(S2,U);while(!StackEmpty(S)){while(Gettop(S1,p)&&p){q->lchild=(BTNode*)malloc(sizeof(BTNode));q=q->lchild;q->data=p->data;push(S1,p->lchild);push(S2,q);} //向左走到尽头pop(S1,p);pop(S2,q);if(!StackEmpty(S1)){pop(S1,p);pop(S2,q);q->rchild=(BTNode*)malloc(sizeof(BTNode));q=q->rchild;q->data=p->data;push(S1,p->rchild); //向右一步push(S2,q);}//while}//BiTree_Copy_Nonrecursive分析:本题的算法系从6.37改写而来.6.47void LayerOrder(Bitree T)//层序遍历二叉树{InitQueue(Q); //建立工作队列EnQueue(Q,T);while(!QueueEmpty(Q)){DeQueue(Q,p);visit(p);if(p->lchild) EnQueue(Q,p->lchild);if(p->rchild) EnQueue(Q,p->rchild);}}//LayerOrder6.48int found=FALSE;Bitree* Find_Near_Ancient(Bitree T,Bitree p,Bitree q)//求二叉树T中结点p和q的最近共同祖先{Bitree pathp[ 100 ],pathq[ 100 ] //设立两个辅助数组暂存从根到p,q的路径Findpath(T,p,pathp,0);found=FALSE;Findpath(T,q,pathq,0); //求从根到p,q的路径放在pathp和pathq中for(i=0;pathp[i]==pathq[i]&&pathp[i];i++); //查找两条路径上最后一个相同结点 return pathp[--i];}//Find_Near_Ancientvoid Findpath(Bitree T,Bitree p,Bitree path[ ],int i)//求从T到p路径的递归算法{if(T==p){found=TRUE;return; //找到}path[i]=T; //当前结点存入路径if(T->lchild) Findpath(T->lchild,p,path,i+1); //在左子树中继续寻找if(T->rchild&&!found) Findpath(T->rchild,p,path,i+1); //在右子树中继续寻找if(!found) path[i]=NULL; //回溯}//Findpathint IsFull_Bitree(Bitree T)//判断二叉树是否完全二叉树,是则返回1,否则返回0 {InitQueue(Q);flag=0;EnQueue(Q,T); //建立工作队列while(!QueueEmpty(Q)){DeQueue(Q,p);if(!p) flag=1;else if(flag) return 0;else{EnQueue(Q,p->lchild);EnQueue(Q,p->rchild); //不管孩子是否为空,都入队列}}//whilereturn 1;}//IsFull_Bitree分析:该问题可以通过层序遍历的方法来解决.与6.47相比,作了一个修改,不管当前结点是否有左右孩子,都入队列.这样当树为完全二叉树时,遍历时得到是一个连续的不包含空指针的序列.反之,则序列中会含有空指针.6.50Status CreateBitree_Triplet(Bitree &T)//输入三元组建立二叉树{if(getchar()!='^') return ERROR;T=(BTNode*)malloc(sizeof(BTNode));p=T;p->data=getchar();getchar(); //滤去多余字符InitQueue(Q);EnQueue(Q,T);while((parent=getchar())!='^'&&(child=getchar())&&(side=getchar())){while(QueueHead(Q)!=parent&&!QueueEmpty(Q)) DeQueue(Q,e);if(QueueEmpty(Q)) return ERROR; //未按层序输入p=QueueHead(Q);q=(BTNode*)malloc(sizeof(BTNode));if(side=='L') p->lchild=q;else if(side=='R') p->rchild=q;else return ERROR; //格式不正确q->data=child;EnQueue(Q,q);}return OK;}//CreateBitree_TripletStatus Print_Expression(Bitree T)//按标准形式输出以二叉树存储的表达式{if(T->data是字母) printf("%c",T->data);else if(T->data是操作符){if(!T->lchild||!T->rchild) return ERROR; //格式错误if(T->lchild->data是操作符&&T->lchild->data优先级低于T->data){printf("(");if(!Print_Expression(T->lchild)) return ERROR;printf(")");} //注意在什么情况下要加括号else if(!Print_Expression(T->lchild)) return ERROR;if(T->rchild->data是操作符&&T->rchild->data优先级低于T->data){printf("(");if(!Print_Expression(T->rchild)) return ERROR;printf(")");}else if(!Print_Expression(T->rchild)) return ERROR;}else return ERROR; //非法字符return OK;}//Print_Expression6.52typedef struct{BTNode node;int layer;} BTNRecord; //包含结点所在层次的记录类型int FanMao(Bitree T)//求一棵二叉树的"繁茂度"{int countd; //count数组存放每一层的结点数InitQueue(Q); //Q的元素为BTNRecord类型EnQueue(Q,{T,0});while(!QueueEmpty(Q)){DeQueue(Q,r);count[yer]++;if(r.node->lchild) EnQueue(Q,{r.node->lchild,yer+1});if(r.node->rchild) EnQueue(Q,{r.node->rchild,yer+1});} //利用层序遍历来统计各层的结点数h=yer; //最后一个队列元素所在层就是树的高度for(maxn=count[0],i=1;count[i];i++)if(count[i]>maxn) maxn=count[i]; //求层最大结点数return h*maxn;}//FanMao分析:如果不允许使用辅助数组,就必须在遍历的同时求出层最大结点数,形式上会复杂一些,你能写出来吗?6.53int maxh;Status Printpath_MaxdepthS1(Bitree T)//求深度等于树高度减一的最靠左的结点{Bitree pathd;maxh=Get_Depth(T); //Get_Depth函数见6.44if(maxh<2) return ERROR; //无符合条件结点Find_h(T,1);return OK;}//Printpath_MaxdepthS1void Find_h(Bitree T,int h)//寻找深度为maxh-1的结点{path[h]=T;if(h==maxh-1){for(i=1;path[i];i++) printf("%c",path[i]->data);exit; //打印输出路径}else{if(T->lchild) Find_h(T->lchild,h+1);if(T->rchild) Find_h(T->rchild,h+1);}path[h]=NULL; //回溯}//Find_h6.54Status CreateBitree_SqList(Bitree &T,SqList sa)//根据顺序存储结构建立二叉链表{Bitree ptr[st+1]; //该数组储存与sa中各结点对应的树指针if(!st){T=NULL; //空树return;}ptr[1]=(BTNode*)malloc(sizeof(BTNode));ptr[1]->data=sa.elem[1]; //建立树根T=ptr[1];for(i=2;i<=st;i++){if(!sa.elem[i]) return ERROR; //顺序错误ptr[i]=(BTNode*)malloc(sizeof(BTNode));ptr[i]->data=sa.elem[i];j=i/2; //找到结点i的双亲jif(i-j*2) ptr[j]->rchild=ptr[i]; //i是j的右孩子else ptr[j]->lchild=ptr[i]; //i是j的左孩子}return OK;}//CreateBitree_SqList6.55int DescNum(Bitree T)//求树结点T的子孙总数填入DescNum域中,并返回该数{if(!T) return -1;else d=(DescNum(T->lchild)+DescNum(T->rchild)+2); //计算公式T->DescNum=d;return d;}//DescNum分析:该算法时间复杂度为O(n),n为树结点总数.注意:为了能用一个统一的公式计算子孙数目,所以当T为空指针时,要返回-1而不是0.6.56BTNode *PreOrder_Next(BTNode *p)//在先序后继线索二叉树中查找结点p的先序后继,并返回指针{if(p->lchild) return p->lchild;else return p->rchild;}//PreOrder_Next分析:总觉得不会这么简单.是不是哪儿理解错了?6.57Bitree PostOrder_Next(Bitree p)//在后序后继线索二叉树中查找结点p的后序后继,并返回指针{if(p->rtag) return p->rchild; //p有后继线索else if(!p->parent) return NULL; //p是根结点else if(p==p->parent->rchild) return p->parent; //p是右孩子else if(p==p->parent->lchild&&p->parent->tag)return p->parent; //p是左孩子且双亲没有右孩子else //p是左孩子且双亲有右孩子{q=p->parent->rchild;while(!q->ltag||!q->rtag){if(!q->ltag) q=q->lchild;else q=q->rchild;} //从p的双亲的右孩子向下走到底return q;}//else}//PostOrder_Next6.58Status Insert_BiThrTree(BiThrTree &T,BiThrTree &p,BiThrTree &x)//在中序线索二叉树T的结点p下插入子树x{if(!p->ltag&&!p->rtag) return INFEASIBLE; //无法插入if(p->ltag) //x作为p的左子树{s=p->lchild; //s为p的前驱p->ltag=Link;p->lchild=x;q=x;while(q->lchild) q=q->lchild;q->lchild=s; //找到子树中的最左结点,并修改其前驱指向sq=x;while(q->rchild) q=q->rchild;q->rchild=p; //找到子树中的最右结点,并修改其前驱指向p}else //x作为p的右子树{s=p->rchild; //s为p的后继p->rtag=Link;p->rchild=x;q=x;while(q->rchild) q=q->rchild;q->rchild=s; //找到子树中的最右结点,并修改其前驱指向sq=x;while(q->lchild) q=q->lchild;q->lchild=p; //找到子树中的最左结点,并修改其前驱指向p}return OK;}//Insert_BiThrTree6.59void Print_CSTree(CSTree T)//输出孩子兄弟链表表示的树T的各边{for(child=T->firstchild;child;child=child->nextsib){printf("(%c,%c),",T->data,child->data);Print_CSTree(child);}}//Print_CSTree6.60int LeafCount_CSTree(CSTree T)//求孩子兄弟链表表示的树T的叶子数目{if(!T->firstchild) return 1; //叶子结点else{count=0;for(child=T->firstchild;child;child=child->nextsib)count+=LeafCount_CSTree(child);return count; //各子树的叶子数之和}}//LeafCount_CSTree6.61int GetDegree_CSTree(CSTree T)//求孩子兄弟链表表示的树T的度{if(!T->firstchild) return 0; //空树else{degree=0;for(p=T->firstchild;p;p=p->nextsib) degree++;//本结点的度for(p=T->firstchild;p;p=p->nextsib){d=GetDegree_CSTree(p);if(d>degree) degree=d; //孩子结点的度的最大值}return degree;}//else}//GetDegree_CSTree6.62int GetDepth_CSTree(CSTree T)//求孩子兄弟链表表示的树T的深度{if(!T) return 0; //空树else{for(maxd=0,p=T->firstchild;p;p=p->nextsib)if((d=GetDepth_CSTree(p))>maxd) maxd=d; //子树的最大深度return maxd+1;}}//GetDepth_CSTree6.63int GetDepth_CTree(CTree A)//求孩子链表表示的树A的深度{return SubDepth(A.r);}//GetDepth_CTreeint SubDepth(int T)//求子树T的深度{if(!A.nodes[T].firstchild) return 1;for(sd=1,p=A.nodes[T].firstchild;p;p=p->next)if((d=SubDepth(p->child))>sd) sd=d;return sd+1;}//SubDepth6.64int GetDepth_PTree(PTree T)//求双亲表表示的树T的深度{maxdep=0;for(i=0;i<T.n;i++){dep=0;for(j=i;j>=0;j=T.nodes[j].parent) dep++; //求每一个结点的深度if(dep>maxdep) maxdep=dep;}return maxdep;}//GetDepth_PTree6.65char Pred,Ind; //假设前序序列和中序序列已经分别储存在数组Pre和In中Bitree Build_Sub(int Pre_Start,int Pre_End,int In_Start,int In_End)//由子树的前序和中序序列建立其二叉链表{sroot=(BTNode*)malloc(sizeof(BTNode)); //建根sroot->data=Pre[Pre_Start];for(i=In_Start;In[i]!=sroot->data;i++); //在中序序列中查找子树根leftlen=i-In_Start;rightlen=In_End-i; //计算左右子树的大小if(leftlen){lroot=Build_Sub(Pre_Start+1,Pre_Start+leftlen,In_Start,In_Start+leftlen-1);sroot->lchild=lroot;} //建左子树,注意参数表的计算if(rightlen){rroot=Build_Sub(Pre_End-rightlen+1,Pre_End,In_End-rightlen+1,In_End);sroot->rchild=rroot;} //建右子树,注意参数表的计算return sroot; //返回子树根}//Build_Submain(){...Build_Sub(1,n,1,n); //初始调用参数,n为树结点总数...}分析:本算法利用了这样一个性质,即一棵子树在前序和中序序列中所占的位置总是连续的.因此,就可以用起始下标和终止下标来确定一棵子树.Pre_Start,Pre_End,In_Start和In_End分别指示子树在前序子序列里的起始下标,终止下标,和在中序子序列里的起始和终止下标.6.66typedef struct{CSNode *ptr;CSNode *lastchild;} NodeMsg; //结点的指针和其最后一个孩子的指针Status Bulid_CSTree_PTree(PTree T)//由树T的双亲表构造其孩子兄弟链表{NodeMsg Treed;for(i=0;i<T.n;i++){Tree[i].ptr=(CSNode*)malloc(sizeof(CSNode));Tree[i].ptr->data=T.node[i].data; //建结点if(T.nodes[i].parent>=0) //不是树根{j=T.nodes[i].parent; //本算法要求双亲表必须是按层序存储if(!(Tree[j].lastchild)) //双亲当前还没有孩子Tree[j].ptr->firstchild=Tree[i].ptr; //成为双亲的第一个孩子else //双亲已经有了孩子Tree[j].lastchild->nextsib=Tree[i].ptr; //成为双亲最后一个孩子的下一个兄弟 Tree[j].lastchild=Tree[i].ptr; //成为双亲的最后一个孩子}//if}//for}//Bulid_CSTree_PTree6.67typedef struct{char data;CSNode *ptr;CSNode *lastchild;} NodeInfo; //结点数据,结点指针和最后一个孩子的指针Status CreateCSTree_Duplet(CSTree &T)//输入二元组建立树的孩子兄弟链表{NodeInfo Treed;n=1;k=0;if(getchar()!='^') return ERROR; //未按格式输入if((c=getchar())=='^') T=NULL; //空树Tree[0].ptr=(CSNode*)malloc(sizeof(CSNode));Tree[0].data=c;Tree[0].ptr->data=c;while((p=getchar())!='^'&&(c=getchar())!='^'){Tree[n].ptr=(CSNode*)malloc(sizeof(CSNode));Tree[n].data=c;Tree[n].ptr->data=c;for(k=0;Tree[k].data!=p;k++); //查找当前边的双亲结点if(Tree[k].data!=p) return ERROR; //未找到:未按层序输入r=Tree[k].ptr;if(!r->firstchild)r->firstchild=Tree[n].ptr;else Tree[k].lastchild->nextsib=Tree[n].ptr;Tree[k].lastchild=Tree[n].ptr; //这一段含义同上一题n++;}//whilereturn OK;}//CreateCSTree_Duplet6.68Status CreateCSTree_Degree(char node[ ],int degree[ ])//由结点的层序序列和各结点的度构造树的孩子兄弟链表{CSNode * ptrd; //树结点指针的辅助存储ptr[0]=(CSNode*)malloc(sizeof(CSNode));i=0;k=1; //i为当前结点序号,k为当前孩子的序号while(node[i]){ptr[i]->data=node[i];d=degree[i];if(d){ptr[k++]=(CSNode*)malloc(sizeof(CSNode)); //k为当前孩子的序号ptr[i]->firstchild=ptr[k]; //建立i与第一个孩子k之间的联系for(j=2;j<=d;j++){ptr[k++]=(CSNode*)malloc(sizeof(CSNode));ptr[k-1]->nextsib=ptr[k]; //当结点的度大于1时,为其孩子建立兄弟链表}//for}//ifi++;}//while}//CreateCSTree_Degree6.69void Print_BiTree(BiTree T,int i)//按树状打印输出二叉树的元素,i表示结点所在层次,初次调用时i=0{if(T->rchild) Print_BiTree(T->rchild,i+1);for(j=1;j<=i;j++) printf(" "); //打印i个空格以表示出层次printf("%c\n",T->data); //打印T元素,换行if(T->lchild) Print_BiTree(T->rchild,i+1);}//Print_BiTree分析:该递归算法实际上是带层次信息的中序遍历,只不过按照题目要求,顺序为先右后左.6.70Status CreateBiTree_GList(BiTree &T)//由广义表形式的输入建立二叉链表{c=getchar();if(c=='#') T=NULL; //空子树else{T=(CSNode*)malloc(sizeof(CSNode));T->data=c;if(getchar()!='(') return ERROR;if(!CreateBiTree_GList(pl)) return ERROR;T->lchild=pl;if(getchar()!=',') return ERROR;if(!CreateBiTree_GList(pr)) return ERROR;T->rchild=pr;if(getchar()!=')') return ERROR; //这些语句是为了保证输入符合A(B,C)的格式 }return OK;}//CreateBiTree_GList6.71void Print_CSTree(CSTree T,int i)//按凹入表形式打印输出树的元素,i表示结点所在层次,初次调用时i=0{for(j=1;j<=i;j++) printf(" "); //留出i个空格以表现出层次printf("%c\n",T->data); //打印元素,换行for(p=T->firstchild;p;p=p->nextsib)Print_CSTree(p,i+1); //打印子树}//Print_CSTree6.72void Print_CTree(int e,int i)//按凹入表形式打印输出树的元素,i表示结点所在层次{for(j=1;j<=i;j++) printf(" "); //留出i个空格以表现出层次printf("%c\n",T.nodes[e].data); //打印元素,换行for(p=T.nodes[e].firstchild;p;p=p->next)Print_CSTree(p->child,i+1); //打印子树}//Print_CSTreemain(){...Print_CTree(T.r,0); //初次调用时i=0...}//main6.73char c; //全局变量,指示当前字符Status CreateCSTree_GList(CSTree &T)//由广义表形式的输入建立孩子兄弟链表{c=getchar();T=(CSNode*)malloc(sizeof(CSNode));T->data=c;if((c=getchar())=='(') //非叶结点{if(!CreateCSTree_GList(fc)) return ERROR; //建第一个孩子T->firstchild=fc;for(p=fc;c==',';p->nextsib=nc,p=nc) //建兄弟链if(!CreateCSTree_GList(nc)) return ERROR;p->nextsib=NULL;if((c=getchar())!=')') return ERROR; //括号不配对}else T->firtchild=NULL; //叶子结点return OK;}//CreateBiTree_GList分析:书后给出了两个间接递归的算法,事实上合成一个算法在形式上可能更好一些.本算法另一个改进之处在于加入了广义表格式是否合法的判断.6.74{printf("%c",T->data);if(T->firstchild) //非叶结点{printf("(");for(p=T->firstchild;p;p=p->nextsib){PrintGlist_CSTree(p);if(p->nextsib) printf(","); //最后一个孩子后面不需要加逗号}printf(")");}//if}//PrintGlist_CSTree6.75char c;int pos=0; //pos是全局变量,指示已经分配到了哪个结点Status CreateCTree_GList(CTree &T,int &i)//由广义表形式的输入建立孩子链表{c=getchar();T.nodes[pos].data=c;i=pos++; //i是局部变量,指示当前正在处理的子树根if((c=getchar())=='(') //非叶结点{CreateCTree_GList();p=(CTBox*)malloc(sizeof(CTBox));T.nodes[i].firstchild=p;p->child=pos; //建立孩子链的头for(;c==',';p=p->next) //建立孩子链{CreateCTree_GList(T,j); //用j返回分配得到的子树根位置p->child=j;p->next=(CTBox*)malloc(sizeof(CTBox));}p->next=NULL;if((c=getchar())!=')') return ERROR; //括号不配对}//ifelse T.nodes[i].firtchild=NULL; //叶子结点return OK;}//CreateBiTree_GList分析:该算法中,pos变量起着"分配"结点在表中的位置的作用,是按先序序列从上向下分配,因此树根T.r一定等于0,而最终的pos值就是结点数T.n.6.76{printf("%c",T.nodes[i].data);if(T.nodes[i].firstchild) //非叶结点{printf("(");for(p=T->firstchild;p;p=p->nextsib){PrintGlist_CSTree(T,p->child);if(p->nextsib) printf(","); //最后一个孩子后面不需要加逗号 }printf(")");}//if}//PrintGlist_CTree。

严蔚敏《数据结构（C语言版）习题集》答案第一章绪论void print_descending(int x,int y,int z)....+f[m-k]=f[m-1]+f[m-2]+......+f[m-k]+f[m-k-1]-f[m-k-1]=2*f[m-1]-f[m-k-1]所以上述算法的时间复杂度仅为O(m). 如果采用递归设计,将达到O(k^m). 即使采用暂存中间结果的方法,也将达到O(m^2).typedef struct{char *sport;enum{male,female} gender;char schoolname; port!=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[ 0 ].totalscore+=result[i].score;if(result[i].gender==0) score[ 0 ].malescore+=result[i].score;else score[ 0 ].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);}}void polyvalue(){float temp;float *p=a;printf("Input number of terms:");scanf("%d",&n);printf("Input value of x:");scanf("%f",&x);printf("Input the %d coefficients from a0 to a%d:\n",n+1,n);p=a;xp=1;sum=0;Status Insert(LinkList &L,int i,int b)void merge1(LinkList &A,LinkList &B,LinkList &C)void SqList_Intersect(SqList A,SqList B,SqList &C)void LinkList_Intersect_Delete(LinkList &A,LinkList B,LinkList C)iList为带头结点的单循环链表类型.{s=L->next;A=(CiList*)malloc(sizeof(CiLNode));p=A;B=(CiList*)malloc(sizeof(CiLNode));q=B;C=(CiList*)malloc(sizeof(CiLNode));r=C; .4,2的顺序重排双向循环链表L中的所有结点{p=;while(p->next!=L&&p->next->next!=L){p->next=p->next->next;p=p->next;} 同时进行调整的话,必须使用堆栈保存偶数结点的指针,否则将会破坏链表结构,造成结点丢失.DuLNode * Locate_DuList(DuLinkedList &L,int x) int x;int y;} coordinate;void Repaint_Color(int g[m][n],int i,int j,int color)归形式的算法该怎么写呢?void NiBoLan(char *str,char *new)题中暂不考虑串的具体操作的实现,而将其看作一种抽象数据类型stringtype,对其可以进行连接操作:c=link(a,b).Status g(int m,int n,int &s)void InitCiQueue(CiQueue &Q)Status EnCyQueue(CyQueue &Q,int x)省掉这一句,则在某些情况下,会引起不希望的后果,虽然在大多数情况下没有影响.请思考:设S='place', T='ace', V='face',则省掉i+=Strlen(V);运行时会出现什么结果?int Delete_SubString(Stringtype &s,Stringtype t)读者用此程序取代作者早些时候对题给出的程序.void StrAssign(Stringtype &T,char chars&#;)h&&T[j].ch!=c) j++; h) T[j].num++;else T[j]={c,1};}h;j++)printf("%c: %d\n",T[j].ch,T[j].num);}前一个程序的区别在于,串s业已存在.{for(p=s->next,q=t->next;p&&q;p=p->next,q=q->next){p->ch=q->ch;pre=p;}while(q){p=(LStrNode*)malloc(sizeof(LStrNode));p->ch=q->ch;pre->next=p;pre=p;}p->next=NULL;}算法的思想是,依次把串S的一个副本S2向右错位平移1格,2格,3格,...与自身S1相匹配,如果存在最长重复子串,则必然能在此过程中被发现.用变量lrs1,lrs2,maxlen来记录已发现的最长重复子串第一次出现位置,第二次出现位置和长度.题目中未说明"重复子串"是否允许有重叠部分,本算法假定允许.如不允许,只需在第二个for语句的循环条件中加上k<=i即可.本算法时间复杂度为O(Strlen(S)^2).void Get_LPubSub(Stringtype S,Stringtype T) for(k=0,j=jmin;j<=jmax;j++){if(A[j]==B[j-i]) k++;else k=0;if(k>maxlen){lps1=j-k+1;lps2=j-i-k+1;maxlen=k;}}一的区别是,由于A,B互不相同,因此B不仅要向右错位,而且还要向左错位,以保证不漏掉一些情况.当B相对于A的位置不同时,需要匹配的区间的计算公式也各不相同,请读者自己画图以帮助理解.本算法的时间复杂度是o（strlrn（s）*strlen（t））。