北京大学数据结构基础-chap6

合集下载

Chap6-设计方法

Chap6-设计方法
对系统设计的影响——协同设计 增加灵活性 增加了风险
嵌入式系统设计者要求
懂得系统的整个构架 详细了解硬件的细节 软件设计满足:
实时要求 低功耗 代码量小
详细了解领域知识
嵌入式系统软硬件协同设计
软硬件协同设计
软硬件协同设计
硬件设计工具(EDA工具)
系统级设计工具
嵌入式系统快速原型设计过程
REUSE DESIGN LIBRARIES AND DATABASE
Primarily software
VIRTUAL PROTOTYPE
Primarily hardware
SYSTEM DEF.
FUNCTION DESIGN
HW & SW CODESIGN
HW & SW PART.
标准 IC
CPU, DSP, …… RAM, ROM, 接口控制器,…… ASIC,……
标准 IP
CPU核,……
标准模块
GPRS模块,GSM模块,蓝牙模块, …… 显示模块,……
标准计算平台
基于PC104的嵌入式计算机 基于Compact PCI的嵌入式计算机 SOC,……
最令人头疼的问题) 嵌入式软件的可靠性问题: 正确性验证技术、测试
技术、调试技术等(可靠性问题是嵌入式软件开 发的基本问题) 可重构计算(Reconfigurable Computing)技 术 可构件化的嵌入式实时操作系统及其开发环境
嵌入式系统的设计
问题:
功能、性 能要求 价格、开 发周期等 约束
Cadence的SPW System View
模拟电路系统仿真工具
Pspice EWB

2022年北京大学计算机科学与技术专业《数据结构与算法》科目期末试卷A(有答案)

2022年北京大学计算机科学与技术专业《数据结构与算法》科目期末试卷A(有答案)

2022年北京大学计算机科学与技术专业《数据结构与算法》科目期末试卷A(有答案)一、选择题1、从未排序序列中依次取出一个元素与已排序序列中的元素依次进行比较,然后将其放在已排序序列的合适位置,该排序方法称为()排序法。

A.插入B.选择C.希尔D.二路归并2、下列排序算法中,占用辅助空间最多的是()。

A.归并排序B.快速排序C.希尔排序D.堆排序3、计算机算法指的是解决问题的步骤序列,它必须具备()三个特性。

A.可执行性、可移植性、可扩充性B.可执行性、确定性、有穷性C.确定性、有穷性、稳定性D.易读性、稳定性、安全性4、用不带头结点的单链表存储队列,其队头指针指向队头结点,队尾指针指向队尾结点,则在进行出队操作时()。

A.仅修改队头指针B.仅修改队尾指针C.队头、队尾指针都可能要修改D.队头、队尾指针都要修改5、下列关于AOE网的叙述中,不正确的是()。

A.关键活动不按期完成就会影响整个工程的完成时间B.任何一个关键活动提前完成,那么整个工程将会提前完成C.所有的关键活动提前完成,那么整个工程将会提前完成D.某些关键活动若提前完成,那么整个工程将会提前完成6、下列叙述中,不符合m阶B树定义要求的是()。

A.根结点最多有m棵子树 B.所有叶结点都在同一层上C.各结点内关键字均升序或降序排列 D.叶结点之间通过指针链接7、排序过程中,对尚未确定最终位置的所有元素进行一遍处理称为一趟排序。

下列排序方法中,每一趟排序结束时都至少能够确定一个元素最终位置的方法是()。

Ⅰ.简单选择排序Ⅱ.希尔排序Ⅲ.快速排序Ⅳ.堆排Ⅴ.二路归并排序A.仅Ⅰ、Ⅲ、Ⅳ B.仅Ⅰ、Ⅱ、Ⅲ C.仅Ⅱ、Ⅲ、Ⅳ D.仅Ⅲ、Ⅳ、Ⅴ8、一个具有1025个结点的二叉树的高h为()。

A.11B.10C.11至1025之间D.10至1024之间9、有n(n>0)个分支结点的满二叉树的深度是()。

A.n2-1B.log2(n+1)+1C.log2(n+1)D.log2(n-l)10、在平衡二叉树中插入一个结点后造成了不平衡,设最低的不平衡结点为A,并已知A 的左孩子的平衡因子为0,右孩子的平衡因子为l,则应作()型调整以使其平衡A.LLB.LRC.RLD.RR二、填空题11、N个顶点的连通图用邻接矩阵表示时,该矩阵至少有______个非零元素。

北大数据结构课讲义10

北大数据结构课讲义10
9.2.1 顺序查找
5
9.2.1 顺序查找
顺序表查找(Sequential Search)又称线性查找。
是一种最简单和最基本的查找方法。它从顺序表的一端 开始,依次将每个元素的关键字同给定值K进行比较,若某 个元素的关键字等于给定值K,则表明查找成功,返回该元 素所在的下标,若直到所有元素都比较完毕,仍找不到关 键字为K的元素,则表明查找失败,返回特定的值。
找成功时的平均查找长度(Average Search Length)。
n
ASL pici i 1
若查找每个数据元素的概率相等,则
1n
ASL ci
n i1
4
9.2 顺序表查找
顺序表 (Sequential List) 是指线性表的顺序存储结构。 ElemType A[MaxSize]; KeyType key;
28
9.4.4 散列表的运算
散列表的类型定义与所使用的冲突处理方法有关。 开放定址法
typedef ElemType hashlist1[HashMaxSize]; 链接法
typedef LNode* hashlist2[HashMaxSize];
(1)初始化散列表 (2)清空散列表 (3)向散列表中插入一元素 (4)从散列表中查找一元素 (5)从散列表中删除一元素
9
int Binsch (ElemType A[], int low, int high, KeyType K) {
int low=0, high=n-1; while (low<=high) {
int mid = (low+high)/2; if (K= =A[mid].key) return mid;
插入 K=31

北大数据结构课件,内部资料,精品

北大数据结构课件,内部资料,精品

数据结构任课教员:张铭、赵海燕、冯梅萍、王腾蛟/mzhang/DS/北京大学信息科学与技术学院网络与信息系统研究所©版权所有,转载或翻印必究教学目的掌握常用的基本数据结构的ADT 及其应用学会合理地组织数据, 有效地表示数据, 有效地处理数据基本掌握算法的设计分析技术 提高程序设计的质量教学要求平时(考勤+作业)20% 上机(+报告)30%期中20%期末30%诚信端正学习态度、调动学习兴趣提倡讨论,但严禁抄袭可以讨论思路,请同学看算法的逻辑问题和效率问题。

但要亲自动手实现。

发现抄袭,则抄袭者和被抄袭者本次作业或上机题计双倍倒扣分,即得-20分。

以后的作业题会得到重点检查。

严重的期评将给予不及格处理数据结构教学计划和要求按时提交作业,严禁抄袭所有书面作业和上机作业都必须在指定的期限内完成并提交一般周三交书面作业。

除非不可抗拒的客观原因,请严格按提交时间完成书面作业和上机作业。

例如,一个满分为10分的作业题,记分标准为:(1)准时提交,满分可达10分(个别加分);(2)延迟3天之内提交,满分可达7分;(3)延迟7天之内提交,满分可达3分;(4)7天之后提交或不交,得分-5分。

(5)抄袭得–20分。

书面作业提交要求1) 写学号、名字2) 每次作业,都在作业本或电子稿的word文档中写上“我保证没有抄袭他人作业”的诚实保证。

否则,计零分或根据抄袭情况倒扣分。

3) 写算法分析、注释4) 算法中直接使用的函数、过程先写ADT,并说明函数功能、入口参数、出口参数5) 注意算法格式(层次嵌套、不同功能块之间留空)上机题提交要求上机作业提交时打一个zip包,学号+姓名+作业次数,如”00308096张宁1.zip”包中含有:1. readme.txt文件,把你的程序运行环境、编译运行步骤、程序功能等等简单说明一下。

2. 附加了诚实代码保证和足够注释的源程序以及相关的项目和资源文件。

例如,VC++中的.dsw, .dsp文件,rc目录中的图像资源文件;Jbuilder中的.jpr或.jpx文件,特殊的Java包等等。

数据结构(C语言版CHAP6(2)

数据结构(C语言版CHAP6(2)

42
23 11 5 19 8 3 29
58
29 14 7 15 8
w,p,lch,rch 是 weight,parent,l child,rchild 的缩写
哈夫曼树
哈夫曼树对应的静态三叉链表
结束
第 13 页
6.7 哈夫曼树及应用
哈夫曼算法 void HuffmanTree(HuffmanTree &HT, int * w, int n){ //w 存放n 个字符的权值(均>0),构造赫夫曼树HT if (n<=1) return; m=2* n-1; HT=(HuffmanTree)malloc(m+1) * sizeof(HTNode); //为哈夫曼树分配存储 //空间 for (p=HT, i=1; i<=n; ++i, ++p, ++w) * p={ * w, 0, 0, 0}; //用给定的n个权// 值 ,构造n棵只有一个根结点的二叉树 for (; i<m; ++i; ++p) { //按构造哈夫曼树的步骤2、3、4,建哈夫曼树 //在HT[1..i-1] 选择parent为0且weight最小的两个结点,其序号分别为s1和 s2。 Select(HT, i-1, s1, s2); HT[s1]. parent =i; HT[s2].parent=i; //HT[i]存放新子树的根结点, HT[i].lchild=s1; HT[i].rchild=s2; HT[i].weight=HT[s1].weight+HT[s2].weight;
分数 0-59 60-69 70-79 80-89 90-100 0.15 0.40 0.30 0.10 比例数 0.05

数据结构ppt课件完整版

数据结构ppt课件完整版

针对有序数据集合,每次通过中间元素将 待查找区间缩小为之前的一半,直到找到 元素或区间为空。
哈希查找
树形查找
通过哈希函数将数据映射到哈希表中,实 现快速查找。
如二叉搜索树、平衡树等,通过树形结构实 现高效查找。
排序算法分类及实现原理
插入排序
将待排序元素逐个插入到已排序序列中,直到所有元素均插入完毕。
由n(n>=0)个具有相同类型 的数据元素(结点)a1,a2,
...,an组成的有序序列。
同一性
每个元素必须是同一类型的数 据。
有序性
元素之间具有一对一的前驱和 后继关系,即除首尾元素外, 每个元素都有一个前驱和一个 后继。
可变性
线性表的长度可变,即可以插 入或删除元素。
顺序存储结构与链式存储结构比较
定义
用一段连续的存储单元依次存储线性 表的数据元素。
优点
可以随机存取表中任一元素,且存取 时间复杂度为O(1)。
顺序存储结构与链式存储结构比较
• 缺点:插入和删除操作需要移动大量元素,时间 复杂度高;需要预先分配存储空间,容易造成空 间浪费。
顺序存储结构与链式存储结构比较
定义
用一组任意的存储单元存储线性 表的数据元素(这组存储单元可 以是连续的,也可以是不连续的
查找操作
查找指定元素的位置。
遍历操作
访问线性表中的每个元素。
销毁操作
释放线性表占用的存储空间。
03
栈和队列
栈定义及特点
栈(Stack)是一种特殊的线性数据结构,其数据的存 取遵循后进先出(LIFO, Last In First Out)的原则。 栈的特点
具有记忆功能,能保存数据的状态。
栈的基本操作包括入栈(push)、出栈(pop)、查 看栈顶元素(top)等。 只能在栈顶进行数据的插入和删除操作。

数据结构(C语言版CHAP6(1)

数据结构(C语言版CHAP6(1)

G
说明 1)二叉树中每个结点最多有两颗子树;二叉树每个结点度小于等于2; 2)左、右子树不能颠例——有序树; 3)二叉树是递归结构,在二叉树的定义中又用到了二叉树的概念;
结束
第 16 页
6.2 二 叉 树
A B D G (a) E C F F C
A B D G (b) E
(a)、(b)是不同的二叉树, (a)的左子树有四个结点, (b)的左子树有两个结点,
结束
第 17 页
6.2 二 叉 树
2. 二叉树的基本形态
φ
结束
第 18 页
6.2 二 叉 树
3.应用举例 例1 可以用二叉树表示表达式
+ a * /
e
f
b
c
d
a+b*(c-d)-e/f
结束
ห้องสมุดไป่ตู้
第 19 页
6.2 二 叉 树
例2 双人比赛的所有可能的结局
开始

开局连赢两局 或五局三胜


甲 甲 乙

对于线性结构由于每个结点只有一个直接后继,遍历是很容易的事 二叉树是非线性结构,每个结点可能有两个后继,如 何访问二叉树的每个结点,而且每个结点仅被访问一次?
结束
第 32 页
6.3
一 二叉树的遍历方法
二叉树的遍历
二叉树由根、左子树、右子树三部分组成 二叉树的遍历可以分解为:访问根,遍历左子树和遍历右子树 令:L:遍历左子树 D:访问根结点 R:遍历右子树 有六种遍历方法: DLR,LDR,LRD,
3)树的结点,可以有零个或多个后继; 4)除根外的其他结点,都存在唯一条从根到该结点的路径; 5)树是一种分枝结构

北大数据结构课件,内部资料,精品

北大数据结构课件,内部资料,精品

第三章字符串任课教员:张铭、赵海燕、冯梅萍、王腾蛟/mzhang/DS/北京大学信息科学与技术学院©版权所有,转载或翻印必究主要内容3.1 字符串抽象数据类型3.2 字符串的存储结构和类定义 3.3 字符串运算的算法实现3.4 字符串的模式匹配3.1字符串抽象数据类型3.1.1 基本概念3.1.2 String抽象数据类型3.1.1 基本概念字符串,由0个或多个字符的顺序排列所组成的复合数据结构,简称“串”。

串的长度:一个字符串所包含的字符个数。

空串:长度为零的串,它不包含任何字符内容。

3.1.1.1字符串常数和变量字符串常数例如:"\n"字符串变量3.1.1.2 字符字符(char) :组成字符串的基本单位。

在C和C++中单字节(8 bits)采用ASCII码对128个符号(字符集charset)进行编码3.1.1.3 字符的编码顺序为了字符串间比较和运算的便利,字符编码表一般遵循约定俗成的“偏序编码规则”。

字符偏序:根据字符的自然含义,某些字符间两两可以比较次序。

其实大多数情况下就是字典序中文字符串有些特例,例如“笔划”序3.1.1.4 C++标准string标准字符串:将C++的<string.h>函数库作为字符串数据类型的方案。

例如:char S[M];串的结束标记:'\0''\0'是ASCII码中8位BIT全0码,又称为NULL符。

3.1.1.4 C++标准string(续)1. 串长函数int strlen(char*s);2. 串复制char *strcpy(char*s1, char*s2);3.串拼接char *strcat(char*s1, char *s2);4.串比较int strcmp(char*s1, char *s2);3.1.1.4 C++标准string(续)5.输入和输出函数6.定位函数char *strchr(char*s, char c); 7.右定位函数char *strrchr(char*s, char c);3.1.1.4 C++标准string(续)3.1.2 String抽象数据类型字符串类(class String): 不采用char S[M]的形式而采用一种动态变长的存储结构。

数据结构c语言版课后习题答案

数据结构c语言版课后习题答案

数据结构c语言版课后习题答案数据结构是计算机科学中的一个重要概念,它涉及到组织、管理和存储数据的方式,以便可以有效地访问和修改数据。

C语言是一种广泛使用的编程语言,它提供了丰富的数据结构实现方式。

对于学习数据结构的C语言版课程,课后习题是巩固理论知识和提高实践能力的重要手段。

数据结构C语言版课后习题答案1. 单链表的实现在C语言中,单链表是一种常见的线性数据结构。

它由一系列节点组成,每个节点包含数据部分和指向下一个节点的指针。

实现单链表的基本操作通常包括创建链表、插入节点、删除节点、遍历链表等。

答案:- 创建链表:定义一个链表结构体,然后使用动态内存分配为每个节点分配内存。

- 插入节点:根据插入位置,调整前后节点的指针,并将新节点插入到链表中。

- 删除节点:找到要删除的节点,调整其前后节点的指针,然后释放该节点的内存。

- 遍历链表:从头节点开始,使用指针遍历链表,直到达到链表尾部。

2. 二叉树的遍历二叉树是一种特殊的树形数据结构,其中每个节点最多有两个子节点。

二叉树的遍历是数据结构中的一个重要概念,常见的遍历方式有前序遍历、中序遍历、后序遍历和层序遍历。

答案:- 前序遍历:先访问根节点,然后递归遍历左子树,最后递归遍历右子树。

- 中序遍历:先递归遍历左子树,然后访问根节点,最后递归遍历右子树。

- 后序遍历:先递归遍历左子树,然后递归遍历右子树,最后访问根节点。

- 层序遍历:使用队列,按照从上到下,从左到右的顺序访问每个节点。

3. 哈希表的实现哈希表是一种通过哈希函数将键映射到表中一个位置来访问记录的数据结构。

它提供了快速的数据访问能力,但需要处理哈希冲突。

答案:- 哈希函数:设计一个哈希函数,将键映射到哈希表的索引。

- 哈希冲突:使用链地址法、开放地址法或双重哈希法等解决冲突。

- 插入操作:计算键的哈希值,将其插入到对应的哈希桶中。

- 删除操作:找到键对应的哈希桶,删除相应的键值对。

4. 图的表示和遍历图是一种复杂的非线性数据结构,由顶点(节点)和边组成。

北外《数据结构》知识要点01

北外《数据结构》知识要点01

北外《数据结构》知识要点01数据结构是计算机科学中的一门核心课程,它研究的是数据的组织、存储和操作。

作为北外学生,学习《数据结构》课程的知识要点对于我们的学习和应用能力的提升至关重要。

本文将介绍北外《数据结构》课程的知识要点01,并通过实际案例和图示进行详细解析,帮助大家全面掌握这些重要的概念和方法。

1. 基本概念数据结构是指数据对象和数据对象之间的关系,它主要包括以下几个方面的内容:- 数据元素:数据结构中的基本单位,可以是一个字符、一个数字或者一个记录。

- 数据项:数据元素中的最小单位。

- 数据结构:数据元素之间的相互关系。

2. 线性表线性表是最基本且常见的数据结构之一,它由一个或多个数据元素组成,数据元素之间存在一对一的关系。

线性表的常用表示方法有顺序存储和链式存储,它包括以下几种类型:- 数组:顺序存储结构,适用于元素个数固定且频繁进行查找和更新的情况。

- 链表:链式存储结构,适用于元素个数不固定且频繁进行插入和删除的情况。

- 栈:只能在表的一端进行插入和删除操作的线性表,遵循先进后出的原则。

- 队列:只能在表的一端进行插入和在另一端进行删除操作的线性表,遵循先进先出的原则。

3. 树结构树是一种非线性的数据结构,它由多个节点组成,其中一个节点称为根节点,每个节点可以有零个或多个子节点。

常见的树结构包括:- 二叉树:每个节点最多有两个子节点的树结构。

二叉树的遍历有前序遍历、中序遍历和后序遍历三种方式。

- 平衡二叉树:左右子树的高度差不超过1的二叉树,可以提高查找效率。

- B树:多路搜索树,适用于磁盘存储等需要大量读写操作的场景。

- 堆:可以快速找到最大值或最小值的完全二叉树。

4. 图结构图是由顶点集合和边集合组成的一种数据结构,它包括有向图和无向图两种类型。

图结构的常见应用包括:- 最短路径算法:例如Dijkstra算法和Floyd-Warshall算法,可以求解两个节点之间最短路径的问题。

北京大学2016年秋季学期《数据结构》课程作业【答案】

北京大学2016年秋季学期《数据结构》课程作业【答案】

树形结构中元素之间存在一对多_关系。(第一章)
2
n
3.一个算法的最基本的原操作执行次数为(3n +2nlog2 +4n-7)/(7n),则该算法的时间
复杂度为_ O(n)______。(第一章)
4.链式存储结构用一组地址任意的存储单元依次存放数据元素,数据元素之间的逻辑
关系通过__指针________间接地反映。(第二章)
答 顺序表的优点势可以随机访问数据元素;缺点是大小固定,不利于增减结点(增 减操作需要移动元素)。链表的优点是采用指针方式增减结点,非常方便(只需要改 变指针指向,不移动结点)。其缺点是不能进行随机访问,只能顺序访问;另外,每
第5页 共 10 页
个结点上增加指针域,造成额外存储空间增大。
2. (第二章)在一个单链表 HL 中删除指针 p 所指结点,应执行如下关键操作: if(________) HL = HL->next; else { q = HL; while(________) q = q->next; _____________; } delete p;
件是_____B_____。(第五章)
a 空或只有一个结点
b 高度等于其结点数
c 任一结点无右孩子
d 任一结点无左孩子
21. 树的基本遍历策略分为先根遍历和后根遍历;二叉树的基本遍历策略可分为先序
遍历、中序遍历和后序遍历。结论___A_______是正确的。(第五章)
a.树的先根遍历序列与其对应的二叉树的先序遍历序列相同
08,09},R={r},r={<01,02>,<01,03>,<01,04>,<02,05>,<02,06>,<03,

2016数据结构基础(C语言版)习题及答案(英文版)

2016数据结构基础(C语言版)习题及答案(英文版)

数据结构基础(C语言版)习题及答案(英文版)目录CHAPTER 1 (2)CHAPTER 2 (24)CHAPTER 3 (44)CHAPTER 4 (63)CHAPTER 5 (79)CHAPTER 6 (96)CHAPTER 7 (125)CHAPTER 8 (139)CHAPTER 9 (140)CHAPTER 10 (142)CHAPTER 11 (147)CHAPTER 12 (170)CHAPTER 1Chapter 1, Pages 16-17Problem 1.a This statement is a poorly phrased version of Fermat's last theorem. We know that we can find n > 2 for which ‚the equation holds. Fermat scribbled a note on a text margin indicating that he had found the solution for n = 2. Unfortunately, the proof died with him. Be cause the statement is phrased as a question‚ rather than a clearly defined algorithm, it lacks definiteness.Problem 1.b This statement violates not only the rules of mathematics, but the criterion of effectiveness. We can compute only those things that are feasible, and division by zero is mathematically undefinedPage 17, Exercise 3#include <stdio.h>#include <math.h>#include <string.h>#define TRUE 1#define FALSE 0#define MAX_STRING 100void truth_table(int);int main(){int n;printf("n:(>=0): ");scanf("%d", &n);while (n <= 0){ /*error loop */printf("n:(>=0): ");scanf("%d", &n);}truth_table(n);}void truth_table(int n){/* generate a truth_table by transforming # of permutations into binary */int i,j, div, rem;char string[MAX_STRING];for (i=0; i < pow(2,n); i++){/*number of permutations or rows in the table */ strcpy(string ,"\0");div = i;for (j = n; j > 0; j--){/*number of bits needed for each row*/rem = div%2;div = div/2;if (!rem) strcat(string,"FALSE ");else strcat(string, "TRUE ");}printf("%s\n", string);}}Page 17, Exercise 4#include <stdio.h>int min(int, int);#define TRUE 1#define FALSE 0int main(){int x,y,z;printf("x: "); scanf("%d", &x);printf("y: "); scanf ("%d", &y);printf("z: "); scanf("%d", &z);if (min(x,y) && min(y,z)) {/*x is smallest */printf("%d ", x);if (min(y,z)) printf ("%d %d\n", y,z);else printf("%d%d\n", z, y);}else if (min(y,x) && min(y,z)){ /*y is the smallest */ printf("%d ", y);if (min(x,z)) printf ("%d %d\n", x,z);else printf("%d%d\n", z,x);}elseprintf("%d %d %d\n", z, y, x);}int min(int a, int b) {if (a < b) return TRUE;return FALSE;}Page 17, Exercise 7#include <stdio.h>double iterFact(int);double recurFact(int);int main(){int n;printf("n:(>=0): ");scanf("%d", &n);while (n < 0){ /*error loop */printf("n:(>=0): ");scanf("%d", &n);}printf("%d factorial is %f.\n", n, iterFact(n)); printf("%d factorial is %f.\n", n, recurFact(n)); }double recurFact(int n){ /*recursive version */if ((n==0) || (n==1)) return 1.0;return n*recurFact(n-1);}double iterFact(int n){/* find the factorial, return as a doubleto keep it from overflowing */int i;double answer;if ((n == 0) || (n == 1)) return 1.0;answer = 1.0;for (i = n; i > 1; i--)answer *= i;return answer;}Page 17, Exercise 8#include <stdio.h>int iterFib(int);int recurFib(int);int main(){int n;printf("n:(>=0): ");scanf("%d", &n);while (n < 0){ /*error loop */printf("n:(>=0): ");scanf("%d", &n);}printf("%d Fibonacci is %d.\n", n, iterFib(n)); printf("%d Fibonacci is %d.\n", n, recurFib(n)); }int recurFib(int n){ /*recursive version */if ((n==0) || (n==1)) return 1;return recurFib(n-1) + recurFib(n-2);}int iterFib(int n){/* find the factorial, return as a doubleto keep it from overflowing */int i;int fib, fib1, fib2;if ((n == 0) || (n == 1)) return 1;fib1 = fib2 = 1;for (i = 2; i <=n; i++) {fib = fib1+fib2;fib2 = fib1;fib1 = fib;}return fib;}Page 17, Exercise 9#include <stdio.h>double recurBinom(int, int);double iterBinom(int, int);double recurFact(int n);int main(){int n,m;printf("n:(>=0): ");scanf("%d", &n);while (n < 0){ /*error loop */printf("n:(>=0): ");scanf("%d", &n);}printf("m:(>=0): ");scanf("%d", &m);while (m < 0){ /*error loop */printf("m:(>=0): ");scanf("%d", &m);}printf("n: %d m: %d Recursive Binomial coefficient is %f.\n", n, m, recurBinom(n,m)); printf("n: %d m: %d Iterative Binomial coefficient is %f.\n", n, m, iterBinom(n,m));}double iterBinom(int n, int m){/* defined as n!/(m! - (n-m)!)*/int i;double nFact, mFact, nMinusMFact;if (n == m) return 1;if ((n==0) || (n == 1)) nFact = 1;else {nFact = 1;for (i = n; i > 1; i--)nFact *= i;}if ((m==0) || (m == 1)) mFact = 1;else {mFact = 1;for (i = m; i > 1; i--)mFact *= i;}if ( ((n-m) == 0) || ((n-m) == 1)) nMinusMFact = 1;else {nMinusMFact = 1;for (i = n-m; i > 1; i--)nMinusMFact *= i;}return nFact/(mFact*nMinusMFact);}double recurFact(int n){ /*recursive version */if ((n==0) || (n==1)) return 1.0;return n*recurFact(n-1);}double recurBinom(int n, int m){ /*recursive version */return recurFact(n)/(recurFact(m)*recurFact(n-m));}Page 17, Exercise 11#include#define Tower1 1#define Tower2 2#define Tower3 3void towers_of_hanoi(int, int, int, int);int main(){int n_disks;printf("Number of disks: ");scanf("%d", &n_disks);printf("Disk, source, and destination towers listed below\n");printf("%12s%10s%15s\n", "Disk No", "Source","Destination");towers_of_hanoi(n_disks,Tower1,Tower3,Tower2);}void towers_of_hanoi(int n_disks, int source, int dest, int spare){if (n_disks == 1 )printf("%10d%10d%10d\n", n_disks, source, dest);else {/*move a disk from source to spare*/towers_of_hanoi(n_disks-1,source,spare,dest);printf("%10d%10d%10d\n", n_disks, source, dest);/*move a disk from spare to destination tower*/towers_of_hanoi(n_disks-1,spare,dest,source);}}Page 21, Exercise 1ADT NaturalNumber is objects:an ordered subrange of the integers starting at zero and ending at the maximum integer (INT_MAX) on the computer functions: forall x, y ∈NaturalNumber; TRUE, FALSE ∈Booleanand where +, −, <, and == are the usual integer operationsNaturalNumber Zero( ) ::= 0Boolean IsZero(x) ::= if (x) return FALSEreturn TRUEBoolean Equal(x, y) ::= if (x == y) return TRUEreturn FALSENaturalNumber Successor(x) ::= if (x == INT_MAX) return xreturn x + 1NaturalNumber Add(x, y) ::= if ((x + y) < INT_MAX) return x + y if ((x + y) == INT_MAX) return x + yreturn INT_MAXNaturalNumber Subtract(x, y) ::= if (x < y) return 0return x − yNaturalNumber Predecessor(x) ::= if (x < 0) return ERRORif (x == 0) return 0return x - 1Boolean IsGreater(x, y) := if ((x-y)) < 0) return ERRORif ((x-y)) == 0) return FALSEreturn TRUENaturalNumber mult(x, y) ::= if (x < 0) return ERRORif (y < 0) return ERRORif (y == 1) return xreturn x + mult(x, y-1)NaturalNumber div(x, y) ::= if (x < 0) return ERRORif (y < 0) return ERRORif (y == 0) return ERRORif (y == 1) return 1return x - div(x, y-1)end NaturalNumberPage 21, Exercise 3ADT Set is objects:a subrange of the integers starting at (INT_MIN) and ending at themaximum integer (INT_MAX) on the computer functions: forall x, y ∈Set; TRUE, FALSE ∈Boolean and the Boolean operations defined in Problem 4 are available (not, and, or,...)and where ==, Ø, +, head(s), tail(s) are the usual set operations,where == return TRUE if tw set elements are the same, and TRUE otherwise.Ø is the empty set.+ adds and element to a set.head(s) extracts the first member in the set.tail(s) extracts a list of all other elements in the set. An empty set contains no tail. A set with only one element has the emtpy set has it tail.Set Create(s) ::= ØBoolean IsEmpty(s) ::= if (s ==Ø ) return TRUEreturn FALSEBoolean IsIn(x, s) ::= if (IsEmpty(s)) return FALSEif (x == head(s) return TRUEreturn IsIn(x, Tail(s))Set Insert(x,s) ::= if (IsEmpty(s)) return x + sif (IsIn(a,s)) return sreturn x + sSet Remove(x, s) ::= if (x == head(s)) return tail(s)return Remove(x, tail(s))Set Union(x, s1, s2) ::= if IsEmpty(s1) return s2if IsIn(head(s1), s2)) return Union(x, tail(s1), s2)return head(s1) + Union(x, tail(s1), s2)set Intersection(x, s1,s2) ::= if IsEmpty(s1) return Øif IsIn(head(s1), s2)) return head(s1) + Intersection(x, tail(s1), s2)return Intersection(x, tail(s1), s2)Boolean Difference(s1,s2) ::= if IsEmpty(s1) return Øif IsIn(head(s1), s2)) return Difference(x, tail(s1), s2)return head(s1) + Difference(x, tail(s1), s2)end SetPage 21, Exercise 3ADT Bag is objects:a subrange of the integers starting at (INT_MIN) and ending at themaximum integer (INT_MAX) on the computer functions: forall x, y ∈Bag; TRUE, FALSE ∈Boolean and the Boolean operations defined in Problem 4 are available (not, and, or,...)and where ==, Ø, +, head(s), tail(s) are the usual Bag operations,where == return TRUE if tw set elements are the same, and TRUE otherwise.Ø is the empty Bag.+ adds and element to a Bag.head(s) extracts the first member in the Bag.tail(s) extracts a list of all other elements in the Bag. An empty bag contains no tail. A bag with only one element has the emtpy bag has it tail.Bag Create(b) ::= ØBoolean IsEmpty(b) ::= if (b ==Ø ) return TRUEreturn FALSEBoolean IsIn(x, b) ::= if (IsEmpty(b)) return FALSEif (x == head(b) return TRUEreturn IsIn(x, Tail(b))Bag Insert(x,s) ::= if (IsEmpty(b)) return breturn x + bBag Remove(x, s) ::= if (IsEmpty(b)) return bif (x == head(b)) return tail(b)return Remove(x, tail(b))end bagPage 21, Exercise 4ADT Boolean is objects:TRUE, FALSE ∈Boolean and the Boolean== the usual boolean operation. where == return TRUE if tw set elements are the same, and TRUE otherwise.Boolean not(x) ::= if (x) return TRUE return FALSEBoolean and(x,y) ::= if(not(x)) return FALSEif (not(y)) return FALSEreturn TRUEBoolean or(x, s)::= if(x) return TRUEif (y) return TRUEreturn FALSEBoolean xor(x, s)::= if(and(not(x), not(y))) return FALSEif (and(x, y)) return FALSEreturn TRUEBoolean implies(x, s)::= if (and(x, y)) return TRUEif (and(not(x),not(y))) return TRUEreturn FALSEBoolean equivalent(x, s)::= if(and(not(x), not(y))) return TRUEif (and(x, y)) return TRUEreturn FALSEend SetPage 25, Exercise 1Iterative Factorial Function, SiterFact(I) = 0 Recursive Function: recurFact()Type Name Number of Bytes Parameter(int) n 4 Local Variables(int)(double) ianswer46Return Type (double) 6TOTAL 20 for each recursive callif (n == MAX_SIZE) SrecurFact(I) = (20•MAX_SIZE)Page 21, Exercise 3ADT Set is objects:a subrange of the integers starting at (INT_MIN) and ending at themaximum integer (INT_MAX) on the computer functions: forall x, y ∈Set; TRUE, FALSE ∈Boolean and the Boolean operations defined in Problem 4 are available (not, and, or,...)and where ==, Ø, +, head(s), tail(s) are the usual set operations,where == return TRUE if tw set elements are the same, and TRUE otherwise.Ø is the empty set.+ adds and element to a set.head(s) extracts the first member in the set.tail(s) extracts a list of all other elements in the set. An empty set contains no tail. A set with only one element has the emtpy set has it tail.Set Create(s)::= ØBoolean IsEmpty(s) ::= if (s ==Ø ) return TRUEreturn FALSEBoolean IsIn(x, s)::= if (IsEmpty(s)) return FALSEif (x == head(s) return TRUEreturn IsIn(x, Tail(s))Set Insert(x,s)::= if (IsEmpty(s)) return x + sif (IsIn(a,s)) return sreturn x + sSet Remove(x, s)::= if (x == head(s)) return tail(s)return Remove(x, tail(s))Set Union(x, s1, s2)::= if IsEmpty(s1) return s2if IsIn(head(s1), s2)) return Union(x, tail(s1), s2)return head(s1) + Union(x, tail(s1), s2)set Intersection(x, s1,s2)::= if IsEmpty(s1) returnØif IsIn(head(s1), s2)) return head(s1) + Intersection(x, tail(s1), s2)return Intersection(x, tail(s1), s2)Boolean Difference(s1,s2)::= if IsEmpty(s1) returnØif IsIn(head(s1), s2)) return Difference(x, tail(s1), s2)return head(s1) + Difference(x, tail(s1), s2)end SetPage 21, Exercise 3ADT Bag is objects:a subrange of the integers starting at (INT_MIN) and ending at themaximum integer (INT_MAX) on the computer functions: forall x, y ∈Bag; TRUE, FALSE ∈Boolean and the Boolean operations defined in Problem 4 are available (not, and, or,...)and where ==, Ø, +, head(s), tail(s) are the usual Bag operations,where == return TRUE if tw set elements are the same, and TRUE otherwise.Ø is the empty Bag.+ adds and element to a Bag.head(s) extracts the first member in the Bag.tail(s) extracts a list of all other elements in the Bag. An empty bag contains no tail. A bag with only one element has the emtpy bag has it tail.Bag Create(b)::= ØBoolean IsEmpty(b) ::= if (b ==Ø ) return TRUEreturn FALSEBoolean IsIn(x, b)::= if (IsEmpty(b)) return FALSEif (x == head(b) return TRUEreturn IsIn(x, Tail(b))Bag Insert(x,s)::= if (IsEmpty(b)) return breturn x + bBag Remove(x, s)::= if (IsEmpty(b)) return bif (x == head(b)) return tail(b)return Remove(x, tail(b))end bagPage 32, Exercise 4: PrintMatrixa. Countsvoid Printmatrix(int matrix[][MAX_SIZE], int rows, int cols) {int i,j;int count = 0;for (i = 0; i<rows; i++){count ++; /*for i loop */for (j = 0; j<cols; j++) {printf("%5d",matrix[i][j]);count++; /*for j loop */}count++; /* last time of j */printf("\n");}count++; /* last time of i */printf("Print Count: %d\n", count);}b. Simplified Countsvoid Printmatrix(int matrix[][MAX_SIZE], int rows, int cols) {int i,j;int count = 0;for (i = 0; i<rows; i++){count ++; /*for i loop */for (j = 0; j<cols; j++) {printf("%5d",matrix[i][j]);count++; /*for j loop */}count++; /* last time of j */printf("\n");}count++; /* last time of i */printf("Print Count: %d\n", count);}c. Final Count for 5x5 matrix : 36d. Step Count TableStep Count TableStatement s/e f Total Stepsvoid Printmatrix(int matrix[][MAX_SIZE], int rows, int cols){int i,j;for (i = 0; i<rows; i++){for (j = 0; j<cols; j++)printf("%5d",matrix[i][j]);printf("\n");}} 01101n+1n+1n+1n+1Total 2n+2Page 32, Exercise 5 Multiplicationa. Countsvoid mult(int a[][MAX_SIZE], int b[][MAX_SIZE], int c[][MAX_SIZE]){int i, j,k;int count = 0;for (i = 0; i < MAX_SIZE; i++) {count ++; /*for i loop */for (j = 0; j < MAX_SIZE; j++) {c[i][j] = 0; count++; /* for assignment */count++; /*for j loop */}count++; /* last time of j */for (k=0; k < MAX_SIZE; k++){c[i][j] += (a[i][k] * b[k][j]); count++; /* for assignment */count++; /* for k loop*/}count++; /*last time of k */}count++; /* last time of i */printf("Multiplication Count: %d\n", count);}b. Simplified Countsvoid mult(int a[][MAX_SIZE], int b[][MAX_SIZE], int c[][MAX_SIZE]) {int i, j,k;int count = 0;for (i = 0; i < MAX_SIZE; i++) {for (j = 0; j < MAX_SIZE; j++) {c[i][j] = 0;count+=2;}for (k=0; k < MAX_SIZE; k++){c[i][j] += (a[i][k] * b[k][j]);count+=2;}count+=3;}count++; /* last time of i */printf("Multiplication Count: %d\n", count);}c. Final Count for 5x5 matrix: 119d. Step Count TableStep Count TableStatement s/e f (MAX_S) = MAX_SIZE Total Stepsvoid mult(inta[][MAX_SIZE], int b[][MAX_SIZE],int c[][MAX_SIZE]) {int i, j,k; 0111111MAX_S+1MAX_S·MAX_S + MAX_SMAX_S+1MAX_S·MAX_S + MAX_Sfor (i = 0; i < MAX_SIZE; i++)for (j = 0; j < MAX_SIZE; j++) {c[i][j] = 0;for (k=0; k < MAX_SIZE; k++)c[i][j] +=(a[i][k] *b[k][j]);}} 0111MAX_S·MAX_SMAX_S·MAX_SMAX_S·MAX_S·MAX_S +MAX_S·MAX_S·MAX_sMAX_S·MAX_S·MAX_SMAX_S·MAX_SMAX_SMAX_S·MAX_SMAX_S·MAX_S·MAX_S +MAX_S·MAX_S·MAX_SMAX_S·MAX_S·MAX_STotal : 3·MAX_SIZE3+ 2·MAX_SIZE2+ 2·MAX_SIZE + 1 = O(MAX_SIZE)3Page 32, Exercise 4: Producta. Countsvoid prod(int a[][MAX_SIZE], int b[][MAX_SIZE], int c[][MAX_SIZE], int rowsA, int colsB, int colsA){int i, j,k;int count = 0;for (i = 0; i < rowsA; i++) {count ++; /*for i loop */for (j = 0; j < colsB; j++) {c[i][j] = 0; count++; /* for assignment */count++; /*for j loop */for (k = 0; k < colsA; k++) {count++; /* for k loop*/c[i][j] += (a[i][k] * b[k][j]); count++; /*for assignment */}count++; /*last time of k */}count++; /* last time of j */}count++; /* last time of i */printf("Prod Count: %d\n", count);}b. Simplified Countsvoid prod(int a[][MAX_SIZE], int b[][MAX_SIZE],int c[][MAX_SIZE], int rowsA, int colsB, int colsA){int i, j,k;int count = 0;for (i = 0; i < rowsA; i++) {for (j = 0; j < colsB; j++) {c[i][j] = 0; count++;count+=3;for (k = 0; k < colsA; k++) {count++;c[i][j] += (a[i][k] * b[k][j]);count+=2;}}count+=3;}count++; /* last time of i */printf("Prod Count: %d\n", count);}c. Final Count for 5x5 matrixvoid prod(int a[][MAX_SIZE], int b[][MAX_SIZE], int c[][MAX_SIZE], int rowsA, int colsB, int colsA){int i, j,k;for (i = 0; i < rowsA; i++)for (j = 0; j < colsB; j++) {c[i][j] = 0;for (k = 0; k < colsA; k++)c[i][j] += (a[i][k] * b[k][j]);}}d. Step Count Table : 336Step Count TableStatement s/e f (A = rows A, B =rowsB)Total Stepsvoid prod(int a[][MAX_SIZE], int b[][MAX_SIZE],int c[][MAX_SIZE], int rowsA, int colsB, int colsA){int i, j,k;for (i = 0; i < rowsA; i++)for (j = 0; j < colsB; j++) {c[i][j] = 0;for (k = 0; k < colsA; k++)c[i][j] += (a[i][k] * b[k][j]);}} 0111111111A+1A•B+ B+1A•BA•BA•B•A + A•B+ A+1A•B•A + A•B+ AA•BAA+1A•B+ B+1A•BA•B•A +A•B+ A+1A•B•A +A•B+ ATotal : 2A•B•A + 3A•B + 2A + B + 3Page 32, Exercise 4a. Countsvoid transpose(int a[][MAX_SIZE]){int i, j;int temp;int count = 0;for (i = 0; i & lt; MAX_SIZE-1; i++) {count ++; /*for i loop */for (j = i+1; j < MAX_SIZE; j++) {count ++; /*for j loop */SWAP(a[i][j],a[j][i],temp); count+=3; /*for swap */}count++; /* last timne of j */}count++; /* last time of i */printf("Transpose Count: %d\n", count);}b. Simplified Countsvoid transpose(int a[][MAX_SIZE]){int i, j;int temp;int count = 0;for (i = 0; i < MAX_SIZE-1; i++) {for (j = i+1; j < MAX_SIZE; j++) {count ++; /*for j loop */SWAP(a[i][j],a[j][i],temp); count+=3; /*for swap */}count+=2;}count++; /* last time of i */printf("Transpose Count: %d\n", count);}c. Final Count for 5x5 matrix : 49d. Step Count TableStep Count TableStatement s/ef Total Stepsvoid transpose(inta[][MAX_SIZE]){int i, j;int temp;for (i = 0; i =< MAX_SIZE-1; i++)for (j = i+1; j < MAX_SIZE; j++)SWAP(a[i][j],a[j][i], temp);} 01131111MAX_SMAX_S(MAX_S-1)+MAX_SMAX_S(MAX_S-1)1MAX_SMAX_S•MAX_S-1 +MAX_S3(MAX_S(MAX_S-1))Total : 4MAX_SIZE•MAX_S-1 + 2MAX_SIZEPage 32, Exercise 4a. Countsvoid transpose(int a[][MAX_SIZE]){int i, j;int temp;int count = 0;for (i = 0; i & lt; MAX_SIZE-1; i++) {count ++; /*for i loop */for (j = i+1; j < MAX_SIZE; j++) {count ++; /*for j loop */SWAP(a[i][j],a[j][i],temp); count+=3; /*for swap */}count++; /* last timne of j */}count++; /* last time of i */printf("Transpose Count: %d\n", count);}b. Simplified Countsvoid transpose(int a[][MAX_SIZE]){int i, j;int temp;int count = 0;for (i = 0; i < MAX_SIZE-1; i++) {for (j = i+1; j < MAX_SIZE; j++) {count ++; /*for j loop */SWAP(a[i][j],a[j][i],temp); count+=3; /*for swap */}count+=2;}count++; /* last time of i */printf("Transpose Count: %d\n", count);}c. Final Count for 5x5 matrix : 49d. Step Count TableStep Count TableStatement s/ef Total Stepsvoid transpose(inta[][MAX_SIZE]){int i, j;int temp;for (i = 0; i =< MAX_SIZE-1; i++)for (j = i+1; j < MAX_SIZE; j++)SWAP(a[i][j],a[j][i], temp);} 01131111MAX_SMAX_S(MAX_S-1)+MAX_SMAX_S(MAX_S-1)1MAX_SMAX_S•MAX_S-1 +MAX_S3(MAX_S(MAX_S-1))Total : 4MAX_SIZE•MAX_S-1 + 2MAX_SIZEPage 40, Exercise 11. Show that the following statements are correct:(a) 5n2− 6n = θ(n2) Sincen 2 is the leading exponent this is correct.(b) n! = O(n n) n! is the leading exponent and its time is anon-deterministic polynomial, so this is correct.(c) n2+ n log n = θ(n2 ) n2 is the leading exponent.(f) n2n + 6 . 2n = θ(n2n) n2n is the leading exponent.(g) n2 + 103n2 = θ(n3) Since 103 is a constant and the time is based onthe leading exponent for the variable, this should be n2.(h) 6n3 / (logn+ 1) = O(n3) n3 is the leading exponent.(i) n1.001 + n logn = θ(n1.001 ) This is debatable because n lognactuallygrows at a faster rate than n raised to 1.0001 except for n < 2.(j) n k + n + n k logn = θ(n k logn) for all k ≥ 1. n k logngrows at a fasterrate.(k) 10n3 + 15n4 +100n22n = O(n22n) n22n is the leading exponent.Page 40, Exercise 2Show that the following statements are incorrect:(a) 10n2 + 9 = O(n). The leading exponent is n2 so the correct answer is O n2)(b) n2 logn = θ(n2). The leading exponent is n2 lognso the time is θ(n2logn). <(c) n2 / logn = θ(n2 ). The leading expoonent is n2 / lognso the time isθ( n2 / log n).(d) n32n+ 6n23n= O(n22n). It doesn't make much difference because either way this time is a non-deterministic polynomial. The time should be O( n n).(e) 3n n = O(2n ). The time should be O( n n).Page 41, Exercise 3Page 41, Exercise 4Page 41, Exercise 5Program 1.19 prints out a 2-dimensional array. The outerloop iterates n times as does the inner loop. The time is n•n; therefore, the worst case time is O(n2 ).Page 41, Exercise 6Program 1.19 multiplies a 2-dimensional array. It requires 3-nested loops each iteratint n times. The time is n•n•n; therefore the worst case time is O(n3). Strassen's Matrix Multiplication method reduces the complexity to : O(n2.76).Page 41, Exercise 7a: O(n2)b : 20n+ 4The answer is obvious because 20•20 = 2020. (a) will exceed b at n>20. CHAPTER 2Page 58, Exercise 1#include <stdio.h>#include <stdlib.h>int** make2dArray(int, int);#define MALLOC(p,s) \if (!((p) = malloc(s))) {\fprintf(stderr, "Insufficient memory"); \exit(EXIT_FAILURE); \}int main(){int i,j;int **myArray;myArray = make2dArray(5,10);myArray[2][4]=6;for (i = 0; i<5; i++){for (j = 0; j < 10; j++){/*myArray[i][j] =0;*/printf("%d ", myArray[i][j]);}printf("\n");}}int** make2dArray(int rows, int cols){/*create a 2-d array rows x cols */int **x, i;MALLOC(x,rows*sizeof(*x)); /*get memory for row pointers*/for(i = 0; i < rows; i++){MALLOC(x[i], cols * sizeof(**x)); /*get memory for col pointers*/ *x[i]=0;}return x;}Page 64, Exercise 1#include <stdio.h>#include <string.h>typedef struct {int month;int day;int year;} date;typedef struct {;}noMarriage;typedef struct { date dom, dodivorce;}divorce;typedef struct {date dom, dodeath;}widow;typedef struct {enum tagField {single, married, widowed, divorced} status;union {noMarriage nom;date dom;divorce divorceStuff;widow widowStuff;} u;} maritalStatus;typedef struct {char name[10];int age;float salary;date dob;maritalStatus ms;}humanBeing;void printPerson(humanBeing);int main(){humanBeing p1;p1.dob.month = 5;p1.dob.day = 16;p1.dob.year = 1978;strcpy(, "Fiona");p1.salary = 1.00;p1.ms.status = married;p1.ms.u.dom.month = 10;p1.ms.u.dom.day = 31;p1.ms.u.dom.year = 1999;printPerson(p1);}void printPerson(humanBeing p){/*print out the information on a person */printf("Name: %s\n", );printf("DOB: %d/%d/%d\n", p.dob.month, p.dob.day, p.dob.year); printf("Salary: %5.2f\n", p.salary);switch(p.ms.status){case married:printf("Marriage Date: %d/%d/%d\n", p.ms.u.dom.month, p.ms.u.dom.day, p.ms.u.dom.year);}}Page 64, Exercise 3#include <stdio.h>#include <string.h>typedef struct {double length, width;} rectStuff;typedef struct {double base, height;} triStuff;typedef struct {char name[10];enum tagField {rectangle, triangle, circle} shapeType;union {rectStuff rect;triStuff tri;double radius;} stats;}shape;void printShape(shape);int main(){shape s1, s2, s3;strcpy(, "rectangle");s1.shapeType = rectangle;s1.stats.rect.length = 10;s1.stats.rect.width = 20;strcpy(, "triangle");s2.shapeType = triangle;s2.stats.tri.base = 102;s2.stats.tri.height = 450;strcpy( ,"circle");s3.stats.radius = 2.5;/* printf("%f\n",s3.stats.radius);*/printShape(s1);printShape(s2);printShape(s3);}void printShape(shape s){/*print out the information on a shape */printf("Name: %s\n", );switch(s.shapeType){case rectangle:printf("\tLength:%f\n", s.stats.rect.length);printf("\tWidth:%f\n\n", s.stats.rect.width);break;case triangle:printf("\tBase:%f\n", s.stats.tri.base);printf("\tHeight:%f\n\n", s.stats.tri.height);break;case circle:printf("Radius:%f\n",s.stats.radius);break;}}Page 72, Exercise 2: readPoly() & printPoly()void printPoly(polynomial terms [], int n){/*print the polynomial*/int i;for (i = 0;i < n-1; i++)printf("%5.2fx^%d +", terms[i].coef, terms[i].expon);printf("%5.2fx^%d\n", terms[n-1].coef, terms[n-1].expon); }void readPoly(polynomial terms [], int *n){/*read in a polynomial*/int i,expon;float coef;printf ("Enter the number of terms in your polynomial: ");scanf("%d", n);while (*n >= MAX_TERMS) {printf("Too many terms in the polynomial\n");printf("Number of terms: ");scanf("%d", n);}for (i= 0; i < *n; i++) {printf("Coefficient: ");scanf("%f", &coef);printf("Exponent: ");。

vb-chap6

vb-chap6
2011-3-18 7
1.数组声明
示例:Dim a(9)As Integer; 定义了一个数组a,该数组的数据类 型是integer,具有10个元素。第一个元 素为a(0),最后一个元素为a(9)。 数组定义后,将占用连续的存储空 间,其占用存储空间大小为“长度*数据 类型所占用的字节数”。例如对于上面 定义的a数组,在程序运行时,系统将为 该数组分配一个连续的40字节的存储单 元,用来存放该数组的每一个元素。
2011-3-18 8
2.引用数组元素
数组声明后,即可以对数组元素进行操作。数组 元素的引用格式为: 数组名(下标1[,下标2…]) 注意: (1)下标可以是数值类型的常量、变量或表达式。如 果下标值不是整数,系统自动按四舍五入取整。例如, A(1.7)=9相当于A(2)=9。 (2)下标值必须在声明数组时所指定的下标范围内, 否则会出现“下标越界”的错误。 (3)一般情况下,在程序中允许简单变量出现的地方, 都可以使用数组元素代替。例如,参加表达式运算、 赋值等,但数组元素不能作为过程的形式参数。
txt12 MultiLine ReadOnly btn11 btn12
2011-3-18
True True "" 生成数组 计算
10
Text Text 计算
代码: Dim a(26) As Integer ’定义存放数据的数组 Private Sub btn1 _ Click (ByVal sender As System. Object, ByVal e As System.EventArgs) Handles btn1 Click txt1.Text="" Dim i As Integer Randomize() For i=1 To 25 a(i)=CInt(Rnd() * 90+10) If i Mod 5 = 1 Then txt1.Text &= Chr(13) & Chr(10) End If txt1.Text &= "" &a(i) Next End Sub Private Sub Forml_Load (ByVal sender As System. Object, ByVal e As System.EventArgs) Handles MyBase2. Load txt1.Text = "" txt2.Text = "" End Sub
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

数据结构与算法(五)张铭主讲采用教材:张铭,王腾蛟,赵海燕编写高等教育出版社,2008. 6 (“十一五”国家级规划教材)张铭《数据结构与算法》第五章二叉树•二叉树的概念•二叉树的抽象数据类型•深度优先搜索•宽度优先搜索•二叉树的存储结构•二叉搜索树•堆与优先队列•Huffman树及其应用HGEAB CDFI第五章二叉树第五章二叉树5.4 二叉搜索树二叉搜索树•Binary Search Tree (BST )•或者是一棵空树;•或者是具有下列性质的二叉树:•对于任何一个结点,设其值为K•则该结点的左子树(若不空)的任意一个结点的值都小于K ;•该结点的右子树(若不空)的任意一个结点的值都大于K ;•而且它的左右子树也分别为BST•性质: 中序遍历是正序的(由小到大的排列)151822517892134886093351765BST 示意图wim wenyum xul wulxalwanzol wil zomyoxemziyon检索19121922517892134886093 35166☐只需检索二个子树之一☐直到K被找到☐或遇上树叶仍找不到,则不存在5二叉树 5.4 二叉搜索树插入17☐首先是检索,若找到则不允许插入☐若失败,则在该位置插入一个新叶☐保持BST性质和性能!12192251789 213488609335166172’5二叉树wimwenyumxulwulxalwan zolwil yoxemziyon☐删除wan ☐删除zolzom zoo二叉树5.4 二叉搜索树BST 删除(值替换)void BinarySearchTree<T>:::removehelp(BinaryTreeNode <T> *& rt, const T val) {if (rt==NULL) cout<<val<<" is not in the tree.\n";else if (val < rt->value()) removehelp(rt->leftchild(), val);else if (val > rt->value()) removehelp(rt->rightchild(), val);else { // 真正的删除BinaryTreeNode <T> * temp = rt;if (rt->leftchild() == NULL) rt = rt->rightchild(); else if (rt->rightchild() == NULL) rt = rt->leftchild(); else {temp = deletemin(rt->rightchild()); AB G D J F HC K E I找rt右子树中最小结点,并删除template<class T>BinaryTreeNode* BST::deletemin(BinaryTreeNode <T> *& rt) { if(rt->leftchild() != NULL)return deletemin(rt->leftchild());else{ // 找到右子树中最小,删除BinaryTreeNode <T> *temp = rt;rt= rt->rightchild();return temp;}}AB GDJF HCK EI二叉搜索树总结•组织内存索引•二叉搜索树是适用于内存储器的一种重要的树形索引•常用红黑树、伸展树等,以维持平衡•外存常用B/B+树•保持性质vs 保持性能•插入新结点或删除已有结点,要保证操作结束后仍符合二叉搜索树的定义思考•怎样防止BST退化为线性结构?7323740思考•允许重复关键码吗?•插入、检索、删除12032132427422372440二叉树•二叉树的概念•二叉树的抽象数据类型•深度优先搜索•宽度优先搜索•二叉树的存储结构•二叉搜索树•堆与优先队列•Huffman树及其应用HGEAB CDFI第五章二叉树堆的定义及其实现•最小堆:最小堆是一个关键码序列{ K 0,K 1,…K n-1},它具有如下特性:•K i ≤K 2i+1(i=0,1,…,⎣n/2⎦-1)•K i ≤K 2i 十2•类似可以定义最大堆41628593144012345堆的性质•完全二叉树的层次序列,可以用数组表示•堆中储存的数是局部有序的,堆不唯一•结点的值与其孩子的值之间存在限制•任何一个结点与其兄弟之间都没有直接的限制•从逻辑角度看,堆实际上是一种树形结构4162859 314412345堆的类定义template<class T>class MinHeap{ // 最小堆ADT定义private:T* heapArray; // 存放堆数据的数组int CurrentSize; // 当前堆中元素数目int MaxSize; // 堆所能容纳的最大元素数目void BuildHeap(); // 建堆public:MinHeap(const int n);// 构造函数,n为最大元素数目virtual~MinHeap(){delete[]heapArray;}; // 析构函数bool isLeaf(int pos) const; // 如果是叶结点,返回TRUEint leftchild(int pos) const; // 返回左孩子位置int rightchild(int pos) const; // 返回右孩子位置int parent(int pos) const; // 返回父结点位置bool Remove(int pos, T& node); // 删除给定下标的元素bool Insert(const T& newNode);// 向堆中插入新元素newNodeT& RemoveMin();// 从堆顶删除最小值void SiftUp(int position); // 从position向上开始调整,使序列成为堆void SiftDown(int left);// 筛选法函数,参数left表示开始处理的数组下标}对最小堆用筛选法SiftDown调整template<class T>void MinHeap<T>::SiftDown(int position) {int i= position; // 标识父结点int j = 2*i+1; // 标识关键值较小的子结点Ttemp= heapArray[i]; // 保存父结点72230568947116while(j < CurrentSize) {if((j < CurrentSize-1)&&(heapArray[j] > heapArray[j+1])) j++; // j指向数值较小的子结点if(temp > heapArray[j]) {heapArray[i] = heapArray[j];i= j;j = 2*j + 1; // 向下继续}else break;}heapArray[i]=temp;}72230516 6894对最小堆用筛选法SiftDown调整71对最小堆用筛选法SiftUp向上调整template<class T>void MinHeap<T>::SiftUp(int position) {// 从position向上开始调整,使序列成为堆int temppos=position;// 不是父子结点直接swapT temp=heapArray[temppos];while((temppos>0) && (heapArray[parent(temppos)] > temp)) { heapArray[temppos]=heapArray[parent(temppos)];temppos=parent(temppos);}heapArray[temppos]=temp;// 找到最终位置}二叉树 5.5 堆与优先队列建最小堆过程•首先,将n 个关键码放到一维数组中•整体不是最小堆•所有叶结点子树本身是堆•当i≥⎣n/2⎦时,以关键码Ki为根的子树已经是堆•从倒数第二层,i= ⎣n/2⎦-1 开始从右至左依次调整•直到整个过程到达树根•整棵完全二叉树就成为一个堆41628593144012 345建最小堆过程示意图?16 < 05?71 < 05? 23 < 687273711623946805i=3i=2?23 < 94?73 < 23? 73 < 68?23 < 05?72 < 05? 72 < 16i=0i=1建最小堆从第一个分支结点heapArray[CurrentSize/2-1]开始,自底向上逐步把以子树调整成堆template<class T>void MinHeap<T>::BuildHeap(){// 反复调用筛选函数for(int i=CurrentSize/2-1; i>=0; i--) SiftDown(i);}二叉树 5.5 堆与优先队列最小堆插入新元素template<class T>bool MinHeap<T>::Insert(const T& newNode) //向堆中插入新元素newNode{if(CurrentSize==MaxSize)// 堆空间已经满return false;heapArray[CurrentSize]=newNode;SiftUp(CurrentSize);// 向上调整CurrentSize++;}41628593144012 345最小堆删除元素操作template<class T>bool MinHeap<T>::Remove(int pos, T& node) { if((pos<0)||(pos>=CurrentSize))return false;T temp=heapArray[pos];heapArray[pos]=heapArray[--CurrentSize];if(heapArray[parent(pos)]> heapArray[pos]) SiftUp(pos);//上升筛else SiftDown(pos); // 向下筛node=temp;return true;}·删除6805631668944036 7312013015045删除1605631668944036 7312013015045建堆效率分析•n 个结点的堆,高度d =⎣log 2n + 1⎦。

相关文档
最新文档