数据结构c语言第三版,邓文华编习题
C语言课后习题参考答案(教材第三版 第七章以后只有选择填空题答案)[1]
![C语言课后习题参考答案(教材第三版 第七章以后只有选择填空题答案)[1]](https://img.taocdn.com/s3/m/c796fe316c175f0e7cd1373e.png)
第一章习题参考答案一、单项选择题1. C2. B3. B4.C5. D6. A7. C8. A二、填空题1. 判断条件2. 面向过程编程3. 结构化4. 程序5. 面向对象语言6. 基本功能操作控制结构7. 有穷性8. 直到型循环结构9. 算法10. 可读性11. 模块化12. 对问题的分解和模块的划分第二章习题参考答案一、单项选择题1. B2. D3. C4. B5. A6. A7. B8. C二、填空题1. 主2. C编译系统3. 函数一个主函数和若干函数4. 输入输出5. 以.h为扩展名的头文件6. .obj7. 库函数8. 文本第三章习题参考答案一、单项选择题1. D2. B3. A4. C5. C6. D7. B8. D9. B 10. C11. A 12. D 13. C 14. C 15. C16. C 17. B 18. C 19. C 20. D21. A 22. D 23. D 24. D A 25. D26. A二、填空1. 补码2. 取绝对值为10-308~1030815~16位3. 0或14. 赋值右向左5. 函数调用6. 65,89三、应用题1. 10 92. 111213. 区别是:求负:单目,右结合-a+b减法:双目,左结合a-b取地址:单目,右结合&a按位与:双目,左结合a&b第四章习题参考答案一、单项选择题1. D2. C3. D4. A5. D6. B7. A8. C9. B 10. B二、填空题1.一条;2. 5.1690003.(1)-200 2500(2)i=-200,j=2500(3)i=-200j=25004. a=98, b=765.000000, c=4321.0000005. 三种可能的输入是:(1)100<回车> 25.81<回车> 1.89234<回车>(2)100<空格> 25.81<空格> 1.89234<回车>(3)100<TAB > 25.81<TAB > 1.89234<回车>6. 0,0,37. 38. 输入语句是:scanf("%lf%lf%lf",&a,&b,&c);9. 13 13.000000 13.00000010. 3种方法:(1) 增加一个临时变量t。
C语言版数据结构题库习题及答案
![C语言版数据结构题库习题及答案](https://img.taocdn.com/s3/m/d6921d7900f69e3143323968011ca300a6c3f6cf.png)
数据结构(C语言版)课后习题答案目录第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’},学生基本信息表也可是一个数据对象。
数据结构:是相互之间存在一种或多种特定关系的数据元素的集合。
换句话说,数据结构是带“结构”的数据元素的集合,“结构”就是指数据元素之间存在的关系。
逻辑结构:从逻辑关系上描述数据,它与数据的存储无关,是独立于计算机的。
因此,数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。
存储结构:数据对象在计算机中的存储表示,也称为物理结构。
抽象数据类型:由用户定义的,表示应用问题的数学模型,以及定义在这个模型上的一组操作的总称。
具体包括三部分:数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。
2.试举一个数据结构的例子,叙述其逻辑结构和存储结构两方面的含义和相互关系。
《C语言程序设计教程》第三版课后习题参考答案
![《C语言程序设计教程》第三版课后习题参考答案](https://img.taocdn.com/s3/m/d26c4b9077a20029bd64783e0912a21615797f7e.png)
《C语言程序设计教程》第三版课后习题参考答案C语言程序设计教程第三版课后习题参考答案第一章:C语言概述1.1 C语言的特点答案:C语言是一种通用的、面向过程的程序设计语言,具有高效、简洁、灵活等特点。
它提供了丰富的程序设计元素和功能,适用于各种不同的应用领域。
1.2 C语言程序的基本结构答案:C语言程序由预处理指令、函数声明、函数定义、变量声明和语句组成。
其中,预处理指令用来引入头文件或定义宏,函数声明用来声明函数的名称和参数,函数定义用来实现函数的功能,变量声明用来声明变量的类型和名称,语句用来表达具体的计算过程。
1.3 C语言的数据类型答案:C语言提供了多种数据类型,包括基本类型(整型、浮点型、字符型等)和派生类型(数组、指针、结构体等)。
每种数据类型在内存中占据一定的存储空间,并具有特定的取值范围和操作规则。
1.4 C语言的运算符和表达式答案:C语言支持各种运算符和表达式,例如算术运算符(+、-、*、/等)、关系运算符(>、<、==等)、逻辑运算符(&&、||、!等)等。
通过运算符和表达式可以进行各种数值计算和逻辑判断。
第二章:基本数据类型与运算2.1 整型数据类型答案:C语言提供了不同长度的整型数据类型,包括有符号整型(int、long等)和无符号整型(unsigned int、unsigned long等)。
整型数据类型可以表示整数值,并具有不同的取值范围。
2.2 浮点型数据类型答案:C语言提供了浮点型数据类型(float、double等),用来表示带小数部分的实数值。
浮点型数据可以表示较大或较小的数值,并具有一定的精度。
2.3 字符型数据类型答案:C语言提供了字符型数据类型(char),用来表示单个字符。
字符型数据可以用于表示各种字符(包括字母、数字、符号等)。
2.4 布尔型数据类型答案:C语言不直接支持布尔型数据类型,但可以使用整型数据类型来表示布尔值(0表示假、非零表示真)。
数据结构(C语言版本)课后练习答案的完整版本.doc
![数据结构(C语言版本)课后练习答案的完整版本.doc](https://img.taocdn.com/s3/m/4f2b7734f121dd36a32d829e.png)
数据结构(C语言版本)课后练习答案的完整版本第一章引言5。
选择题:CCBDCA 6。
尝试分析以下程序段的时间复杂性。
(1)o(1)(2)o(m * n)(3)o(N2)(4)o(log3n)(5)因为x已执行n-1n-2.1=n (n-1)/2,执行时间为O(n2)(6)O()第2章线性表1。
多项选择babadbcbdcddac 2。
算法设计问题(6)设计一种算法,通过一次遍历来确定单个链表中具有最大值的节点。
元素类型最大值(链表L ){如果(下一个==空)返回空;pmax=1-下一个;//假设第一个节点中的数据具有最大值p=L-下一个-下一个;同时(p!=NULL ){//如果在下一个节点处存在if(p-数据pmax-数据)pmax=p;p=p-下一个;}返回pmax-数据;(7)设计一种算法,通过遍历一次来反转链表中所有节点的链接方向,并且仍然使用原表的存储空间。
空逆(链表L) {//逆单个链表L p=L-头节点的下一个;下一个=空;而(p){ q=p-next;//q指向*p=l-next 的下一个p-next;l-next=p;//*p插入在头节点p=q之后;}}(10)已知长度n的线性表A采用顺序存储结构。
请编写一个时间复杂度为0(n)和空间复杂度为0(1)的算法,删除线性表中所有有值项的数据元素。
[主题分析]删除线性表中按顺序存储的元素通常涉及一系列元素的移动(删除第I个元素,并按顺序向前移动第I到第N个元素)。
本主题要求删除线性表中项目值为的所有数据元素,并且不要求元素之间的相对位置保持不变。
因此,可以考虑设置两个指针(i=1,j=n)从两端移到中间。
当遇到带有值项的数据元素时,右端元素将直接移动到带有值项的数据元素的位置。
虚删除(元素类型A[),整数n)A是一个有n个元素的一维数组。
此算法删除值为项的中的所有元素。
{ I=1;j=n。
∑设置数组的低端和高端指针(下标)。
同时(不精确;r=p;//让r 作为指针,而(q!=null){ if(q-data data)r=q;q:=q-next。
数据结构c语言版第三版习题解答
![数据结构c语言版第三版习题解答](https://img.taocdn.com/s3/m/366fcfd4cd22bcd126fff705cc17552707225eb1.png)
数据结构c语言版第三版习题解答数据结构 C 语言版第三版习题解答在学习计算机科学与技术的过程中,数据结构是一门非常重要的基础课程。
而《数据结构C 语言版第三版》更是众多教材中的经典之作。
其中的习题对于我们理解和掌握数据结构的概念、原理以及算法实现起着至关重要的作用。
接下来,我将为大家详细解答这本书中的一些典型习题。
首先,让我们来看一道关于线性表的习题。
题目是这样的:设计一个算法,从一个有序的线性表中删除所有其值重复的元素,使表中所有元素的值均不同。
对于这道题,我们可以采用双指针的方法来解决。
定义两个指针 p和 q,p 指向线性表的开头,q 从 p 的下一个位置开始。
当 q 所指向的元素与 p 所指向的元素相同时,我们就将 q 所指向的元素删除,并将 q 向后移动一位。
当 q 所指向的元素与 p 所指向的元素不同时,我们将 p 向后移动一位,并将 q 所指向的元素赋值给 p 所指向的位置,然后再将 q 向后移动一位。
当 q 超出线性表的范围时,算法结束。
下面是用 C 语言实现的代码:```cvoid removeDuplicates(int arr, int n) {int p = 0, q = 1;while (q < n) {if (arrp == arrq) {for (int i = q; i < n 1; i++){arri = arri + 1;}(n);} else {p++;arrp = arrq;}q++;}}```再来看一道关于栈的习题。
题目是:利用栈实现将一个十进制数转换为八进制数。
我们知道,将十进制数转换为八进制数可以通过不断除以 8 取余数的方法来实现。
而栈的特点是后进先出,正好适合存储这些余数。
以下是 C 语言实现的代码:```cinclude <stdioh>include <stdlibh>define MAX_SIZE 100typedef struct {int top;int dataMAX_SIZE;} Stack;//初始化栈void initStack(Stack s) {s>top =-1;}//判断栈是否为空int isEmpty(Stack s) {return s>top ==-1;}//判断栈是否已满int isFull(Stack s) {return s>top == MAX_SIZE 1;}//入栈操作void push(Stack s, int element) {if (isFull(s)){printf("Stack Overflow!\n");return;}s>data++s>top = element;}//出栈操作int pop(Stack s) {if (isEmpty(s)){printf("Stack Underflow!\n");return -1;}return s>datas>top;}//将十进制转换为八进制void decimalToOctal(int decimal) {Stack s;initStack(&s);while (decimal!= 0) {push(&s, decimal % 8);decimal /= 8;}while (!isEmpty(&s)){printf("%d", pop(&s));}printf("\n");}int main(){int decimal;printf("请输入一个十进制数: ");scanf("%d",&decimal);printf("转换后的八进制数为: ");decimalToOctal(decimal);return 0;}```接下来是一道关于队列的习题。
数据结构C语言第三版习题4参考答案
![数据结构C语言第三版习题4参考答案](https://img.taocdn.com/s3/m/4991282c915f804d2b16c15d.png)
习题4参考答案4.1 选择题:(1). A (2). D (3). C (4). C (5). B (6). B (7). D (8). A (9). D4.2 填空题:(1)串长相等且对应位置字符相等(2)不含任何元素的串,0(3)所含字符均是空格,所含空格数(4)10(5)“hello boy”(6)18(7)1066(8)长度为n(n>=0)的字符序列(9)串中所含字符的个数(10) 364.3 StrLength (s)=14, StrLength (t)=4, SubStr( s,8,7)=” STUDENT”, SubStr(t,2,1)=”O”,StrIndex(s,“A”)=3, StrIndex (s,t)=0, StrRep(s,“STUDENT”,q)=” I AM A WORKER”, 4.4 StrRep(s,”Y”,”+”);StrRep(s,”+*”,”*Y”);4.5 空串:不含任何字符;空格串:所含字符都是空格串变量和串常量:串常量在程序的执行过程中只能引用不能改变;串变量的值在程序执行过程中是可以改变和重新赋值的主串与子串:子串是主串的一个子集串变量的名字与串变量的值:串变量的名字表示串值的标识符4.6int StrEqual(SString s,SString t){/*比较两串是否相等,相等返回1,否则返回0*/int i=1;while(i<=s[0] &&i<=t[0])if(s[i]!=t[i]) return 0;else i++;if(s[0]!=t[0]) return 0;else return 1;}4.7(1)6*8*6=288(2)1000+47*6=1282(3)1000+(8+4)*6=1072(4)1000+(6*7+4)*6=12764.8。
c语言程序设计教程第三版习题答案
![c语言程序设计教程第三版习题答案](https://img.taocdn.com/s3/m/38fd88adf71fb7360b4c2e3f5727a5e9856a27c2.png)
c语言程序设计教程第三版习题答案C语言程序设计教程第三版习题答案第一章:C语言概述1. 简述C语言的特点。
C语言是一种结构化编程语言,具有高级语言的特点,同时支持底层硬件操作。
其特点包括:简洁、高效、可移植、丰富的运算符、数据结构支持、广泛的库函数等。
2. 什么是编译型语言?编译型语言是指源代码在执行前需要通过编译器转换成机器语言的程序设计语言。
C语言就是一种编译型语言。
第二章:数据类型、运算符和表达式1. 列出C语言的基本数据类型。
C语言的基本数据类型包括:整型(int)、字符型(char)、浮点型(float和double)。
2. 说明赋值运算符的用法。
赋值运算符(=)用于将右侧表达式的值赋给左侧的变量。
例如:`int a = 10;` 将整数值10赋给变量a。
第三章:控制结构1. 什么是条件语句?条件语句用于根据条件的真假来执行不同的代码块。
C语言中的条件语句主要有if语句和switch语句。
2. 循环语句有哪些?C语言中的循环语句主要有for循环、while循环和do-while循环。
第四章:数组和字符串1. 数组的声明和初始化方式。
数组声明的一般形式为:`type arrayName[arraySize];`。
初始化可以使用花括号一次性赋值,如:`int arr[5] = {1, 2, 3, 4, 5};`。
2. 字符串在C语言中的表示方法。
在C语言中,字符串以字符数组的形式存在,以空字符('\0')作为结束标志。
第五章:函数1. 函数的定义和调用。
函数定义的一般形式为:`returnTypefunctionName(parameterList) { /* function body */ }`。
调用函数时,使用其名称和必要的参数。
2. 函数的参数传递方式有哪些?C语言中函数的参数传递方式主要有值传递(pass by value)和引用传递(pass by reference)。
数据结构(c语言版)第三版习题解答
![数据结构(c语言版)第三版习题解答](https://img.taocdn.com/s3/m/056274f8ab00b52acfc789eb172ded630b1c98bc.png)
数据结构(c语言版)第三版习题解答数据结构(C语言版)第三版习题解答1. 栈(Stack)1.1 栈的基本操作栈是一种具有特定限制的线性表,它只允许在表的一端进行插入和删除操作。
栈的基本操作有:(1)初始化栈(2)判断栈是否为空(3)将元素入栈(4)将栈顶元素出栈(5)获取栈顶元素但不出栈1.2 栈的实现栈可以使用数组或链表来实现。
以数组为例,声明一个栈结构如下:```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储栈中的元素int top; // 栈顶指针} Stack;```1.3 栈的应用栈在计算机科学中有广泛的应用,例如计算表达式的值、实现函数调用等。
下面是一些常见的栈应用:(1)括号匹配:使用栈可以检查一个表达式中的括号是否匹配。
(2)中缀表达式转后缀表达式:栈可以帮助我们将中缀表达式转换为后缀表达式,便于计算。
(3)计算后缀表达式:使用栈可以方便地计算后缀表达式的值。
2. 队列(Queue)2.1 队列的基本操作队列是一种按照先进先出(FIFO)原则的线性表,常用的操作有:(1)初始化队列(2)判断队列是否为空(3)将元素入队(4)将队头元素出队(5)获取队头元素但不出队2.2 队列的实现队列的实现一般有循环数组和链表两种方式。
以循环数组为例,声明一个队列结构如下:```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储队列中的元素int front; // 队头指针int rear; // 队尾指针} Queue;```2.3 队列的应用队列在计算机科学中也有广泛的应用,例如多线程任务调度、缓存管理等。
下面是一些常见的队列应用:(1)广度优先搜索:使用队列可以方便地实现广度优先搜索算法,用于解决图和树的遍历问题。
(2)生产者-消费者模型:队列可以用于实现生产者和消费者之间的数据传输,提高系统的并发性能。
数据结构C语言版习题与答案
![数据结构C语言版习题与答案](https://img.taocdn.com/s3/m/7f54bbc058f5f61fb73666c0.png)
一、是非题1. 数据结构概念包括数据之间的逻辑结构,数据在计算机中的存储方式和数据的运算三个方面。
.......................( T )2. 线性表的逻辑顺序与物理顺序总是一致的........( F )3. 线性表中的每个结点最多只有一个前驱和一个后继。
......( T )4. 线性的数据结构可以顺序存储,也可以链接存储。
非线性的数据结构只能链接存储。
.......................( F )5. 栈和队列逻辑上都是线性表。
..........................( T )6. 单链表从任何一个结点出发,都能访问到所有结点........( F )7. 单链表形式的队列,头指针F指向队列的第一个结点,尾指针R指向队列的最后一个结点。
.................................................( T )8. 在用单链表表示的链式队列中,队头在链表的链尾位置。
....( F )9. 多维数组是向量的推广。
..............................( T )10. 栈是一种先进先出的线性表。
....( F )11. 凡是递归定义的数据结构都可以用递归算法来实现它的操作。
......( T )12. 设串S的长度为n,则S的子串个数为n(n+1)/2。
...........( F )13. 一般树和二叉树的结点数目都可以为0。
................( F )14. 按中序遍历二叉树时,某结点的直接后继是它的右子树中第1个被访问的结点。
....( T )15. 后序序列和中序序列能唯一确定一棵二叉树。
....( T )16. 对于一棵具有n个结点,其高度为h的二叉树,进行任—种次序遍历的时间复杂度为O(n) .............( T )17. 网络的最小代价生成树是唯一的。
...( T )18. 图的拓扑有序序列不是唯一的。
习 题_数据结构(C语言版)(第3版)_[共2页]
![习 题_数据结构(C语言版)(第3版)_[共2页]](https://img.taocdn.com/s3/m/468ee5b5caaedd3383c4d3e5.png)
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/ void dele_sequence_cqueue(sequence_queue ∗sq) {
if(sq->front==sq->rear) { printf("\n 循环队列是空的!无法进行删除操作!");
exit(1); } sq->front=(sq->front+1)%MAXSIZE; }
算法 2.27 循环队列(顺序存储)的删除操作
31
另一种方法是牺牲一个数组元素的空间,即若数组的大小是 MAXSIZE,则该数组所表示的循环
队列最多允许存储 MAXSIZE−1 个结点。这样,循环队列满的条件是:
循环队列空的条件是:
(rear + 1)%MAXSIZE = front
rear = front
循环队列的顺序存储结构的 C 语言描述和一般队列一致,但是循环队列基本操作的具体实现
/∗ 函数功能:循环队列(顺序存储)的插入操作
∗/
/∗ 函数参数:指向 sequence_queue 类型变量的指针变量 sq
∗/
/∗
datatype 类型的变量 x
∗/
/∗ 函数返回值:空
∗/
/∗ 文件名:secqinse.c,函数名:insert_sequence_cqueue() ∗/
/∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗/ void insert_sequence_cqueue(sequence_queue ∗sq,datatype x) {
习 题_数据结构(C语言版)(第3版)_[共2页]
![习 题_数据结构(C语言版)(第3版)_[共2页]](https://img.taocdn.com/s3/m/ac273818a1c7aa00b42acb35.png)
260{ /*按最低位优先依次对各关键字进行分配和收集*/distribute(r,i); /*第i趟分配*/collect(r); /*第i趟收集*/}}算法10.15 静态链式基数排序算法从上面链式基数排序算法中可以看出,算法10.13中的分配过程和记录的个数有关,其时间复杂度为O(n),算法10.14中的收集过程和各位排序码的取值范围中值的个数rd(十进制为10)有关,其时间复杂度为O(rd),静态链式基数排序要进行b趟收集和b趟分配,故基数排序的时间复杂度为O(b(n + rd))。
静态链式基数排序除了需2rd(这里是2∗10)个队列指针的存储空间外,还增加了n个link 指针域的存储空间。
静态链式基数排序是一种稳定的排序方法。
10.1 选择题。
(1)下列序列中,( )是执行第一趟快速排序后得到的序列。
A.[da,ax,eb,de,bb]ff[ha,gc] B.[cd,eb,ax,da]ff[ha,gc,bb]C.[gc,ax,eb,cd,bb]ff[da,ha] C.[ax,bb,cd,da]ff[eb,gc,ha](2)下列说法错误的是( )。
A.冒泡排序在数据有序的情况下具有最少的比较次数。
B.直接插入排序在数据有序的情况下具有最少的比较次数。
C.二路归并排序需要借助O(n)的存储空间。
D.基数排序适合于实型数据的排序。
(3)下面的序列中初始序列构成最小堆(小根堆)的是( )。
A.10、60、20、50、30、26、35、40B.70、40、36、30、20、16、28、10C.20、60、50、40、30、10、8、72D.10、30、20、50、40、26、35、60(4)在下列算法中,( )算法可能出现下列情况:在最后一趟开始之前,所有的元素都不在其最终的位置上。
A.堆排序B.插入排序C.冒泡排序D.快速排序(5)若需在O(n log n)的时间内完成对数组的排序,且要求排序算法是稳定的,则可选择的排序方法是( )。
数据结构(C语言版)第三版__清华大学出版社_习题参考答案
![数据结构(C语言版)第三版__清华大学出版社_习题参考答案](https://img.taocdn.com/s3/m/b3bffb005627a5e9856a561252d380eb63942362.png)
数据结构(C语言版)第三版__清华大学出版社_习题参考答案数据结构(C语言版)第三版__清华大学出版社_习题参考答案引言:数据结构是计算机科学的基础,对于学习和理解数据结构的相关概念和算法非常重要。
本文将对清华大学出版社出版的《数据结构(C语言版)第三版》中的习题进行参考答案的提供。
通过正确的理解和掌握这些习题的解答,读者可以加深对数据结构的认识,并提高自己的编程能力。
第一章:绪论1.1 数据结构的定义与作用数据结构是指数据对象以及数据对象之间的关系、运算和存储结构的总称。
数据结构的作用是在计算机中高效地组织和存储数据,同时支持常见的数据操作和算法。
1.2 算法的定义与特性算法是解决特定问题的一系列步骤和规则。
算法具有确定性、有穷性、可行性和输入输出性等特点。
第二章:线性表2.1 线性表的定义和基本操作线性表是同类型数据元素的一个有限序列。
线性表的基本操作包括初始化、查找、插入、删除和遍历等。
2.2 顺序存储结构顺序存储结构是将线性表中的元素按顺序存放在一块连续的存储空间中。
顺序存储结构的特点是随机存取、插入和删除操作需要移动大量元素。
2.3 链式存储结构链式存储结构通过结点之间的指针链表来表示线性表。
链式存储结构的特点是插入和删除操作方便,但查找操作需要遍历整个链表。
第三章:栈和队列3.1 栈的定义和基本操作栈是只能在一端进行插入和删除操作的线性表。
栈的基本操作包括初始化、入栈、出栈和获取栈顶元素等。
3.2 队列的定义和基本操作队列是只能在一端插入操作,在另一端进行删除操作的线性表。
队列的基本操作包括初始化、入队、出队和获取队头元素等。
第四章:串4.1 串的定义和基本操作串是由零个或多个字符组成的有限序列。
串的基本操作包括初始化、串的赋值、串的连接和串的比较等。
第五章:树5.1 树的基本概念和术语树是n(n>=0)个结点的有限集。
树的基本概念包括根结点、子树、深度和高度等。
5.2 二叉树二叉树是每个结点最多有两个子树的树结构。
c 第三版课后习题答案
![c 第三版课后习题答案](https://img.taocdn.com/s3/m/e01c8074a22d7375a417866fb84ae45c3b35c22e.png)
c 第三版课后习题答案C 第三版课后习题答案C语言是一门广泛应用于计算机编程领域的编程语言,它的学习对于计算机科学和软件工程的学生来说是非常重要的。
C语言第三版是一本经典的教材,它为学生提供了丰富的习题来巩固所学的知识。
在这篇文章中,我将为大家提供C语言第三版课后习题的答案,希望能对大家的学习有所帮助。
1. 第一章:开始学习C语言在第一章中,主要介绍了C语言的基本概念和语法规则。
以下是一些常见的习题及其答案:1.1 填空题:a) C语言是一种______语言。
答案:结构化b) 在C语言中,用于存储数据的基本单元是______。
答案:变量1.2 程序设计题:编写一个C程序,要求用户输入两个整数,然后输出它们的和。
答案:```c#include <stdio.h>int main() {int num1, num2, sum;printf("请输入两个整数:");scanf("%d%d", &num1, &num2);sum = num1 + num2;printf("它们的和为:%d\n", sum);return 0;}```2. 第二章:C语言基础第二章主要介绍了C语言的基本数据类型、运算符和控制结构。
以下是一些习题及其答案:2.1 选择题:a) 下列哪个是C语言的基本数据类型?1. float2. string3. boolean4. char答案:4. charb) 下列哪个运算符用于求两个整数的商?1. +2. -3. *4. /答案:4. /2.2 程序设计题:编写一个C程序,判断一个整数是否为偶数。
答案:```c#include <stdio.h>int main() {int num;printf("请输入一个整数:");scanf("%d", &num);if (num % 2 == 0) {printf("这是一个偶数。
数据结构(第3版)习题答案
![数据结构(第3版)习题答案](https://img.taocdn.com/s3/m/b3d159fdf90f76c661371a17.png)
简单的函数形式。比较典型的形式是含有n的单个项(带一个常数系数)。表1-1列出了一些
常用的g函数及其名称。对于表1-1中的对数函数logn,没有给出对数基,原因是对于任何大
于1的常数a和b都有logan =logbn/logba,所以logan和logbn都有一个相对的乘法系数1/logba,
合。
1.3两个数据结构的逻辑结构和存储结构都相同,但是它们的运算集合中有一个运算的定义不
一样,它们是否可以认作是同一个数据结构?为什么?
【答】:不能,运算集合是数据结构的重要组成部分,不同的运算集合所确定的数据结构是不
一样的,例如,栈与队列它们的逻辑结构与存储结构可以相同,但由于它们的运算集合不一样,
if (L->data[i]==x) c++;
return c;
}
2.4设计一个算法,将一个顺序表倒置。即,如果顺序表各个结点值存储在一维数组a中,倒
置的结果是使得数组a中的a[0]等于原来的最后一个元素,a[1]等于原来的倒数第2个元
素,…,a的最后一个元素等于原来的第一个元素。
【答】:顺序表的存储结构定义同题2.3,实现顺序表倒置的算法程序如下:
【答】:顺序表的存储结构定义如下(文件名seqlist.h):
#include <stdio.h>
#define N 100
typedef int datatype;
typedef struct {
datatype data[N];
int length;
} seqlist;
/*预定义最大的数据域空间*/
数据结构(C语言版)第三版习题答案
![数据结构(C语言版)第三版习题答案](https://img.taocdn.com/s3/m/9f966375168884868762d699.png)
精神成就事业,态度决定一切。
附录习题参考答案习题1参考答案1.1.选择题(1). A. (2). A. (3). A. (4). B.C. (5). A. (6). A. (7). C. (8). A. (9). B. (10.) A.1.2.填空题(1). 数据关系(2). 逻辑结构物理结构(3). 线性数据结构树型结构图结构(4). 顺序存储链式存储索引存储散列表(Hash)存储(5). 变量的取值范围操作的类别(6). 数据元素间的逻辑关系数据元素存储方式或者数据元素的物理关系(7). 关系网状结构树结构(8). 空间复杂度和时间复杂度(9). 空间时间(10). Ο(n)1.3 名词解释如下:数据:数据是信息的载体是计算机程序加工和处理的对象包括数值数据和非数值数据数据项:数据项指不可分割的、具有独立意义的最小数据单位数据项有时也称为字段或域数据元素:数据元素是数据的基本单位在计算机程序中通常作为一个整体进行考虑和处理一个数据元素可由若干个数据项组成数据逻辑结构:数据的逻辑结构就是指数据元素间的关系数据存储结构:数据的物理结构表示数据元素的存储方式或者数据元素的物理关系数据类型:是指变量的取值范围和所能够进行的操作的总和算法:是对特定问题求解步骤的一种描述是指令的有限序列1.4 语句的时间复杂度为:(1) Ο(n2)(2) Ο(n2)(3) Ο(n2)(4) Ο(n-1)(5) Ο(n3)1.5 参考程序:main(){int XYZ;scanf("%d %d%d"&X&YZ);if (X>=Y)if(X>=Z)if (Y>=Z) { printf("%d %d%d"XYZ);}else{ printf("%d %d%d"XZY);}else{ printf("%d %d%d"ZXY);}else if(Z>=X)if (Y>=Z) { printf("%d %d%d"YZX);}else{ printf("%d%d%d"ZYX);}else{ printf("%d%d%d"YXZ);}}1.6 参考程序:main(){int in;float xa[]p;printf("\nn=");scanf("%f"&n);printf("\nx=");scanf("%f"&x);for(i=0;i<=n;i++)scanf("%f "&a[i]);p=a[0];for(i=1;i<=n;i++){ p=p+a[i]*x;x=x*x;}printf("%f"p)'}习题2参考答案2.1选择题(1). C. (2). B. (3). B. (4). B. 5. D. 6. B. 7. B. 8. A. 9. A. 10. D.2.2.填空题(1). 有限序列(2). 顺序存储和链式存储(3). O(n) O(n)(4). n-i+1 n-i(5). 链式(6). 数据指针(7). 前驱后继(8). Ο(1) Ο(n)(9). s->next=p->next; p->next=s ;(10). s->next2.3. 解题思路:将顺序表A中的元素输入数组a若数组a中元素个数为n将下标为012...(n-1)/2的元素依次与下标为nn-1...(n-1)/2的元素交换输出数组a的元素参考程序如下:main(){int in;float ta[];printf("\nn=");scanf("%f"&n);for(i=0;i<=n-1;i++)scanf("%f "&a[i]);for(i=0;i<=(n-1)/2;i++){ t=a[i]; a[i] =a[n-1-i]; a[n-1-i]=t;} for(i=0;i<=n-1;i++)printf("%f"a[i]);}2.4 算法与程序:main(){int in;float ta[];printf("\nn=");scanf("%f"&n);for(i=0;i<n;i++)scanf("%f "&a[i]);for(i=1;i<n;i++)if(a[i]>a[0]{ t=a[i]; a[i] =a[0]; a[0]=t;}printf("%f"a[0]);for(i=2;i<n;i++)if(a[i]>a[1]{ t=a[i]; a[i] =a[1]; a[1]=t;}printf("%f"a[0]);}2.5 算法与程序:main(){int ijkn;float xta[];printf("\nx=");scanf("%f"&x);printf("\nn=");scanf("%f"&n);for(i=0;i<n;i++)scanf("%f "&a[i]); // 输入线性表中的元素for (i=0; i<n; i++) { // 对线性表中的元素递增排序k=i;for (j=i+1; j<n; j++) if (a[j]<a[k]) k=j; if (k<>j) {t=a[i];a[i]=a[k];a[k]=t;}}for(i=0;i<n;i++) // 在线性表中找到合适的位置if(a[i]>x) break;for(k=n-1;k>=i;i--) // 移动线性表中元素然后插入元素xa[k+1]=a[k];a[i]=x;for(i=0;i<=n;i++) // 依次输出线性表中的元素printf("%f"a[i]);}2.6 算法思路:依次扫描A和B的元素比较A、B当前的元素的值将较小值的元素赋给C如此直到一个线性表扫描完毕最后将未扫描完顺序表中的余下部分赋给C即可C的容量要能够容纳A、B两个线性表相加的长度有序表的合并算法:void merge (SeqList ASeqList BSeqList *C){ int ijk;i=0;j=0;k=0;while ( i<=st && j<=st )if (A.data[i]<=B.data[j])C->data[k++]=A.data[i++];elseC->data[k++]=B.data[j++];while (i<=st )C->data[k++]= A.data[i++];while (j<=st )C->data[k++]=B.data[j++];C->last=k-1;}2.7 算法思路:依次将A中的元素和B的元素比较将值相等的元素赋给C如此直到线性表扫描完毕线性表C就是所求递增有序线性表算法:void merge (SeqList ASeqList BSeqList *C){ int ijk;i=0;j=0;k=0;while ( i<=st)while(j<=st )if (A.data[i]=B.data[j])C->data[k++]=A.data[i++];C->last=k-1;}习题3参考答案3.1.选择题(1). D (2). C (3). D (4). C (5). B (6). C (7). C (8). C (9). B (10).AB (11). D (12). B (13). D (14). C (15). C (16). D(17). D (18). C (19). C (20). C 3.2.填空题(1) FILOFIFO(2) -13 4 X * + 2 Y * 3 / -(3) stack.topstack.s[stack.top]=x(4) p>llink->rlink=p->rlinkp->rlink->llink=p->rlink(5) (R-F+M)%M(6) top1+1=top2(7) F==R(8) front==rear(9) front==(rear+1)%n(10) N-13.3 答:一般线性表使用数组来表示的线性表一般有插入、删除、读取等对于任意元素的操作而栈只是一种特殊的线性表栈只能在线性表的一端插入(称为入栈push)或者读取栈顶元素或者称为"弹出、出栈"(pop)3.4 答:相同点:栈和队列都是特殊的线性表只在端点处进行插入删除操作不同点:栈只在一端(栈顶)进行插入删除操作;队列在一端(top)删除一端(rear)插入3.5 答:可能序列有14种:ABCD; ACBD; ACDB; ABDC; ADCB; BACD; BADC; BCAD; BCDA; BDCA; CBAD; CBDA; CDBA; DCBA3.6 答:不能得到435612最先出栈的是4则按321的方式出不可能得到1在2前的序列可以得到135426按如下方式进行push(1)pop()push(2)push(3)pop()push(4)push(5)pop()pop()pop()push(6)pop()3.7 答:stack3.8 非递归:int vonvert (int noint a[]) //将十进制数转换为2进制存放在a[] 并返回位数{int r;SeStack s*p;P=&s;Init_stack(p);while(no){push(pno%2);no/=10;}r=0;while(!empty_stack(p)){pop(pa+r);r++;}return r;}递归算法:void convert(int no){if(no/2>0){Convert(no/2);Printf("%d"no%2);}elseprintf("%d"no);}3.9 参考程序:void view(SeStack s){SeStack *p; //假设栈元素为字符型char c;p=&s;while(!empty_stack(p)){c=pop(p);printf("%c"c);}printf("\n");}3.10 答:char3.11 参考程序:void out(linkqueue q){int e;while(q.rear !=q.front ){dequeue(qe);print(e); //打印}}习题4参考答案4.1 选择题:(1). A (2). D (3). C (4). C (5). B (6). B (7). D (8). A (9). B (10). D 4.2 填空题:(1)串长相等且对应位置字符相等(2)不含任何元素的串(3)所含字符均是空格所含空格数(4) 10(5) "hello boy"(6) 13(7) 1066(8)模式匹配(9)串中所含不同字符的个数(10) 364.3 StrLength (s)=14StrLength (t)=4SubStr( s87)=" STUDENT"SubStr(t21)="O"StrIndex(s"A")=3StrIndex (st)=0StrRep(s"STUDENT"q)=" I AM A WORKER"4.4 StrRep(s"Y""+");StrRep(s"+*""*Y");4.5 空串:不含任何字符;空格串:所含字符都是空格串变量和串常量:串常量在程序的执行过程中只能引用不能改变;串变量的值在程序执行过程中是可以改变和重新赋值的主串与子串:子串是主串的一个子集串变量的名字与串变量的值:串变量的名字表示串值的标识符4.6int EQUAl(ST){char *p*q;p=&S;q=&T;while(*p&&*q){if(*p!=*q)return *p-*q;p++;q++;}return *p-*q;}4.7(1)6*8*6=288(2)1000+47*6=1282(3)1000+(8+4)*8=1096(4)1000+(6*7+4)*8=13684.8习题5参考答案5.1 选择(1)C(2)B(3)C(4)B(5)C(6)D(7)C(8)C(9)B(10)C (11)B(12)C(13)C(14)C(15)C(16)B5.2 填空(1)1(2)1036;1040(3)2i(4) 1 ; n ; n-1 ; 2(5)2k-1;2k-1(6)ACDBGJKIHFE(7)p!=NULL(8)Huffman树(9)其第一个孩子; 下一个兄弟(10)先序遍历;中序遍历5.3叶子结点:C、F、G、L、I、M、K;非终端结点:A、B、D、E、J;各结点的度:结点: A B C D E F G L I J K M度: 4 3 0 1 2 0 0 0 0 1 0 0树深:4无序树形态如下:二叉树形态如下:5.5二叉链表如下:三叉链表如下:5.6先序遍历序列:ABDEHICFJG中序遍历序列:DBHEIAFJCG后序遍历序列:DHIEBJFGCA5.7(1) 先序序列和中序序列相同:空树或缺左子树的单支树;(2) 后序序列和中序序列相同:空树或缺右子树的单支树;(3) 先序序列和后序序列相同:空树或只有根结点的二叉树5.8这棵二叉树为:先根遍历序列:ABFGLCDIEJMK后根遍历序列:FGLBCIDMJKEA层次遍历序列:ABCDEFGLIJKM5.10证明:设树中结点总数为n叶子结点数为n0则n=n0 + n1 + ...... + nm (1)再设树中分支数目为B则B=n1 + 2n2 + 3n3 + ...... + m nm (2)因为除根结点外每个结点均对应一个进入它的分支所以有n= B + 1 (3)将(1)和(2)代入(3)得n0 + n1 + ...... + nm = n1 + 2n2 + 3n3 + ...... + m nm + 1 从而可得叶子结点数为:n0 = n2 + 2n3 + ...... + (m-1)nm + 15.11由5.10结论得n0 = (k-1)nk + 1又由 n=n0 + nk得nk= n-n0代入上式得n0 = (k-1)(n-n0)+ 1叶子结点数为:n0 = n (k-1) / k5.12int NodeCount(BiTree T){ //计算结点总数if(T)if (T-> lchild==NULL )&&( T --> rchild==NULL )return 1;elsereturn NodeCount(T-> lchild ) +Node ( T --> rchild )+1; elsereturn 0;}void ExchangeLR(Bitree bt){/* 将bt所指二叉树中所有结点的左、右子树相互交换 */ if (bt && (bt->lchild || bt->rchild)) {bt->lchild<->bt->rchild;Exchange-lr(bt->lchild);Exchange-lr(bt->rchild);}}/* ExchangeLR */5.14int IsFullBitree(Bitree T){/* 是则返回1否则返回0*/Init_Queue(Q); /* 初始化队列*/flag=0;In_Queue(QT); /* 根指针入队列按层次遍历*/while(!Empty_Queue (Q)){Out_Queue(Qp);if(!p) flag=1; /* 若本次出队列的是空指针时则修改flag值为1若以后出队列的指针存在非空则可断定不是完全二叉树 */else if (flag) return 0; /*断定不是完全二叉树 */ else{In_Queue(Qp->lchild);In_Queue(Qp->rchild); /* 不管孩子是否为空都入队列*/}}/* while */return 1; /* 只有从某个孩子指针开始之后所有孩子指针都为空才可断定为完全二叉树*/}/* IsFullBitree */转换的二叉树为:5.16对应的森林分别为:5.17typedef char elemtype;typedef struct{ elemtype data;int parent;} NodeType;(1) 求树中结点双亲的算法:int Parent(NodeType t[ ]elemtype x){/* x不存在时返回-2否则返回x双亲的下标(根的双亲为-1 */for(i=0;i<MAXNODE;i++)if(x==t[i].data) return t[i].parent; return -2;}/*Parent*/(2) 求树中结点孩子的算法:void Children(NodeType t[ ]elemtype x){for(i=0;i<MAXNODE;i++){if(x==t[i].data)break;/*找到x退出循环*/}/*for*/if(i>=MAXNODE) printf("x不存在\n"); else {flag=0;for(j=0;j<MAXNODE;j++)if(i==t[j].parent){ printf("x的孩子:%c\n"t[j].data);flag=1;}if(flag==0) printf("x无孩子\n");}/*Children*/5.18typedef char elemtype;typedef struct ChildNode{ int childcode;struct ChildNode *nextchild;}typedef struct{ elemtype data;struct ChildNode *firstchild;} NodeType;(1) 求树中结点双亲的算法:int ParentCL(NodeType t[ ]elemtype x){/* x不存在时返回-2否则返回x双亲的下标 */for(i=0;i<MAXNODE;i++)if(x==t[i].data) {loc=i;/*记下x的下标*/break;}if(i>=MAXNODE) return -2; /* x不存在 *//*搜索x的双亲*/for(i=0;i<MAXNODE;i++)for(p=t[i].firstchild;p!=NULL;p=p->nextchild) if(loc==p->childcode)return i; /*返回x结点的双亲下标*/}/* ParentL */(2) 求树中结点孩子的算法:void ChildrenCL(NodeType t[ ]elemtype x){for(i=0;i<MAXNODE;i++)if(x==t[i].data) /*依次打印x的孩子*/{flag=0; /* x存在 */for(p=t[i].firstchild;p;p=p->nextchild){ printf("x的孩子:%c\n"t[p-> childcode].data);flag=1;}if(flag==0) printf("x无孩子\n");return;}/*if*/printf("x不存在\n");return;}/* ChildrenL */5.19typedef char elemtype;typedef struct TreeNode{ elemtype data;struct TreeNode *firstchild; struct TreeNode *nextsibling; } NodeType;void ChildrenCSL(NodeType *telemtype x){ /* 层次遍历方法 */Init_Queue(Q); /* 初始化队列 */In_Queue(Qt);count=0;while(!Empty_Queue (Q)){Out_Queue(Qp);if(p->data==x){ /*输出x的孩子*/p=p->firstchild;if(!p) printf("无孩子\n");else{ printf("x的第%i个孩子:%c\n"++countp->data);/*输出第一个孩子*/p=p->nextsibling; /*沿右分支*/while(p){printf("x的第%i个孩子:%c\n"++countp->data);p=p-> nextsibling;}}return;}if(p-> firstchild) In_Queue(Qp-> firstchild);if(p-> nextsibling) In_Queue(Qp-> nextsibling);}}/* ChildrenCSL */5.20(1) 哈夫曼树为:(2) 在上述哈夫曼树的每个左分支上标以1右分支上标以0并设这7个字母分别为A、B、C、D、E、F和H如下图所示:则它们的哈夫曼树为分别为:A:1100B:1101C:10D:011E:00F:010H:111习题6参考答案6.1 选择题(1)C (2)A (3)B(4)C(5)B______条边(6)B(7)A(8)A(9)B(10)A(11)A(12)A(13)B(14)A(15)B(16)A(17)C 6.2 填空(1) 4(2) 1对多 ; 多对多(3) n-1 ; n(4) 0_(5)有向图(6) 1(7)一半(8)一半(9)___第i个链表中边表结点数___(10)___第i个链表中边表结点数___(11)深度优先遍历;广度优先遍历(12)O(n2)(13)___无回路6.3(1)邻接矩阵:(2)邻接链表:(3)每个顶点的度:顶点度V1 3V2 3V3 2V4 3V5 36.4(1)邻接链表:(2)逆邻接链表:(3)顶点入度出度V1 3 0V2 2 2V3 1 2V4 1 3V5 2 1V6 2 36.5(1)深度优先查找遍历序列:V1 V2 V3 V4 V5; V1 V3 V5 V4 V2; V1 V4 V3 V5 V2 (1)广度优先查找遍历序列:V1 V2 V3 V4 V5; V1 V3 V2 V4 V5; V1 V4 V3 V2 V56.6有两个连通分量:6.7顶点(1)(2)(3)(4)(5)Low Close Cost VexLow CloseCost VexLow CloseCost VexLow CloseCost VexLow CloseCost VexV10 00 00 00 00 0V21 00 00 00 00 0V31 01 00 00 00 0V43 02 12 10 10 1V5∞ 05 13 22 30 3U{v1} {v1v2} {v1v2v3} {v1 v2 v3 v4} {v1 v2 v3 v4 v5} T {} { (v1 v2) } {(v1 v2) (v1 v3) } {(v1 v2) (v1 v3) (v2 v4) } {(v1 v2) (v1v3)(v2v4)(v4v5) }最小生成树的示意图如下:6.8拓扑排序结果: V3--> V1 --> V4 --> V5 --> V2 --> V66.9(1)建立无向图邻接矩阵算法:提示:参见算法6.1因为无向图的邻接矩阵是对称的所以有for (k=0; k<G ->e; k++) /*输入e条边建立无向图邻接矩阵*/{ scanf("\n%d%d"&i&j);G ->edges[i][j]= G ->edges[j][i]=1;}(2)建立无向网邻接矩阵算法:提示:参见算法6.1初始化邻接矩阵:#define INFINITY 32768 /* 表示极大值*/for(i=0;i<G->n;i++)for(j=0;j<G->n;j++) G->edges[i][j]= INFINITY;输入边的信息:不仅要输入边邻接的两个顶点序号还要输入边上的权值for (k=0; k<G ->e; k++) /*输入e条边建立无向网邻接矩阵*/{ scanf("\n%d%d%d"&i&j&cost); /*设权值为int型*/G ->edges[i][j]= G ->edges[j][i]=cost;/*对称矩阵*/}(3)建立有向图邻接矩阵算法:提示:参见算法6.16.10(1)建立无向图邻接链表算法:typedef VertexType char;int Create_NgAdjList(ALGraph *G){ /* 输入无向图的顶点数、边数、顶点信息和边的信息建立邻接表 */scanf("%d"&n); if(n<0) return -1; /* 顶点数不能为负 */G->n=n;scanf("%d"&e); if(e<0) return =1; /*边数不能为负 */G->e=e;for(m=0;m< G->n ;m++)G-> adjlist [m].firstedge=NULL; /*置每个单链表为空表*/for(m=0;m< G->n;m++)G->adjlist[m].vertex=getchar(); /*输入各顶点的符号*/for(m=1;m<= G->e; m++){scanf("\n%d%d"&i&j); /* 输入一对邻接顶点序号*/if((i<0 || j<0) return -1;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第i+1个链表中插入一个边表结点*/ p->adjvex=j;p->next= G-> adjlist [i].firstedge;G-> adjlist [i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第j+1个链表中插入一个边表结点*/ p->adjvex=i;p->next= G-> adjlist [j].firstedge;G-> adjlist [j].firstedge=p;} /* for*/return 0; /*成功*/}//Create_NgAdjList(2)建立有向图逆邻接链表算法:typedef VertexType char;int Create_AdjList(ALGraph *G){ /* 输入有向图的顶点数、边数、顶点信息和边的信息建立逆邻接链表 */scanf("%d"&n); if(n<0) return -1; /* 顶点数不能为负 */G->n=n;scanf("%d"&e); if(e<0) return =1; /*弧数不能为负 */G->e=e;for(m=0;m< G->n; m++)G-> adjlist [m].firstedge=NULL; /*置每个单链表为空表*/for(m=0;m< G->n;m++)G->adjlist[m].vertex=getchar(); /*输入各顶点的符号*/for(m=1;m<= G->e ; m++){scanf("\n%d%d"&t&h); /* 输入弧尾和弧头序号*/if((t<0 || h<0) return -1;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第h+1个链表中插入一个边表结点*/ p->adjvex=t;p->next= G-> adjlist [h].firstedge;G-> adjlist [h].firstedge=p;} /* for*/return 0; /*成功*/}//Create_AdjList6.11void Create_AdjM(ALGraph *G1MGraph *G2){ /*通过无向图的邻接链表G1生成无向图的邻接矩阵G2*/G2->n=G1->n; G2->e=G1->e;for(i=0;i<G2->n;i++) /* 置G2每个元素为0 */for(j=0;j<G2->n;j++) G2->edges[i][j]= 0;for(m=0;m< G1->n;m++)G2->vexs[m]=G1->adjlist[m].vertex; /*复制顶点信息*/num=(G1->n/2==0?G1->n/2:G1->n/2+1); /*只要搜索前n/2个单链表即可*/for(m=0;m< num;m++){ p=G1->adjlist[m].firstedge;while(p){ /* 无向图的存储具有对称性*/G2->edges[m][ p->adjvex ]= G2->edges[p->adjvex ] [m] =1;p==p->next;}}/* for */}/*Create_AdjM */void Create_AdjL(ALGraph *G1MGraph *G2){ /*通过无向图的邻接矩阵G1生成无向图的邻接链表G2*/G2->n=G1->n; G2->e=G1->e;for(i=0;i<G1->n;i++) /* 建立每个单链表 */{ G2->vexs[i]=G1->adjlist[i].vertex;G2->adjlist[i].firstedge=NULL;for(j=i; j<G1->n; j++) /*对称矩阵只要搜索主对角以上的元素即可*/{ if(G1->edges[i][j]== 1){ p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第i+1个链表中插入一个边表结点*/p->adjvex=j;p->next= G-> adjlist [i].firstedge;G-> adjlist [i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第j+1个链表中插入一个边表结点*/p->adjvex=i;p->next= G-> adjlist [j].firstedge;G-> adjlist [j].firstedge=p;}/*if*/}/* for*/}/* for*/}/* Create_AdjL */6.13(1) 邻接矩阵中1的个数的一半;(2) 若位于[i-1j-1]或[j-1i-1]位置的元素值等于1则有边相连否则没有(3) 顶点i的度等于第i-1行中或第i-1列中1的个数6.14(1) 邻接链表中边表结点的个数的一半;(2) 若第i-1(或j-1)个单链表中存在adjvex域值等于j-1(或i-1)的边表结点则有边相连否则没有(3) 顶点i的度等于第i-1个单链表中边表结点的个数提示:参见算法6.2 和6.3习题 7参考答案7.1 选择题(1)C (2)C (3) C (4)B (5) A (6)A (7) D (8)B (9)D (10) B(11)B (12)A (13)C (14)C (15)A (16)D (17)C (18)BC (19)B (20)A7.2 填空题(1) O(n)O(log2n)(2) 12485log2(n+1)-1(3)小于大于(4)增序序列(5)m-1(6) 70; 342055(7) n/m(8)开放地址法链地址法(9)产生冲突的可能性就越大产生冲突的可能性就越小(10)关键码直接(11)②①⑦(12) 1616821(13)直接定址法数字分析法平方取中法折叠法除留余数法随机数法(14)开放地址法再哈希法链地址法建立一个公共溢出区(15)装满程度(16)索引快(17)哈希函数装填因子(18)一个结点(19)中序(20)等于7.3 一棵二叉排序树(又称二叉查找树)或者是一棵空树或者是一棵同时满足下列条件的二叉树:(1)若它的左子树不空则左子树上所有结点的键值均小于它根结点键值(2)若它的右子树不空则右子树上所有结点的键值均大于它根结点键值(3)它的左、右子树也分别为二叉排序树7.4 对地址单元d=H(K)如发生冲突以d为中心在左右两边交替进行探测按照二次探测法键值K的散列地址序列为:do=H(K)d1=(d0+12)mod md2=(d0-12)mod md3=(d0+22)mod md4=(d0-12)mod m......7.5 衡量算法的标准有很多时间复杂度只是其中之一尽管有些算法时间性能很好但是其他方面可能就存在着不足比如散列查找的时间性能很优越但是需要关注如何合理地构造散列函数问题而且总存在着冲突等现象为了解决冲突还得采用其他方法二分查找也是有代价的因为事先必须对整个查找区间进行排序而排序也是费时的所以常应用于频繁查找的场合对于顺序查找尽管效率不高但却比较简单常用于查找范围较小或偶而进行查找的情况7.6此法要求设立多个散列函数Hii=1...k当给定值K与闭散列表中的某个键值是相对于某个散列函数Hi的同义词因而发生冲突时继续计算该给定值K在下一个散列函数Hi+1下的散列地址直到不再产生冲突为止7.7散列表由两个一维数组组成一个称为基本表另一个称为溢出表插入首先在基本表上进行;假如发生冲突则将同义词存人溢出表7.8 结点个数为n时高度最小的树的高度为1有两层它有n-1个叶结点1个分支结点;高度最大的树的高度为n-l有n层它有1个叶结点n-1个分支结点7.9 设顺序查找以h为表头指针的有序链表若查找成功则返回结点指针p查找失败则返回null值pointer sqesrearch(pointer hint xpointerp){p=null;while(h)if(x>h->key)h=h->link;else{if(x==h->key)p=h;return(p);}}虽然链表中的结点是按从小到大的顺序排列的但是其存储结构为单链表查找结点时只能从头指针开始逐步进行搜索故不能用折半(二分)查找7.10 分析:对二叉排序树来讲其中根遍历序列为一个递增有序序列因此对给定的二叉树进行中根遍历如果始终能保证前一个值比后一个值小则说明该二叉树是二叉排序树int bsbtr (bitreptr T) /*predt记录当前结点前趋值初值为-∞*/{ if (T==NULL) return(1);else{b1=bsbtr(T->lchild);/*判断左子树*/if (!b1|| (predt>=T->data)) return(0);*当前结点和前趋比较*/ predt=T->data;/*修改当前结点的前趋值*/return(bsbtr(T->rchild));/*判断右子树并返回最终结果*/}}7.11 (1)使用线性探查再散列法来构造散列表如表下所示散列表───────────────────────────────地址 0 1 2 3 4 5 6 7 8 9 10───────────────────────────────数据 33 1 13 12 34 38 27 22───────────────────────────────(2)使用链地址法来构造散列表如下图(3)装填因子a=8/11使用线性探查再散列法查找成功所需的平均查找次数为Snl=0.5(1+1/(1-a))=0.5*(1+1/(1-8/11))=7/3使用线性探查再散列法查找不成功所需的平均查找次数为:Unl=0.5(1+1/(1-a)2)=0.5*(1+1/(1-8/11)2)=65/9 使用链地址法查找成功所需的平均查找次数为:Snc=l+a/2=1+8/22=15/11使用链地址法查找不成功所需的平均查找次数为: 'Unl=a+e-a=8/1l+e-8/117.12 分析:在等查区间的上、下界处设两个指针由此计算出中间元素的序号当中间元素大于给定值X时接下来到其低端区间去查找;当中间元素小于给定值X时接下来到其高端区间去查找;当中间元素等于给定值X时表示查找成功输出其序号Int binlist(sqtable Aint stkeytype X) /*t、s分别为查找区间的上、下界*/{ if(s<t) return(0);/*查找失败*/else{ mid=(S+t)/2;switCh(mid){case x<A.item[midJ.key: return(binlist(Asmid-lX));/*在低端区间上递归*/case x==A.item[mid].key: return(mid);/+查找成功*/ case x>A.item[mid].key: return(amid+ltX));/*在高端区间上递归*/}}}int sqsearch0 (sqtable Akeytype X) /*数组有元素n个*/{ i=l;A.item[n+1].key=X;/t设置哨兵*/while (A.item[n+1].key!=X) i++;return (i% (n/1));/*找不到返回0找到返回其下标*/}查找成功平均查找长度为:(1+2+3+...+n)/n:(1+n)/2查找不成功平均查找长度为:n+17.14散列函数:H(key)=100+(key个位数+key十位数) mod l0;形成的散列表:100 101 102 103 104 105 106 107 108 10998 75 63 46 49 79 61 53 17查找成功时的平均长度为:(1+2+1+1+5+1+1+5+5+3)/10=2.5次由于长度为10的哈希表已满因此在插人第11个记录时所需作的比较次数的期望值为10查找不成功时的平均长度为10习题 8参考答案8.1 选择题(1)B (2)A (3)D (4)C (5)B (6)A (7)B (8)C (9)A (10)C(11)D (12)C (13) C (14)D (15)C (16)B (17) D (18)C (19)B (20)D8.2填空题(1)快速归并(2) O(log2n)O(nlog2n)(3)归并(4)向上根结点(5) 1918162030(6)(7)4913275076386597(8)88(9)插入选择(每次选择最大的)(10)快速归并(11)O(1)O(nlog2n)(12)稳定(13)3(14)(15205040)(15)O(log2n)(16)O(n2)(17)冒泡排序快速排序(18)完全二叉树n/2(19)稳定不稳定(20)24(2015)8.3. 假定给定含有n个记录的文件(r1f2...rn)其相应的关键字为(k1k2...kn)则排序就是确定文件的一个序列rrr2...rn使得k1'≤k2'≤...≤kn'从而使得文件中n个记录按其对应关键字有序排列如果整个排序过程在内存中进行则排序叫内部排序假设在待排序的文件中存在两个或两个以上的记录具有相同的关键字若采用某种排序方法后使得这些具有相同关键字的记录在排序前后相对次序依然保持不变则认为该排序方法是稳定的否则就认为排序方法是不稳定的8.4.稳定的有:直接插入排序、二分法插入排序、起泡排序、归并排序和直接选择排序8.5.初始记录序列按关键字有序或基本有序时比较次数为最多8.6.设5个元素分别用abcde表示取a与b、c与d进行比较若a>bc>d(也可能是a<bc<d此时情况类似)显然此时进行了两次比较取b与d再比较若b>d则a>b>d若b<d则有c>d>b此时已进行了3次比较要使排序比较最多7次可把另外两个元素按折半检索排序插入到上面所得的有序序列中此时共需要4次比较从而可得算法共只需7次比较8.7.题目中所说的几种排序方法中其排序速度都很快但快速排序、归并排序、基数排序和Shell排序都是在排序结束后才能确定数据元素的全部序列而排序过程中无法知道部分连续位置上的最终元素而堆排序则是每次输出一个堆顶元素(即最大或最少值的元素)然后对堆进行再调整保证堆顶元素总是当前剩下元素的最大或最小的从而可知欲在一个大量数据的文件中如含有15000个元素的记录文件中选取前10个最大的元素可采用堆排序进行8.8.二分法排序8.9.void insertsort(seqlist r)  ;{ //对顺序表中记录R[0一N-1)按递增序进行插入排序&NBSP;int ij;  ;for(i=n-2;i>=0; i--) //在有序区中依次插入r[n-2]..r[0]  ;if(r[i].key>r[i+1].key) //若不是这样则r[i]原位不动 ;{  ;r[n]=r[i];j=i+l;//r[n]是哨兵 ;do{ //从左向右在有序区中查找插入位置 ;r[j-1]= r[j];//将关键字小于r[i].key的记录向右移 ;j++;  ;}whle(r[j].key r[j-1]=r[n];//将引i)插入到正确位置上 ;}//endif ;}//insertsort.  ;8.10.建立初始堆:[937 694 863 265 438 751 742129075 3011]&NBSP;&NBSP;第一次排序重建堆:[863 694 751 765 438 301 742 129 075]9378.11.在排序过程中每次比较会有两种情况出现若整个排序过程至少需作t次比较则显然会有2^t个情况由于n个结点总共有n!种不同的排列因而必须有n!种不同的比较路径于是: 2t≥n!即t≥log2n!因为log2nl=nlog2n-n/ln2+log2n/2+O(1)故有log2n!≈nlog2n从而t≧nlog2n得证8.12.依据堆定义可知:序列(1)、(2)、(4)是堆(3)不是堆从而可对其调整使之为如下的大根堆(1009580604095821020)8.13.第一趟:[265 301] [129 751] [863 937] [694 742] [076 438]&NBSP; &NBSP;第二趟:[129 265 301 751] [694 742 863 937] [076 438]&NBSP;&NBSP;第三趟:[129 265 301 694 742 751 863 937] [076 438]&NBSP;&NBSP;第四趟:[076 129 265 301 438 694 742 751 863 937]&NBSP;8.14.(1)归并排序:(1829) (2547) (1258) (1051)(18252947) (10125158)(1012182529475158)(2)快速排序:(1018251229585147)(1018251229475158)(1012182529475158)(3)堆排序:初始堆(大顶堆):(58 47512918122510)第一次调整:(51 472529181210)(58)第二次调整:(47 2925101812)(5158)第三次调整:(29 18251012)(475158)第四次调整:(25 181210)(29475158)第五次调整:(18 1012)(2529475158)第六次调整:(12 10) (182529475158)第七次调整:(10 12182529475158)8.15.(1)直接插入排序序号 1 2 3 4 5 6 7 8 9 10 11 12 关键字 83 40 63 13 84 35 96 57 39 79 61 151=2 40 83 [63 13 84 35 96 57 39 79 61 15] 1=3 40 63 83 [13 84 35 96 57 39 79 61 15] 1=4 13 40 63 83 [84 3 5 96 57 39 79 61 15] I=5 13 40 63 83 84 [35 96 57 39 79 61 15] I=6 13 35 40 63 83 84 [96 57 39 79 61 15] 1=7 13 35 40 63 83 84 96 [57 39 79 61 15] 1=8 13 35 40 57 63 83 84 96 [ 39 79 61 15] 1=9 13 35 39 40 57 63 83 84 96 [79 61 15] I=10 13 35 39 40 57 63 79 83 84 96 [61 15] I=11 13 35 39 40 57 61 63 79 83 84 96 [15] 1=12 13 15 35 39 40 57 61 63 79 83 84 96 (2)直接选择排序序号 1 2 3 4 5 6 7 8 9 10 11 12 关键字 83 40 63 13 84 35 96 57 39 79 61 15i=1 13 [ 40 63 83 84 35 96 57 39 79 61 15] i=2 13 15 [63 83 84 35 96 57 39 79 61 40] i=3 13 15 35 [83 84 63 96 57 39 79 61 40] i=4 13 15 35 39 [84 63 96 57 83 79 61 40] i=5 13 15 35 39 40 [63 96 57 83 79 61 84] i=6 13 15 35 39 40 57 [96 63 83 79 61 84] i=7 13 15 35 39 40 57 61 [63 83 79 96 84] i=8 13 15 35 39 40 57 61 63 [83 79 96 84] i=9 13 15 35 39 40 57 61 63 79 183 96 84] i=10 13 15 35 39 40 57 61 63 79 83 [96 84] i=11 13 15 35 39 40 57 61 63 79 83 84 [96] (3)快速排序关键字 83 40 63 13 84 35 96 57 39 79 61 15 第一趟排序后 [15 40 63 13 61 35 79 57 39] 83 [96 84] 第二趟排序后 [13] 15 [63 40 61 35 79 57 39] 83 84 [96] 第三趟排序后 13 15 [39 40 61 35 57] 63 [79] 83 84 96 第四趟排序后 13 15 [35] 39 [61 40 57] 63 79 83 84 96第五趟排序后 13 15 35 39 [57 40] 61 63 79 83 84 96 第六趟排序后 13 15 35 39 40 [57] 61 63 79 83 84 96 第七趟排序后 13 15 35 39 40 57 61 63 79 83 84 96 (4)堆排序关键字 83 40 63 13 84 35 96 57 39 79 61 15排序成功的序列 96 84 83 79 63 61 57 40 39 35 15 13(5)归并排序关键字 83 40 63 13 84 35 96 57 39 79 61 15 第一趟排序后 [40 83] [13 63] [3584] [57 96] [39 79] [15 61]第二趟排序后 [13 40 63 83] [35 57 84 96] [15 39 61 79] 第三趟排序后 [13 35 40 57 63 83 84 96]] [15 39 61 79] 第四趟排序后 13 15 35 39 40 57 61 63 79 83 84 96。
C语言第三版全部习题(答案)-new
![C语言第三版全部习题(答案)-new](https://img.taocdn.com/s3/m/eeadb1c780eb6294dd886cd1.png)
习题 1一、选择题1.B2.A3.B4.A5.B6.D二、阅读程序写出结果。
1.I love China!we are students.2. 6三、程序设计题解:main(){int a,b,c,v;a=10;b=20;c=15;v=a*b*c;printf("v=%d",v);}本程序运行结果为:v=3000习题 2一、选择题1. C2. B3. A4. A5. A6. C7. D 8. C 9. D 10. C 11. B 12. A二、程序阅读题1.3,2,-8,23.000000,2.500000,-8.0000002.4,43. 3 1 2 34.aabb cc abc三、程序设计题:#define M 5main(){ int n,c;n=2; c=M*n;printf("%d\n",c); }本程序运行结果为:10习题 3一、选择题1. A2. C3. D4. C5. C二、程序阅读题1.x=3,a=2,b=32.z=12.7000003.121a212三、程序填空:a=a+bb=a-ba=a-b四、程序设计题#include<math.h>main(){ int n;float rate=0.0225,capital,deposit;scanf("%d,%f",&n,&capital);deposit=capital*pow(1+rate,n);printf("deposit=%f\n",deposit); }习题 4一、选择题1. B2. B3. B4. B5. C6. D7. C 8. A二、填空题1. 02. x>40&&x<=60||x<1203. 最近的4.3 2 25. -1三、程序填空:1.(ch>='A'&&ch<='Z')|| (ch>='a'&&ch<='z')2.ch>='0'&&ch<='9'3.ch==' '4.4142四、程序设计题1.#include<stdio.h>main(){char ch;ch=getchar();if(ch>='A'&&ch<='Z') ch+=32;else if(ch>='a'&&ch<='z') ch-=32;putchar(ch);putchar('\n'); }2.解:main(){float x,y;scanf("%f",&x);if(x>-1)y=2*x;else if(x==1)y=3;else y=4+x;printf("y=%f",y);}本程序运行结果为:-2<CR>y=2.0000003.main(){ int x;scanf("%d",&x);if(x%2==0) printf("Is Even\n"); else printf("Is Odd\n"); }习题 5一、选择题1. C2. C3. D4. A5. B6. D7. C 8. C 9. D 10. B二、程序阅读题1.sum=32.程序的功能是 1至10偶数求乘积,奇数求和,运行结果为 sum=25 mul=3840.000000 。
数据结构C语言第三版习题6参考答案
![数据结构C语言第三版习题6参考答案](https://img.taocdn.com/s3/m/b1165b681eb91a37f1115c5d.png)
习题6参考答案6.1 选择题(1)C (2)A (3)B(4)C(5)B(6)B(7)A(8)A(9)B(10)A (11)A(12)A(13)B(14)D(15)B(16)A(17)C6.2 填空(1) 4(2) 1对多 ; 多对多(3) n-1 ; n(4) 0_(5)有向图(6) 1(7)两倍(8)两倍(9)___第i个链表中边表结点数___(10)___第i个链表中边表结点数___(11)深度优先遍历;广度优先遍历(12)O(n2)(13)___无回路6.3(1)邻接矩阵:(2)邻接链表:(3)每个顶点的度:顶点度V1 3V2 3V3 2V4 3V5 36.4(1)邻接链表:(2)逆邻接链表:(3)顶点入度出度V1 3 0V2 2 2V3 1 2V4 1 3V5 2 1V6 2 36.5(1)深度优先查找遍历序列:V1 V2 V3 V4 V5; V1 V3 V5 V4 V2; V1 V4 V3 V5 V2 (1)广度优先查找遍历序列:V1 V2 V3 V4 V5; V1 V3 V2 V4 V5; V1 V4 V3 V2 V56.6有两个连通分量:6.7最小生成树的示意图如下:6.8拓扑排序结果: V3→ V1 → V4 → V5 → V2 → V66.9(1)建立无向图邻接矩阵算法: 提示:参见算法6.1因为无向图的邻接矩阵是对称的,所以有for (k=0; k<G ->e; k++) /*输入e 条边,建立无向图邻接矩阵*/ { scanf("\n%d,%d",&i,&j);G ->edges[i][j]= G ->edges[j][i]=1; }(2)建立无向网邻接矩阵算法: 提示:参见算法6.1 。
初始化邻接矩阵:#define INFINITY 32768 /* 表示极大值*/for(i=0;i<G->n;i++)for(j=0;j<G->n;j++) G->edges[i][j]= INFINITY;输入边的信息:不仅要输入边邻接的两个顶点序号,还要输入边上的权值for (k=0; k<G ->e; k++) /*输入e条边,建立无向网邻接矩阵*/{ scanf("\n%d,%d,%d",&i,&j,&cost); /*设权值为int型*/G ->edges[i][j]= G ->edges[j][i]=cost;/*对称矩阵*/}(3)建立有向图邻接矩阵算法:提示:参见算法6.1。
c语言程序设计教程第三版课后习题
![c语言程序设计教程第三版课后习题](https://img.taocdn.com/s3/m/7e34c97f182e453610661ed9ad51f01dc2815721.png)
c语言程序设计教程第三版课后习题C语言程序设计教程第三版课后习题习题1:基本数据类型练习编写一个程序,使用C语言的基本数据类型:整型(int)、浮点型(float)、双精度浮点型(double)和字符型(char)。
要求程序能够:- 声明这些类型的变量,并分别赋值。
- 打印出这些变量的值和类型。
习题2:算术运算符编写一个程序,演示C语言中的加(+)、减(-)、乘(*)、除(/)和模(%)运算符。
要求程序能够:- 计算两个整数的加、减、乘、除和模的结果。
- 计算两个浮点数的加、减、乘、除的结果。
- 打印出每种运算的结果。
习题3:条件语句编写一个程序,使用if、else if和else语句来处理不同的条件。
要求程序能够:- 根据输入的整数,判断它是否为正数、负数或零。
- 如果输入的整数大于10,则打印“大于10”。
- 如果输入的整数小于10,则打印“小于10”。
习题4:循环语句编写一个程序,使用for、while和do-while循环来执行重复操作。
要求程序能够:- 使用for循环打印从1到10的数字。
- 使用while循环打印从1到5的数字。
- 使用do-while循环打印从1到3的数字。
习题5:数组和字符串编写一个程序,演示数组和字符串的基本操作。
要求程序能够:- 声明一个整型数组和一个字符数组。
- 为数组赋值并打印数组元素。
- 使用字符串函数,如strlen()、strcpy()和strcat(),操作字符串。
习题6:函数的使用编写一个程序,使用自定义函数来完成特定的任务。
要求程序能够:- 编写一个函数,计算两个数的最大值。
- 编写一个函数,将一个字符串反转。
- 在主函数中调用这些函数,并打印结果。
习题7:指针的应用编写一个程序,演示指针的基本操作。
要求程序能够:- 声明一个整型变量和一个指向该变量的指针。
- 使用指针来修改变量的值。
- 声明一个指针数组,并使用它来存储和打印一系列整数。
习题8:结构体和联合体编写一个程序,使用结构体(struct)和联合体(union)来组织数据。
数据结构c语言第三版,邓文华编习题3答案
![数据结构c语言第三版,邓文华编习题3答案](https://img.taocdn.com/s3/m/62037b66ff4733687e21af45b307e87101f6f817.png)
数据结构c语言第三版,邓文华编习题3答案习题3参考答案.选择题(1). D (2). C (3). D (4). C (5). B (6). C (7). C (8). C (9). B (10).B(11). D (12). B (13). D (14). C (15). C (16). C (17). D (18). C (19).C (20).B.填空题(1)FILO, FIFO(2)-1, 3 4 X * + 2 Y * 3 / -(3), []=x(4)p>llink->rlink=p->rlink, p->rlink->llink=p->rlink(5)(R-F+M)%M(6)top1+1==top2(7)F==R(8)front==rear(9)front==(rear+1)%n(10)N-1答:一般线性表使用数组来表示的线性表一般有插入、删除、读取等对于任意元素的操作而栈只是一种特殊的线性表栈只能在线性表的一端插入(称为入栈,push)或者读取栈顶元素或者称为“弹出、出栈”(pop)。
答:相同点:栈和队列都是特殊的线性表,只在端点处进行插入,删除操作。
不同点:栈只在一端(栈顶)进行插入,删除操作;队列在一端(top)删除,一端(rear)插入。
答:可能序列有14种:ABCD; ACBD; ACDB; ABDC; ADCB; BACD; BADC; BCAD; BCDA; BDCA; CBAD; CBDA; CDBA; DCBA。
答:不能得到4,3,5,6,1,2,最先出栈的是4,则按321的方式出,不可能得到1在2前的序列,可以得到1,3,5,4,2,6,按如下方式进行push(1), pop(), push(2), push(3), pop(), push(4), push(5), pop(), pop(), pop(), push(6), pop()。
数据结构c语言版第三版习题解答
![数据结构c语言版第三版习题解答](https://img.taocdn.com/s3/m/034339725b8102d276a20029bd64783e09127d37.png)
数据结构c语言版第三版习题解答数据结构是计算机科学中非常重要的一门学科,它研究如何在计算机中存储和组织数据,以便有效地进行检索和操作。
数据结构的知识对于编写高效的程序和解决复杂的问题至关重要。
在学习和理解数据结构的过程中,解决习题是一种非常有效的方法。
本文将为读者提供《数据结构C语言版(第三版)》习题的解答。
1. 第一章:绪论第一章主要介绍了数据结构的基本概念和内容,包括算法和数据结构的概念、抽象数据类型(ADT)以及算法的评价等。
习题解答中,我们可以通过分析和讨论的方式对这些概念进行加深理解。
2. 第二章:算法分析第二章主要介绍了算法的基本概念和分析方法,包括时间复杂度和空间复杂度的计算方法。
习题解答中,我们可以通过具体的算法实例来计算其时间和空间复杂度,加深对算法分析的理解。
3. 第三章:线性表第三章主要介绍了线性表的概念和实现,包括顺序表和链表两种实现方式。
习题解答中,我们可以通过编写代码实现线性表的基本操作,并分析其时间和空间复杂度。
4. 第四章:栈和队列第四章主要介绍了栈和队列的概念和实现,包括顺序栈、链栈、顺序队列和链队列四种实现方式。
习题解答中,我们可以通过编写代码实现栈和队列的基本操作,并分析其时间和空间复杂度。
5. 第五章:串第五章主要介绍了串的概念和实现,包括顺序串和链串两种实现方式。
习题解答中,我们可以通过编写代码实现串的基本操作,并分析其时间和空间复杂度。
6. 第六章:树第六章主要介绍了树的概念和实现,包括二叉树、哈夫曼树和赫夫曼编码等内容。
习题解答中,我们可以通过编写代码实现树的基本操作,并分析其时间和空间复杂度。
7. 第七章:图第七章主要介绍了图的基本概念和实现,包括图的表示方法和图的遍历算法等。
习题解答中,我们可以通过编写代码实现图的基本操作,并分析其时间和空间复杂度。
8. 第八章:查找第八章主要介绍了查找算法的基本概念和实现,包括顺序查找、二分查找、哈希查找等内容。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
pop(p,a+r);
r++;
}
return r;
}
递归算法:
void convert(int no)
{
if(no/2>0)
{
Convert(no/2);
Printf(“%d”,no%2);
}
else
printf(“%d”,no);
}
参考程序:
void view(SeStack s)
{
SeStack *p; //假设栈元素为字符型
不同点:栈只在一端(栈顶)进行插入,删除操作;队列在一端(top)删除,一端(rear)插入。
答:可能序列有14种:ABCD;ACBD;ACDB;ABDC;ADCB;BACD;BADC;BCAD;BCDA;BDCA;CBAD; CBDA; CDBA; DCBA。
答:不能得到4,3,5,6,1,2,最先出栈的是4,则按321的方式出,不可能得到1在2前的序列,可以得到1,3,5,4,2,6,按如下方式进行push(1),pop(),push(2),push(3),pop(), push(4), push(5), pop(), pop(), pop(), push(6), pop()。
char c;
p=&s;
while(!empty_stack(p))
{
c=pop(p);
printf(“%c”,c);
}
printf(”\n”);
}
答:char
参考程序:
void out(linkqueue q)
{
int e;
while != )
{
dequeue(q,e);
print(e); //打印
答:stack
非递归:
int vonvert (int no,int a[]) //将十进制数转换为2进制存放在a[],并返回位数{
int r;
SeStack s,*p;
P=&s;
Init_stack(p);
while(no)
{
pr=0;
while(!empty_stack(p))
(1)FILO, FIFO
(2)-1, 3 4 X * + 2 Y * 3 / -
(3), []=x
(4)p>llink->rlink=p->rlink, p->rlink->llink=p->rlink
(5)(R-F+M)%M
(6)top1+1==top2
(7)F==R
(8)front==rear
习题
.选择题
(1). D (2).C (3). D (4). C (5). B (6). C (7). C (8). C (9). B (10).B(11). D (12). B (13). D (14). C (15). C (16). C (17). D (18). C (19). C (20). B.填空题
}
}
嘿嘿,感谢吧,标准答案哦
(9)front==(rear+1)%n
(10)N-1
答:一般线性表使用数组来表示的
线性表一般有插入、删除、读取等对于任意元素的操作
而栈只是一种特殊的线性表
栈只能在线性表的一端插入(称为入栈,push)或者读取栈顶元素或者称为“弹出、出栈”(pop)。
答:相同点:栈和队列都是特殊的线性表,只在端点处进行插入,删除操作。