C语言第9章(顾元刚)-4

合集下载

c语言程序设计(第四版)-谭浩强

c语言程序设计(第四版)-谭浩强

c语言程序设计(第四版)-谭浩强C语言程序设计(第四版)是由谭浩强教授编写的一本广受欢迎的C语言教材。

这本书以其深入浅出的讲解、丰富的实例和清晰的结构,帮助了无数计算机专业的学生和自学者掌握了C语言的基础知识和编程技巧。

第一章:C语言概述谭浩强教授在开篇第一章中对C语言的历史、特点以及C语言在现代编程领域中的应用进行了简要的介绍。

他强调了C语言的高效性、灵活性以及它在操作系统、嵌入式系统等领域的广泛应用。

第二章:C语言基础第二章深入讲解了C语言的基本语法,包括数据类型、运算符、表达式等。

谭教授通过实际的代码示例,帮助读者理解C语言的基本概念。

第三章:控制语句在第三章中,谭教授详细介绍了C语言中的控制语句,包括条件语句(if、switch)、循环语句(for、while、do-while)和跳转语句(break、continue、goto)。

每个控制语句都有详细的解释和示例代码,帮助读者掌握程序流程控制的方法。

第四章:数组第四章讨论了数组的概念、声明和使用。

谭教授特别强调了数组在C语言中的重要性,以及如何使用数组来存储和处理数据集合。

第五章:函数函数是C语言中实现代码复用的重要手段。

第五章详细讲解了函数的定义、声明、调用以及参数传递。

谭教授还介绍了递归函数的概念和应用。

第六章:指针第六章是C语言中的一个难点,谭教授通过详细的解释和丰富的示例,帮助读者理解指针的概念、指针与数组的关系、指针的运算以及指针在函数中的应用。

第七章:结构体与联合体第七章介绍了C语言中的结构体和联合体,这两种数据类型允许程序员创建复杂的数据结构,以满足不同程序设计的需求。

第八章:预处理指令第八章讲解了预处理指令的概念和使用,包括宏定义、文件包含、条件编译等。

这些指令在C语言程序设计中起到了辅助和优化的作用。

第九章:位运算第九章介绍了位运算的概念和应用,包括位逻辑运算、位移运算等。

位运算在处理二进制数据时非常有用。

第十章:文件操作第十章详细讲解了C语言中的文件操作,包括文件的打开、关闭、读写等操作。

E大学计算机系列教材·数据结构(C语言版)

E大学计算机系列教材·数据结构(C语言版)

本文由FUKA2010贡献 pdf文档可能在WAP端浏览体验不佳。

建议您优先选择TXT,或下载源文件到本机查看。

内容简介 《数据结构》(C 语言版)的第 1 章综述数据、数据结构和抽象数据类型等基本概念;第 2 章 至第 7 章从抽象数据类型的角度,分别讨论线性表、栈、队列、串、数组、广义表、树和二叉 树以及图等基本类型的数据结构及其应用;第 8 章综合介绍操作系统和编译程序中涉及的动态 存储管理的基本技术;第 9 章至第 11 章讨论查找和排序,除了介绍各种实现方法之外,并着重 从时间上进行定性或定量的分析和比较;第 12 章介绍常用的文件结构。

 《数据结构》 (C 语言版)的前半部分从抽象数据类型的角度讨论各种基本类型的数据结构及其 应用;后半部分主要讨论查找和排序的各种实现方法及其综合分析比较。

其内容和章节编排 1992 年 4 月出版的《数据结构》(第二版)基本一致,但在本书中更突出了抽象数据类型的概 念。

全书采用类 C 语言作为数据结构和算法的描述语言。

市场价: ¥ 30.00 卓越价: ¥ 22.50 此商品可以享受免费送货 编辑推荐 《数据结构》(C 语言版)是为“数据结构”课程编写的教材,也可作为学习数据结构及其算法的 C 程序设计的参数教材。

 本书的前半部分从抽象数据类型的角度讨论各种基本类型的数据结构及其应用; 后半部分主要讨 论查找和排序的各种实现方法及其综合分析比较。

其内容和章节编排 1992 年 4 月出版的《数 据结构》(第二版)基本一致,但在本书中更突出了抽象数据类型的概念。

全书采用类 C 语言 作为数据结构和算法的描述语言。

 本书概念表述严谨,逻辑推理严密,语言精炼,用词达意,并有配套出版的《数据结构题集》 (C 语言版),便于教学,又便于自学。

 本书后附有光盘。

光盘内容可在 DOS 环境下运行的以类 C 语言描述的“数据结构算法动态模拟 辅助教学软件,以及在 Windows 环境下运行的以类 PASCAL 或类 C 两种语言描述的“数据结 构算法动态模拟辅助教学软件”。

《C语言》章节列表

《C语言》章节列表

第1章程序设计和C语言1第2章算法——程序的灵魂16第3章最简单的C程序设计——顺序程序设计第4章选择结构程序设计85第5章循环结构程序设计114第6章利用数组处理批量数据1426.1怎样定义和引用一维数组1426.1.1怎样定义一维数组1436.1.2怎样引用一维数组元素1446.1.3一维数组的初始化1456.1.4一维数组程序举例1466.2怎样定义和引用二维数组1486.2.1怎样定义二维数组1496.2.2怎样引用二维数组的元素1506.2.3二维数组的初始化1516.2.4二维数组程序举例1526.3字符数组1546.3.1怎样定义字符数组1546.3.2字符数组的初始化1556.3.3怎样引用字符数组中的元素1556.3.4字符串和字符串结束标志1566.3.5字符数组的输入输出1596.3.6使用字符串处理函数1616.3.7字符数组应用举例165习题168第7章用函数实现模块化程序设计1707.1为什么要用函数1707.2怎样定义函数1727.2.1为什么要定义函数1727.2.2定义函数的方法1737.3调用函数1747.3.1函数调用的形式1747.3.2函数调用时的数据传递1757.3.3函数调用的过程1777.3.4函数的返回值1787.4对被调用函数的声明和函数原型1797.5函数的嵌套调用1827.6函数的递归调用1847.7数组作为函数参数1927.7.1数组元素作函数实参1937.7.2数组名作函数参数1947.7.3多维数组名作函数参数1977.8局部变量和全局变量1997.8.1局部变量1997.8.2全局变量2007.9变量的存储方式和生存期2047.9.1动态存储方式与静态存储方式2047.9.2局部变量的存储类别2057.9.3全局变量的存储类别2087.9.4存储类别小结2127.10关于变量的声明和定义2147.11内部函数和外部函数2157.11.1内部函数2157.11.2外部函数215习题218第8章善于利用指针2208.1指针是什么2208.2指针变量2228.2.1使用指针变量的例子2228.2.2怎样定义指针变量2238.2.3怎样引用指针变量2248.2.4指针变量作为函数参数2268.3通过指针引用数组2308.3.1数组元素的指针2308.3.2在引用数组元素时指针的运算2318.3.3通过指针引用数组元素2338.3.4用数组名作函数参数2378.3.5通过指针引用多维数组2458.4通过指针引用字符串2558.4.1字符串的引用方式 2558.4.2字符指针作函数参数2598.4.3使用字符指针变量和字符数组的比较263 8.5指向函数的指针2668.5.1什么是函数指针2668.5.2用函数指针变量调用函数2668.5.3怎样定义和使用指向函数的指针变量268 8.5.4用指向函数的指针作函数参数2708.6返回指针值的函数2748.7指针数组和多重指针2778.7.1什么是指针数组 2778.7.2指向指针数据的指针2808.7.3指针数组作main函数的形参2828.8动态内存分配与指向它的指针变量2858.8.1什么是内存的动态分配2858.8.2怎样建立内存的动态分配2858.8.3void指针类型 2878.9有关指针的小结288习题291第9章用户自己建立数据类型2939.1定义和使用结构体变量2939.1.1自己建立结构体类型2939.1.2定义结构体类型变量 2959.1.3结构体变量的初始化和引用2979.2使用结构体数组3009.2.1定义结构体数组3009.2.2结构体数组的应用举例3019.3结构体指针3039.3.1指向结构体变量的指针3039.3.2指向结构体数组的指针3049.3.3用结构体变量和结构体变量的指针作函数参数306 9.4用指针处理链表3099.4.1什么是链表 3099.4.2建立简单的静态链表3109.4.3建立动态链表3119.4.4输出链表3159.5共用体类型3179.5.1什么是共用体类型3179.5.2引用共用体变量的方式3189.5.3共用体类型数据的特点3199.6使用枚举类型3239.7用typedef声明新类型名326习题330第10章对文件的输入输出33110.1C文件的有关基本知识33110.1.1什么是文件33110.1.2文件名33210.1.3文件的分类33210.1.4文件缓冲区33310.1.5文件类型指针33310.2打开与关闭文件33510.2.1用fopen函数打开数据文件33510.2.2用fclose函数关闭数据文件33710.3顺序读写数据文件33810.3.1怎样向文件读写字符33810.3.2怎样向文件读写一个字符串34110.3.3用格式化的方式读写文件34410.3.4用二进制方式向文件读写一组数据34510.4随机读写数据文件34910.4.1文件位置标记及其定位34910.4.2随机读写 35210.5文件读写的出错检测353习题354第11章常见错误分析355附录370附录A在Visual C++ 6.0环境下运行C程序的方法370附录B常用字符与ASCII代码对照表377附录CC语言中的关键字378附录D运算符和结合性378附录EC语言常用语法提要380附录FC库函数384参考文献390第4章选择结构程序设计854.1选择结构和条件判断854.2用if语句实现选择结构874.2.1用if语句处理选择结构举例874.2.2if语句的一般形式 894.3关系运算符和关系表达式914.3.1关系运算符及其优先次序914.3.2关系表达式924.4逻辑运算符和逻辑表达式924.4.1逻辑运算符及其优先次序934.4.2逻辑表达式944.4.3逻辑型变量964.5条件运算符和条件表达式974.6选择结构的嵌套1004.7用switch语句实现多分支选择结构1024.8选择结构程序综合举例106习题112第5章循环结构程序设计1155.1为什么需要循环控制1155.2用while语句实现循环1165.3用do…while语句实现循环1185.4用for 语句实现循环1215.5循环的嵌套1255.6几种循环的比较1265.7改变循环执行的状态1265.7.1用break语句提前终止循环1275.7.2用continue语句提前结束本次循环1285.7.3break语句和continue语句的区别1295.8循环程序举例132习题141第6章利用数组处理批量数据1436.1怎样定义和引用一维数组1436.1.1怎样定义一维数组1446.1.2怎样引用一维数组元素1456.1.3一维数组的初始化1466.1.4一维数组程序举例1476.2怎样定义和引用二维数组1496.2.1怎样定义二维数组1506.2.2怎样引用二维数组的元素1516.2.3二维数组的初始化1526.2.4二维数组程序举例1536.3字符数组1556.3.1怎样定义字符数组1556.3.2字符数组的初始化1566.3.3怎样引用字符数组中的元素156 6.3.4字符串和字符串结束标志1576.3.5字符数组的输入输出1606.3.6使用字符串处理函数1626.3.7字符数组应用举例166习题169第7章用函数实现模块化程序设计171 7.1为什么要用函数1717.2怎样定义函数1737.2.1为什么要定义函数1737.2.2定义函数的方法1747.3调用函数1757.3.1函数调用的形式1757.3.2函数调用时的数据传递1767.3.3函数调用的过程1787.3.4函数的返回值1797.4对被调用函数的声明和函数原型181 7.5函数的嵌套调用1837.6函数的递归调用1857.7数组作为函数参数1937.7.1数组元素作函数实参1937.7.2数组名作函数参数1957.7.3多维数组名作函数参数1987.8局部变量和全局变量2007.8.1局部变量2007.8.2全局变量2017.9变量的存储方式和生存期2057.9.1动态存储方式与静态存储方式205 7.9.2局部变量的存储类别2067.9.3全局变量的存储类别2097.9.4存储类别小结2137.10关于变量的声明和定义2157.11内部函数和外部函数2167.11.1内部函数2167.11.2外部函数216习题219第8章善于利用指针2218.1指针是什么2218.2指针变量2238.2.1使用指针变量的例子2238.2.2怎样定义指针变量2248.2.3怎样引用指针变量2258.2.4指针变量作为函数参数2278.3通过指针引用数组2328.3.1数组元素的指针2328.3.2在引用数组元素时指针的运算2338.3.3通过指针引用数组元素2348.3.4用数组名作函数参数2398.3.5通过指针引用多维数组2478.4通过指针引用字符串2578.4.1字符串的引用方式 2578.4.2字符指针作函数参数2618.4.3使用字符指针变量和字符数组的比较265 8.5指向函数的指针2688.5.1什么是函数指针2688.5.2用函数指针变量调用函数2688.5.3怎样定义和使用指向函数的指针变量270 8.5.4用指向函数的指针作函数参数2728.6返回指针值的函数2768.7指针数组和多重指针2798.7.1什么是指针数组 2798.7.2指向指针数据的指针2828.7.3指针数组作main函数的形参2848.8动态内存分配与指向它的指针变量2878.8.1什么是内存的动态分配2878.8.2怎样建立内存的动态分配2878.8.3void指针类型 2898.9有关指针的小结290习题293第9章用户自己建立数据类型2959.1定义和使用结构体变量2959.1.1自己建立结构体类型2959.1.2定义结构体类型变量 2979.1.3结构体变量的初始化和引用2999.2使用结构体数组3029.2.1定义结构体数组3029.2.2结构体数组的应用举例3049.3结构体指针3059.3.1指向结构体变量的指针3059.3.2指向结构体数组的指针3069.3.3用结构体变量和结构体变量的指针作函数参数3089.4用指针处理链表3119.4.1什么是链表 3119.4.2建立简单的静态链表3129.4.3建立动态链表3139.4.4输出链表3179.5共用体类型3199.5.1什么是共用体类型3199.5.2引用共用体变量的方式3209.5.3共用体类型数据的特点3219.6使用枚举类型3259.7用typedef声明新类型名328习题332第10章对文件的输入输出33310.1C文件的有关基本知识33310.1.1什么是文件33310.1.2文件名33410.1.3文件的分类33410.1.4文件缓冲区33510.1.5文件类型指针33510.2打开与关闭文件33710.2.1用fopen函数打开数据文件33710.2.2用fclose函数关闭数据文件33910.3顺序读写数据文件34010.3.1怎样向文件读写字符34010.3.2怎样向文件读写一个字符串34310.3.3用格式化的方式读写文件34610.3.4用二进制方式向文件读写一组数据34710.4随机读写数据文件35110.4.1文件位置标记及其定位35110.4.2随机读写 35410.5文件读写的出错检测355习题356第11章常见错误分析374附录390附录A在Visual C++ 6.0环境下运行C程序的方法390 附录CC语言中的关键字398附录D运算符和结合性398附录EC语言常用语法提要400附录FC库函数404参考文献410。

全套课件-C#入门经典(第4版)_完整

全套课件-C#入门经典(第4版)_完整
第01章 C语言编程
C语言是一种功能强大、简洁的计算机语言,通过它可以编写程序,指挥 计算机完成指定的任务。我们可以利用C语言创建程序(即一组指令),并让计 算机依指令行事。
用C语言编程并不难,本书将用浅显易懂的方法介绍C语言的基础知识, 读完本章,读者就可以编写第一个C语言程序了,其实C语言很简单。 。
1.7 函数及模块化编程
到目前为止,“函数”这个词已出现过好几次了,如main()、printf()、函 数体等。下面将深入研究函数是什么,为什么它们那么重要。
大多数编程语言(包含C语言)都提供了一种方法,将程序切割成多个段, 各段都可以独立编写。在C语言中,这些段称为函数。一个函数的程序代码与 其他函数是相互隔绝的。函数与外界有一个特殊的接口,可将信息传进来,也 可将函数产生的结果传出去。这个接口在函数的第一行即在函数名的地方指定。
1.5.3 定义main()函数
函数是两个括号之间执行某组操作的一段代码。每个C程序都由一个或多 个函数组成,每个C程序都必须有一个main()函数——因为每个程序总是从这 个函数开始执行。因此假定创建、编译、链接了一个名为progname.exe的文 件。执行它时,操作系统会调用这个程序的main()函数。
1.8 常见错误
错误是生活中的一部分。用C语言编写计算机程序时,必须用编译器将源 代码转换成机器码,所以必须用非常严格的规则控制使用C语言的方式。漏掉 一个该有的逗点,或添加不该有的分号,编译器都不会将程序转换成机器码。
即使实践了多年,程序中也很容易出现输入错误。这些错误可能在编译 或链接程序时找出。但有些错误可能使程序执行时,表面上看起来正常,却不 定时地出错,这就需要花很多时间来跟踪错误了 。
1.6.1 了解问题

苏小红c语言程序设计课后答案

苏小红c语言程序设计课后答案

苏小红c语言程序设计课后答案苏小红的《C语言程序设计》是一本广泛使用的教材,它以清晰的结构和丰富的示例,帮助学生掌握C语言的基础知识和编程技巧。

课后答案对于学生来说是一个重要的学习资源,可以帮助他们检查自己的学习成果,加深对知识点的理解。

以下是一些可能的课后答案示例,用于帮助学生复习和理解C语言程序设计的相关概念。

第一章:C语言概述1. C语言的发展历史:C语言由Dennis Ritchie在20世纪70年代初期开发,最初用于UNIX操作系统的编写。

2. C语言的特点:C语言是一种结构化语言,具有高度的灵活性和强大的功能,能够进行底层系统编程。

第二章:C语言基础1. 数据类型:C语言提供了多种数据类型,包括整型(int)、浮点型(float和double)、字符型(char)等。

2. 变量声明:变量在使用前必须声明,声明时需要指定数据类型和变量名。

第三章:运算符和表达式1. 算术运算符:包括加(+)、减(-)、乘(*)、除(/)等。

2. 赋值运算符:如`=`,`+=`,`-=`等,用于给变量赋值或进行运算后赋值。

第四章:控制结构1. 条件语句:如`if`,`else if`,`else`,用于根据不同的条件执行不同的代码块。

2. 循环语句:包括`for`循环、`while`循环和`do-while`循环,用于重复执行代码块。

第五章:数组1. 一维数组:存储相同类型的元素,可以通过下标访问数组元素。

2. 多维数组:如二维数组,可以看作是数组的数组。

第六章:函数1. 函数定义:使用`return`类型和函数名来定义函数。

2. 函数调用:通过函数名和必要的参数来调用函数。

第七章:指针1. 指针变量:存储另一个变量的内存地址。

2. 指针运算:包括地址运算和指针的增减。

第八章:结构体和联合体1. 结构体:可以包含不同类型的数据成员。

2. 联合体:所有成员共享相同的内存位置。

第九章:预处理指令1. 宏定义:使用`#define`来定义常量或代码片段。

c语言程序设计答案(清华大学出版社)

c语言程序设计答案(清华大学出版社)

c语言程序设计答案(清华大学出版社)C语言程序设计是一门基础而重要的计算机编程课程,它不仅教授编程语言的语法和结构,更培养了解决问题的逻辑思维能力。

《C语言程序设计》一书由清华大学出版社出版,是众多高校计算机专业学生的必读教材。

以下是该书的一些答案解析,以帮助学生更好地理解和掌握C 语言的相关知识。

第一章:C语言概述- C语言的特点:C语言是一种结构化语言,具有高效、灵活、功能强大等特点。

- C语言的发展历史:C语言由丹尼斯·里奇在20世纪70年代初期开发,最初用于UNIX操作系统。

第二章:数据类型、运算符和表达式- 基本数据类型:包括整型(int)、字符型(char)、浮点型(float和double)。

- 运算符:包括算术运算符、关系运算符、逻辑运算符、位运算符等。

- 表达式:由常量、变量、运算符和函数调用组成的组合,用于计算和赋值。

第三章:控制语句- 顺序结构:程序按照代码的顺序执行。

- 选择结构:使用`if`、`switch`等语句进行条件判断。

- 循环结构:使用`for`、`while`、`do-while`等语句进行重复执行。

第四章:数组- 一维数组:连续存储的相同类型元素集合。

- 二维数组:可以看作是一维数组的集合。

- 数组的初始化:可以使用花括号进行初始化。

第五章:函数- 函数的定义:使用`return`类型和函数名定义。

- 函数的调用:通过函数名和参数列表调用。

- 递归函数:函数内部调用自身。

第六章:指针- 指针变量:存储变量地址的变量。

- 指针的运算:包括地址运算和指针的自增自减。

- 指针与数组:指针可以方便地访问数组元素。

第七章:结构体与联合体- 结构体:可以包含不同类型的数据成员。

- 联合体:所有成员共享同一块内存空间。

第八章:预处理指令- 宏定义:使用`#define`定义常量或宏。

- 文件包含:使用`#include`引入头文件。

第九章:位运算- 位运算符:包括位与(&)、位或(|)、位非(~)、位异或(^)等。

C语言程序设计(第4版)

C语言程序设计(第4版)
该次修订在保持前三版的写作风格和特色的基础上,主要做了以下改进。
该教材的第1章和第7章由冯佳昕编写;第2章、第3章和第8章由秦玉平编写;第4章~第6章由马靖善编写; 附录由刘福德编写;各章的习题由秦玉平编写。根据由大连理工大学王秀坤担任主审。在该教材的编写过程中, 作者参考了有关C语言程序设计的书籍和资料。
2020年9月,该教材由清华大学出版社出版。
内容简介
《C语言程序设计(第4版)》共分为8章,详细介绍了C语言的基本语法规则和功能实现。其中,第1章为C语 言概述,介绍C语言的简单发展历史、基本特点、32个关键字和语句的分类以及上机操作指导。第2章为C语言的 基本语法规则,介绍数据类型、运算符、表达式和基本输入/输出函数。第3章为控制语句与预处理命令,介绍分 支语句、循环语句和编译预处理命令。第4章为数组,介绍一维数组与二维数组的定义和使用以及常用字符串操作。 第5章为函数,介绍函数的定义、调用、命令行参数的使用、全局变量和局部变量等。第6章为结构体、共用体和 枚举,介绍结构体、共用体和枚举类型、变量的定义和使用、链表的基本操作等。第7章为文件系统,介绍缓冲区 系统文件的常用处理方法。第8章为常见错误和程序调试,介绍初学者常犯错误和程序调试方法。
教材目录
参考资料:
教学资源
该教材有配套教材——《C语言程序设计(第4版)学习与实验指导》。 该教材还提供大纲、源程序、教学课件、习题及其解答、实验指导、教学站等辅助教学资源。
作者简介
马靖善:男,计算机专业硕士毕业,渤海大学信息科学与技术学院教授。一直从事计算机专业教学和科研工 作。
秦玉平:1965年生,男,博士,渤海大学工学院教授,主要从事机器学习和模式识别方面的研究。
感谢观看
C语言程序设计(第4版)

C语言入门经典(第4版)课后练习参考答案

C语言入门经典(第4版)课后练习参考答案

目录目录 (1)第1章C语言编程 (4)练习1.1 (4)练习1.2 (5)练习1.3 (5)第2章编程初步 (6)习题2.1 (6)习题2.2 (7)习题2.3 (9)习题2.4 (10)第3章条件判断 (12)习题3.1 (12)习题3.2 (14)习题3.3 (19)习题3.4 (21)第4章循环 (24)习题4.1 (24)习题4.2 (26)习题4.4 (27)习题4.5 (29)第5章数组 (31)习题5.1 (31)习题5.2 (33)习题5.3 (35)习题5.4 (36)习题5.5 (39)第6章字符串和文本的应用 (41)习题6.1 (41)习题6.2 (50)习题6.3 (53)习题6.4 (53)第7章指针 (57)习题7.1 (57)习题7.2 (59)习题7.3 (61)习题7.4 (63)习题8.1 (65)习题8.2 (67)习题8.3 (69)习题8.4 (73)第9章函数再探 (79)习题9.1 (79)习题9.2 (80)习题9.3 (83)习题9.4 (85)第10章基本输入输出操作 (87)习题10.1 (87)习题10.2 (89)习题10.3 (91)习题10.4 (92)第11章结构化数据 (95)习题11.1 (95)习题11.2 (99)习题11.3 (103)习题11.5 (114)第12章处理文件 (119)习题12.1 (120)习题12.2 (121)习题12.3 (125)习题12.4 (127)第13章支持功能 (132)习题13.1 (133)习题13.2 (133)习题13.3 (135)《C语言入门经典(第4版)》课后练习参考答案第1章C语言编程练习1.1 编写一个程序,用两个printf()语句别离输出自己的名字和地址。

练习1.2将上一个练习修改成所有的输出只用一个printf()语句。

练习1.3编写一个程序,输出下列文本,格式如下所示:"It's freezing in here," he said coldly.第2章编程初步习题2.1 编写一个程序,提示用户用英寸输入一个距离,然后将该距离值输出为码、英尺和英寸的形式。

C语言程序设计(第4版)

C语言程序设计(第4版)

教学资源
《C语言程序设计(第4版)》提供有配套教学课件和源代码、与纸质教材内容配套的数字课程资源、《C语 言程序设计精髓》和《程序设计基》Mooc课程。
《C语言程序设计(第4版)》的配套教材是《C语言程序设计学习指导(第4版)》。
教材特色
该教材在内容的指导思想上,以C语言为工具,介绍计算思维方法和程序设计的基本方法,不拘泥于C语言 的基本语法知识,面向实际应用,把计算思维方法和程序设计中的思想和方法渗透到C语言的介绍中。
2019年8月6日,《C语言程序设计(第4版)》由高等教育出版社出版。
内容简介
全书由14章组成,第1章介绍为什么要学习编程;第2章介绍基本数据类型,包括常量与变量、简单的屏幕输 出、数据类型等内容;第3章介绍基本算术运算符,包括C运算符和表达式、宏常量与宏替换、常用的标准数学函 数等内容;第4章介绍键盘输入和屏幕输出,包括单个字符的输入/输出、数据的格式化屏幕输出、数据的格式化 键盘输入等内容;第5章介绍选择控制结构,包括关系运算符与关系表达式、用于分支控制的条件语句、逻辑运算 符和逻辑表达式等内容;第6章介绍循环控制结构,包括循环控制结构与循环语句、条件控制的循环、流程的转移 控制等内容;第7章介绍函数与模块化程序设计,包括向函数传递值和从函数返回值、函数的递归调用和递归函数、 模块化程序设计等内容;第8章介绍数组和算法基础,包括数组的定义和初始化、向函数传递数组、排序和查找等 内容;第9章介绍指针,包括变量的内存、指针变量的定义和初始化、函数指针及其应用等内容;第10章介绍字 符串,包括字符串字面量、字符指针、向函数传递字符串等内容;第11章介绍指针和数组,包括指针和数组间的 关系、指针数组及其应用、动态数组等内容;第12章介绍结构体和数据结构基础,包括结构体数组的定义和初始 化、结构体指针的定义和初始化、向函数传递结构体等内容;第13章介绍文件操作,包括按字符读写文件、按格 式读写文件、按数据块读写文件等内容;第14章介绍简单的游戏设计,包括动画的基本原理、迷宫游戏、Flappy bird游戏等内容。

《C语言程序设计》李学刚数字资源9章 参考答案 3拓展训练答案 单元2 拓展训练答案

《C语言程序设计》李学刚数字资源9章 参考答案 3拓展训练答案 单元2 拓展训练答案

单元2 拓展训练答案一、单项选择题1.下面4个选项中,均是合法整型常量的是(D )。

A.-0x4al,2e2,0x B.-0xcdf,0la,0xeC.-01,0,0686 D.0,0xabcd,1L2.下面4个选项中,不是合法十六进制数的是的(B )。

A.0XF2A B.01234C.-0xdddd D.0xdefl3.下列正确的转义字符是(A )。

A.'\a' B.'\B' C.'\c' D.'\d' 4.下面4个选项中,均不是不合法的转义字符的是(C )。

A.'\=','\\','xf' B.'\1011','\','\A'C.'\011' ,'\f','\1' D.'\abc','\101','xlf' 5.字符串"\'\\\a\bcde\f\'"的长度是(B )。

A.8 B.9 C.10 D.11 6.下列不能正确定义const常量是(C )。

A.const int b=0; B.int const b=12;C.const int c; D.int const c=10+2;7.宏替换过程是在(B )进行的。

A.运行前B.编译前C.编译后D.编辑后8.有宏定义#define L 10和#define M L+1,则printf("%d\n",10*M-1);输出的结果为( B )。

A.110 B.100C.109 D.1019.若有以下说明语句:char s="\\\\092" ; 则下面正确的是(B )。

A.使s的值包含5个字符B.说明语句不合法10.若有这样的定义和语句:unsigned short a=65535,b;b=a+1;程序其它部分正确,则printf("%d\n",b);输出的值为( A )。

清华大学出版社 C语言课程设计(第4版) 课后答案道

清华大学出版社 C语言课程设计(第4版) 课后答案道

第一章概述1-1简述计算机程序设计语言的发展历程。

解:迄今为止计算机程序设计语言的发展经历了机器语言、汇编语言、高级语言等阶段,C语言是一种面向对象的编程语言,也属于高级语言。

1-2面向对象的编程语言有哪些特点?解:面向对象的编程语言与以往各种编程语言有根本的不同,它设计的出发点就是为了能更直接的描述客观世界中存在的事物以及它们之间的关系。

面向对象的编程语言将客观事物看作具有属性和行为的对象,通过抽象找出同一类对象的共同属性(静态特征)和行为(动态特征),形成类。

通过类的继承与多态可以很方便地实现代码重用,大大缩短了软件开发周期,并使得软件风格统一。

因此,面向对象的编程语言使程序能够比较直接地反问题域的本来面目,软件开发人员能够利用人类认识事物所采用的一般思维方法来进行软件开发。

C语言是目前应用最广的面向对象的编程语言。

1-3什么是结构化程序设计方法?这种方法有哪些优点和缺点?解:结构化程序设计的思路是:自顶向下、逐步求精;其程序结构是按功能划分为若干个基本模块;各模块之间的关系尽可能简单,在功能上相对独立;每一模块内部均是由顺序、选择和循环三种基本结构组成;其模块化实现的具体方法是使用子程序。

结构化程序设计由于采用了模块分解与功能抽象,自顶向下、分而治之的方法,从而有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务,便于开发和维护。

虽然结构化程序设计方法具有很多的优点,但它仍是一种面向过程的程序设计方法,它把数据和处理数据的过程分离为相互独立的实体。

当数据结构改变时,所有相关的处理过程都要进行相应的修改,每一种相对于老问题的新方法都要带来额外的开销,程序的可重用性差。

由于图形用户界面的应用,程序运行由顺序运行演变为事件驱动,使得软件使用起来越来越方便,但开发起来却越来越困难,对这种软件的功能很难用过程来描述和实现,使用面向过程的方法来开发和维护都将非常困难。

1-4什么是对象?什么是面向对象方法?这种方法有哪些特点?解:从一般意义上讲,对象是现实世界中一个实际存在的事物,它可以是有形的,也可以是无形的。

c语言程序设计苏小红课后答案

c语言程序设计苏小红课后答案

c语言程序设计苏小红课后答案C语言程序设计是一门基础而重要的计算机编程课程,它为学生提供了学习程序设计的基本概念、原理和方法。

苏小红编写的《C语言程序设计》是一本广泛使用的教材,其课后习题答案对于学生理解和巩固知识点非常有帮助。

以下是部分课后习题的答案示例,以供参考。

第一章:C语言概述1. 问题:C语言的特点是什么?答案:C语言具有简洁、紧凑、灵活、高效等特点。

它是一种结构化语言,支持多种数据类型,并且具有丰富的运算符。

C语言的程序设计语言简洁,语法结构清晰,易于学习。

2. 问题:C语言的主要应用领域有哪些?答案:C语言广泛应用于系统软件、应用软件、嵌入式系统、操作系统、数据库管理系统等领域。

第二章:数据类型、运算符和表达式1. 问题:C语言中的基本数据类型有哪些?答案:C语言的基本数据类型包括整型(int)、字符型(char)、浮点型(float和double)等。

2. 问题:如何理解C语言中的运算符优先级?答案:C语言中的运算符优先级决定了表达式中各个运算符的执行顺序。

例如,乘除运算符的优先级高于加减运算符,括号内的运算优先级最高。

第三章:控制结构1. 问题:C语言中的三种基本控制结构是什么?答案:C语言中的三种基本控制结构是顺序结构、选择结构和循环结构。

2. 问题:if语句的基本形式有哪些?答案:if语句的基本形式包括单分支if语句、双分支if-else语句和多分支if-else if-else语句。

第四章:数组1. 问题:什么是一维数组?答案:一维数组是具有相同数据类型元素的集合,这些元素在内存中连续存储,可以通过索引访问。

2. 问题:如何声明和初始化一个一维数组?答案:声明一维数组的语法是 `type arrayName[arraySize];`。

初始化可以使用 `{value1, value2, ...}` 的方式,例如 `intarr[5] = {1, 2, 3, 4, 5};`。

《C语言程序设计》李学刚数字资源9章 参考答案 2同步训练答案 同步训练2-1答案

《C语言程序设计》李学刚数字资源9章 参考答案 2同步训练答案 同步训练2-1答案

同步训练2-1答案一、单项选择题1.下面4个选项中,均是合法整型常量的是(A )。

A.160,0xffff,011 B.-0xcdf,0la,0xeC.-01,,0668 D.-0x48a,2e5,0x2.下面4个选项中,均是不合法指数形式的是(B )。

A.123,,.0e5 B.160,,E3C.-018,123e4,0.0 D.-e3,.234,1e33.下面4个选项中,不是合法八进制数的是的(C )。

A.-04567 B.0C.08l D.07L4.下面4个选项中,均是不正确的八进制数或十六进制数的是(D )。

A.016,0x8f,018 B.0adc,017,0xaC.010,-0x11,0x16 D.0a12,7ff,-1235.下面4个选项中,均是正确的数值常量或字符常量的是(D )。

A.,0f,,'&' B."a",,1e1,'\='C.'3',011,0xff00,0a D.+01,0xabcd,2e2,506.下面4个选项中,均是合法转义字符的是(A )。

A.'\'','\\','\n' B."\",'\017','\='C.'\018','\f','xab' D.'\0','\101','xlf'7.下列不正确的转义字符是(C )。

A.'\\' B.'\'' C.'074' D.'\0'8.下列正确的字符是(D )。

A.'\182' B.'\xax' C."a" D.'Z'9.字符串"\t\\chinese\\girl\n"的长度是(B )。

《C语言程序设计》李学刚数字资源9章 参考答案 2同步训练答案 同步训练1-1答案

《C语言程序设计》李学刚数字资源9章 参考答案 2同步训练答案 同步训练1-1答案

同步训练1-1答案一、单项选择题1.C语言是由(C )于1972年在贝尔实验室开发出来的。

A.Matin Richards B.Ken ThompsonC.Dennis Ritchie D.Brian Kernighan2.C语言名称的由来是(B )。

A.对B语言做进一步的充实和完善因此取名为C语言B.取BCPL的第二个字母。

C.第三个程序设计语言D.取Combined的首字母3.C语言是一种(B )的程序设计语言。

A.面向对象B.面向过程C.可视化D.组件导向4.用户可以灵活使用C语言所提供的(B )构成表达式来表达实际问题。

A.关键字B.运算符C.库函数D.字符5.C语言的数据类型丰富,利用(B )可以构造出自己所需要的数据类型。

A.基本类型B.构造类型C.指针类型D.空类型6.C语言程序的基本单位是(B )。

A.程序B.函数C.语句D.字符7.用C语言编写的源代码程序(B )。

A.可立即执行B.是一个源程序C.经过编译即可执行D.经过编译解释才能执行8.以下叙述中正确的是(C )。

A.C源程序不必通过编译就可以直接运行B.C源程序经编译形成的二进制代码可以直接运行C.C源程序经编译、连接后生成的可执行文件可以直接运行D.C源程序经编译、连接后源程序就可以直接运行9.要把高级语言编写的源程序转换为目标程序,需要使用(D )。

A.编辑程序B.驱动程序C.诊断程序D.编译程序10.一个C语言程序的执行是从(A )。

A.main函数开始,直到main函数结束B.第一个函数开始,直到最后一个函数结束C.第一个语句开始,直到最后一个语句结束D.main函数开始,直到最后一个函数结束二、知识填空题1.C语言是面向过程的程序设计语言。

2.用C语言编写的程序,不能被计算机直接识别、理解和执行,需要一种担任翻译工作的程序,称为编译程序。

3.C语言源程序文件的扩展名是.cpp 。

4.C语言源程序经过编译后,生成文件的扩展名是.obj 。

《C语言程序设计》李学刚数字资源9章 参考答案 4自测试卷答案 单元3测验试卷答案

《C语言程序设计》李学刚数字资源9章 参考答案 4自测试卷答案 单元3测验试卷答案

单元3 测验试卷答案一、单项选择题(每题2分,15题共30分)1.scanf函数被称为(B )输入函数。

A.字符B.格式C.整数D.浮点2.逻辑运算符两侧运算对象的数据类型是(D )。

A.只是0或1 B.只能是0或非0正数C.只能是整型或字符型数据D.可以是任何合法的类型数据3.有以下定义和语句char c1='a',c2='f';printf("%d,%c\n",c2-c1,c2-'a'+'B');则输出结果是(D )。

A.2,M B.5,1 C.2,E D.5,G 4.若有定义int k=7, x=12;,则能使值为3的表达式是(C )。

A.x%=(k%=5) B.x%=(k-k%5)C.(x%=k)-(k%=5) D.x%=k-k%55.已知各变量的类型说明如下,则不符合C语言语法的表达式是(A )。

A.x%(-3) B.w+=-2C.k=(a=2,b=3,a+b) D.a+=a-=(b=4)*(a=3) 6.若变量已正确定义并赋值,下面不符合C语言语法的表达式是(D )。

A.a=a+7; B.a=7+b+c,a++ C.(int) 12.3%4 D.a=a+7=a+b 7.以下选项中,与k=n++完全等价的表达式是(A )。

A.k=n,n=n+1 B.n=n+1,k=nC.k=++n D.k+=n+18.若t为double类型,表达式t=1,t+5,t++的值是(A)。

A.B.1 C.D.9.若有定义,int m=5,y=2;则执行表达式y+=y-=m*=y后,y的值为(B )。

A.6 B.-6 C.-8 D.2 10.设a 为double型变量,下列选项中正确的是(B )。

A.scanf("%f",&a); B.scanf("%lf",a);C.scanf(&a); D.scanf("%d",&a);11.以下程序段的输出是(C )。

参考文献_C语言程序设计(第2版)_[共2页]

参考文献_C语言程序设计(第2版)_[共2页]

282
参考文献
[1] 韩增红,王冬梅. C 语言程序设计. 北京:人民邮电出版社,2009.
[2] 谭浩强. C 程序设计(第三版). 北京:清华大学出版社,2006.
[3] Eric S.Roberts. The Art and Science of C. 北京:机械工业出版社,2006.
[4] 张海藩. 软件工程导论(第5版). 北京:清华大学出版社,2008.
[5] 苏长龄,韩增红. C/C++程序设计教程. 长春:吉林科学技术出版社,2007.
[6] Stephen Prata. C Primer Plus (第5版). 北京:人民邮电出版社,2006.
[7] H.M.Deitel ,P.j.Deitel 著. 薛万鹏等译. C 程序设计教程. 北京:机械工业出版社,2005.
[8] 何钦铭,颜晖. C 语言程序设计. 北京:高等教育出版社,2008.
[9] 李明. C 语言程序设计教程. 上海:上海交通大学出版社,2008.
[10] 顾元刚. C 语言程序设计教程. 北京:机械工业出版社,2005.
[11] 林小茶. C 程序设计教程. 北京:清华大学出版社,2005.
[12] 郭翠英. C 语言课程设计案例精编. 北京:中国水利水电出版社,2004.。

严蔚敏版数据结构(C语言版)参考答案第七,九章

严蔚敏版数据结构(C语言版)参考答案第七,九章

第七章图7.14Status Build_AdjList(ALGraph &G)//输入有向图的顶点数,边数,顶点信息和边的信息建立邻接表{InitALGraph(G);scanf("%d",&v);if(v<0) return ERROR; //顶点数不能为负G.vexnum=v;scanf("%d",&a);if(a<0) return ERROR; //边数不能为负G.arcnum=a;for(m=0;m<v;m++)G.vertices[m].data=getchar(); //输入各顶点的符号for(m=1;m<=a;m++){t=getchar();h=getchar(); //t为弧尾,h为弧头if((i=LocateVex(G,t))<0) return ERROR;if((j=LocateVex(G,h))<0) return ERROR; //顶点未找到p=(ArcNode*)malloc(sizeof(ArcNode));if(!G.vertices.[i].firstarc) G.vertices[i].firstarc=p;else{for(q=G.vertices[i].firstarc;q->nextarc;q=q->nextarc);q->nextarc=p;}p->adjvex=j;p->nextarc=NULL;}//whilereturn OK;}//Build_AdjList7.15//本题中的图G均为有向无权图,其余情况容易由此写出Status Insert_Vex(MGraph &G, char v)//在邻接矩阵表示的图G上插入顶点v {if(G.vexnum+1)>MAX_VERTEX_NUM return INFEASIBLE;G.vexs[++G.vexnum]=v;return OK;}//Insert_VexStatus Insert_Arc(MGraph &G,char v,char w)//在邻接矩阵表示的图G上插入边(v,w){if((i=LocateVex(G,v))<0) return ERROR;if((j=LocateVex(G,w))<0) return ERROR;if(i==j) return ERROR;if(!G.arcs[i][j].adj){G.arcs[i][j].adj=1;G.arcnum++;}return OK;}//Insert_ArcStatus Delete_Vex(MGraph &G,char v)//在邻接矩阵表示的图G上删除顶点v {n=G.vexnum;if((m=LocateVex(G,v))<0) return ERROR;G.vexs[m]<->G.vexs[n]; //将待删除顶点交换到最后一个顶点for(i=0;i<n;i++){G.arcs[i][m]=G.arcs[i][n];G.arcs[m][i]=G.arcs[n][i]; //将边的关系随之交换}G.arcs[m][m].adj=0;G.vexnum--;return OK;}//Delete_Vex分析:如果不把待删除顶点交换到最后一个顶点的话,算法将会比较复杂,而伴随着大量元素的移动,时间复杂度也会大大增加.Status Delete_Arc(MGraph &G,char v,char w)//在邻接矩阵表示的图G上删除边(v,w){if((i=LocateVex(G,v))<0) return ERROR;if((j=LocateVex(G,w))<0) return ERROR;if(G.arcs[i][j].adj){G.arcs[i][j].adj=0;G.arcnum--;}return OK;}//Delete_Arc7.16//为节省篇幅,本题只给出Insert_Arc算法.其余算法请自行写出.Status Insert_Arc(ALGraph &G,char v,char w)//在邻接表表示的图G上插入边(v,w) {if((i=LocateVex(G,v))<0) return ERROR;if((j=LocateVex(G,w))<0) return ERROR;p=(ArcNode*)malloc(sizeof(ArcNode));p->adjvex=j;p->nextarc=NULL;if(!G.vertices[i].firstarc) G.vertices[i].firstarc=p;{for(q=G.vertices[i].firstarc;q->q->nextarc;q=q->nextarc)if(q->adjvex==j) return ERROR; //边已经存在q->nextarc=p;}G.arcnum++;return OK;}//Insert_Arc7.17//为节省篇幅,本题只给出较为复杂的Delete_Vex算法.其余算法请自行写出. Status Delete_Vex(OLGraph &G,char v)//在十字链表表示的图G上删除顶点v {if((m=LocateVex(G,v))<0) return ERROR;n=G.vexnum;for(i=0;i<n;i++) //删除所有以v为头的边{if(G.xlist[i].firstin->tailvex==m) //如果待删除的边是头链上的第一个结点{q=G.xlist[i].firstin;G.xlist[i].firstin=q->hlink;free(q);G.arcnum--;}else //否则{for(p=G.xlist[i].firstin;p&&p->hlink->tailvex!=m;p=p->hlink);if(p){q=p->hlink;p->hlink=q->hlink;free(q);G.arcnum--;}}//else}//forfor(i=0;i<n;i++) //删除所有以v为尾的边{if(G.xlist[i].firstout->headvex==m) //如果待删除的边是尾链上的第一个结点 {q=G.xlist[i].firstout;G.xlist[i].firstout=q->tlink;free(q);G.arcnum--;}else //否则{for(p=G.xlist[i].firstout;p&&p->tlink->headvex!=m;p=p->tlink);if(p)q=p->tlink;p->tlink=q->tlink;free(q);G.arcnum--;}}//else}//forfor(i=m;i<n;i++) //顺次用结点m之后的顶点取代前一个顶点{G.xlist[i]=G.xlist[i+1]; //修改表头向量for(p=G.xlist[i].firstin;p;p=p->hlink)p->headvex--;for(p=G.xlist[i].firstout;p;p=p->tlink)p->tailvex--; //修改各链中的顶点序号}G.vexnum--;return OK;}//Delete_Vex7.18//为节省篇幅,本题只给出Delete_Arc算法.其余算法请自行写出.Status Delete_Arc(AMLGraph &G,char v,char w)////在邻接多重表表示的图G上删除边(v,w){if((i=LocateVex(G,v))<0) return ERROR;if((j=LocateVex(G,w))<0) return ERROR;if(G.adjmulist[i].firstedge->jvex==j)G.adjmulist[i].firstedge=G.adjmulist[i].firstedge->ilink;else{for(p=G.adjmulist[i].firstedge;p&&p->ilink->jvex!=j;p=p->ilink);if (!p) return ERROR; //未找到p->ilink=p->ilink->ilink;} //在i链表中删除该边if(G.adjmulist[j].firstedge->ivex==i)G.adjmulist[j].firstedge=G.adjmulist[j].firstedge->jlink;else{for(p=G.adjmulist[j].firstedge;p&&p->jlink->ivex!=i;p=p->jlink);if (!p) return ERROR; //未找到q=p->jlink;p->jlink=q->jlink;free(q);} //在i链表中删除该边G.arcnum--;return OK;}//Delete_ArcStatus Build_AdjMulist(AMLGraph &G)//输入有向图的顶点数,边数,顶点信息和边的信息建立邻接多重表{InitAMLGraph(G);scanf("%d",&v);if(v<0) return ERROR; //顶点数不能为负G.vexnum=v;scanf(%d",&a);if(a<0) return ERROR; //边数不能为负G.arcnum=a;for(m=0;m<v;m++)G.adjmulist[m].data=getchar(); //输入各顶点的符号for(m=1;m<=a;m++){t=getchar();h=getchar(); //t为弧尾,h为弧头if((i=LocateVex(G,t))<0) return ERROR;if((j=LocateVex(G,h))<0) return ERROR; //顶点未找到p=(EBox*)malloc(sizeof(EBox));p->ivex=i;p->jvex=j;p->ilink=NULL;p->jlink=NULL; //边结点赋初值if(!G.adjmulist[i].firstedge) G.adjmulist[i].firstedge=p;else{q=G.adjmulist[i].firstedge;while(q){r=q;if(q->ivex==i) q=q->ilink;else q=q->jlink;}if(r->ivex==i) r->ilink=p;//注意i值既可能出现在边结点的ivex域中,else r->jlink=p; //又可能出现在边结点的jvex域中}//else //插入i链表尾部if(!G.adjmulist[j].firstedge) G.adjmulist[j].firstedge=p;else{q=G.adjmulist[i].firstedge;while(q){r=q;if(q->jvex==j) q=q->jlink;else q=q->ilnk;}if(r->jvex==j) r->jlink=p;else r->ilink=p;}//else //插入j链表尾部}//forreturn OK;}//Build_AdjList7.20int Pass_MGraph(MGraph G)//判断一个邻接矩阵存储的有向图是不是可传递的,是则返回1,否则返回0{for(x=0;x<G.vexnum;x++)for(y=0;y<G.vexnum;y++)if(G.arcs[x][y]){for(z=0;z<G.vexnum;z++)if(z!=x&&G.arcs[y][z]&&!G.arcs[x][z]) return 0;//图不可传递的条件}//ifreturn 1;}//Pass_MGraph分析:本算法的时间复杂度大概是O(n^2*d).7.21int Pass_ALGraph(ALGraph G)//判断一个邻接表存储的有向图是不是可传递的,是则返回1,否则返回0{for(x=0;x<G.vexnum;x++)for(p=G.vertices[x].firstarc;p;p=p->nextarc){y=p->adjvex;for(q=G.vertices[y].firstarc;q;q=q->nextarc){z=q->adjvex;if(z!=x&&!is_adj(G,x,z)) return 0;}//for}//for}//Pass_ALGraphint is_adj(ALGraph G,int m,int n)//判断有向图G中是否存在边(m,n),是则返回1,否则返回0{for(p=G.vertices[m].firstarc;p;p=p->nextarc)if(p->adjvex==n) return 1;return 0;}//is_adj7.22int visited[MAXSIZE]; //指示顶点是否在当前路径上int exist_path_DFS(ALGraph G,int i,int j)//深度优先判断有向图G中顶点i到顶点j是否有路径,是则返回1,否则返回0{if(i==j) return 1; //i就是jelse{visited[i]=1;for(p=G.vertices[i].firstarc;p;p=p->nextarc){k=p->adjvex;if(!visited[k]&&exist_path(k,j)) return 1;//i下游的顶点到j有路径}//for}//else}//exist_path_DFS7.23int exist_path_BFS(ALGraph G,int i,int j)//广度优先判断有向图G中顶点i到顶点j是否有路径,是则返回1,否则返回0{int visited[MAXSIZE];InitQueue(Q);EnQueue(Q,i);while(!QueueEmpty(Q)){DeQueue(Q,u);visited[u]=1;for(p=G.vertices[i].firstarc;p;p=p->nextarc){k=p->adjvex;if(k==j) return 1;if(!visited[k]) EnQueue(Q,k);}//for}//whilereturn 0;}//exist_path_BFS7.24void STraverse_Nonrecursive(Graph G)//非递归遍历强连通图G{int visited[MAXSIZE];InitStack(S);Push(S,GetVex(S,1)); //将第一个顶点入栈visit(1);visited=1;while(!StackEmpty(S)){while(Gettop(S,i)&&i){j=FirstAdjVex(G,i);if(j&&!visited[j]){visit(j);visited[j]=1;Push(S,j); //向左走到尽头}}//whileif(!StackEmpty(S)){Pop(S,j);Gettop(S,i);k=NextAdjVex(G,i,j); //向右走一步if(k&&!visited[k]){visit(k);visited[k]=1;Push(S,k);}}//if}//while}//Straverse_Nonrecursive分析:本算法的基本思想与二叉树的先序遍历非递归算法相同,请参考6.37.由于是强连通图,所以从第一个结点出发一定能够访问到所有结点.7.25见书后解答.7.26Status TopoNo(ALGraph G)//按照题目要求顺序重排有向图中的顶点{int new[MAXSIZE],indegree[MAXSIZE]; //储存结点的新序号n=G.vexnum;FindInDegree(G,indegree);InitStack(S);for(i=1;i<G.vexnum;i++)if(!indegree[i]) Push(S,i); //零入度结点入栈count=0;while(!StackEmpty(S)){Pop(S,i);new[i]=n--; //记录结点的拓扑逆序序号count++;for(p=G.vertices[i].firstarc;p;p=p->nextarc){k=p->adjvex;if(!(--indegree[k])) Push(S,k);}//for}//whileif(count<G.vexnum) return ERROR; //图中存在环for(i=1;i<=n;i++) printf("Old No:%d New No:%d\n",i,new[i])return OK;}//TopoNo分析:只要按拓扑逆序对顶点编号,就可以使邻接矩阵成为下三角矩阵.7.27int visited[MAXSIZE];int exist_path_len(ALGraph G,int i,int j,int k)//判断邻接表方式存储的有向图G的顶点i到j是否存在长度为k的简单路径{if(i==j&&k==0) return 1; //找到了一条路径,且长度符合要求else if(k>0){visited[i]=1;for(p=G.vertices[i].firstarc;p;p=p->nextarc){l=p->adjvex;if(!visited[l])if(exist_path_len(G,l,j,k-1)) return 1; //剩余路径长度减一}//forvisited[i]=0; //本题允许曾经被访问过的结点出现在另一条路径中}//elsereturn 0; //没找到}//exist_path_len7.28int path[MAXSIZE],visited[MAXSIZE]; //暂存遍历过程中的路径int Find_All_Path(ALGraph G,int u,int v,int k)//求有向图G中顶点u到v之间的所有简单路径,k表示当前路径长度{path[k]=u; //加入当前路径中visited[u]=1;if(u==v) //找到了一条简单路径{printf("Found one path!\n");for(i=0;path[i];i++) printf("%d",path[i]); //打印输出}elsefor(p=G.vertices[u].firstarc;p;p=p->nextarc){l=p->adjvex;if(!visited[l]) Find_All_Path(G,l,v,k+1); //继续寻找}visited[u]=0;path[k]=0; //回溯}//Find_All_Pathmain(){...Find_All_Path(G,u,v,0); //在主函数中初次调用,k值应为0...}//main7.29int GetPathNum_Len(ALGraph G,int i,int j,int len)//求邻接表方式存储的有向图G 的顶点i到j之间长度为len的简单路径条数{if(i==j&&len==0) return 1; //找到了一条路径,且长度符合要求else if(len>0){sum=0; //sum表示通过本结点的路径数visited[i]=1;for(p=G.vertices[i].firstarc;p;p=p->nextarc){l=p->adjvex;if(!visited[l])sum+=GetPathNum_Len(G,l,j,len-1)//剩余路径长度减一}//forvisited[i]=0; //本题允许曾经被访问过的结点出现在另一条路径中}//elsereturn sum;}//GetPathNum_Len7.30int visited[MAXSIZE];int path[MAXSIZE]; //暂存当前路径int cycles[MAXSIZE][MAXSIZE]; //储存发现的回路所包含的结点int thiscycle[MAXSIZE]; //储存当前发现的一个回路int cycount=0; //已发现的回路个数void GetAllCycle(ALGraph G)//求有向图中所有的简单回路{for(v=0;v<G.vexnum;v++) visited[v]=0;for(v=0;v<G.vexnum;v++)if(!visited[v]) DFS(G,v,0); //深度优先遍历}//DFSTraversevoid DFS(ALGraph G,int v,int k)//k表示当前结点在路径上的序号{visited[v]=1;path[k]=v; //记录当前路径for(p=G.vertices[v].firstarc;p;p=p->nextarc){w=p->adjvex;if(!visited[w]) DFS(G,w,k+1);else //发现了一条回路{for(i=0;path[i]!=w;i++); //找到回路的起点for(j=0;path[i+j];i++) thiscycle[j]=path[i+j];//把回路复制下来if(!exist_cycle()) cycles[cycount++]=thiscycle;//如果该回路尚未被记录过,就添加到记录中for(i=0;i<G.vexnum;i++) thiscycle[i]=0; //清空目前回路数组}//else}//forpath[k]=0;visited[k]=0; //注意只有当前路径上的结点visited为真.因此一旦遍历中发现当前结点visited为真,即表示发现了一条回路}//DFSint exist_cycle()//判断thiscycle数组中记录的回路在cycles的记录中是否已经存在{int temp[MAXSIZE];for(i=0;i<cycount;i++) //判断已有的回路与thiscycle是否相同{ //也就是,所有结点和它们的顺序都相同j=0;c=thiscycle&#0;; //例如,142857和857142是相同的回路for(k=0;cycles[i][k]!=c&&cycles[i][k]!=0;k++);//在cycles的一个行向量中寻找等于thiscycle第一个结点的元素if(cycles[i][k]) //有与之相同的一个元素{for(m=0;cycles[i][k+m];m++)temp[m]=cycles[i][k+m];for(n=0;n<k;n++,m++)temp[m]=cycles[i][n]; //调整cycles中的当前记录的循环相位并放入temp数组中if(!StrCompare(temp,thiscycle)) //与thiscycle比较return 1; //完全相等for(m=0;m<G.vexnum;m++) temp[m]=0; //清空这个数组}}//forreturn 0; //所有现存回路都不与thiscycle完全相等}//exist_cycle分析:这个算法的思想是,在遍历中暂存当前路径,当遇到一个结点已经在路径之中时就表明存在一条回路;扫描路径向量path可以获得这条回路上的所有结点.把结点序列(例如,142857)存入thiscycle中;由于这种算法中,一条回路会被发现好几次,所以必须先判断该回路是否已经在cycles中被记录过,如果没有才能存入cycles的一个行向量中.把cycles的每一个行向量取出来与之比较.由于一条回路可能有多种存储顺序,比如142857等同于285714和571428,所以还要调整行向量的次序,并存入temp数组,例如,thiscycle为142857第一个结点为1,cycles的当前向量为857142,则找到后者中的1,把1后部分提到1前部分前面,最终在temp中得到142857,与thiscycle比较,发现相同,因此142857和857142是同一条回路,不予存储.这个算法太复杂,很难保证细节的准确性,大家理解思路便可.希望有人给出更加简捷的算法.7.31int visited[MAXSIZE];int finished[MAXSIZE];int count; //count在第一次深度优先遍历中用于指示finished数组的填充位置void Get_SGraph(OLGraph G)//求十字链表结构储存的有向图G的强连通分量{count=0;for(v=0;v<G.vexnum;v++) visited[v]=0;for(v=0;v<G.vexnum;v++) //第一次深度优先遍历建立finished数组if(!visited[v]) DFS1(G,v);for(v=0;v<G.vexnum;v++) visited[v]=0; //清空visited数组for(i=G.vexnum-1;i>=0;i--) //第二次逆向的深度优先遍历{v=finished(i);if(!visited[v]){printf("\n"); //不同的强连通分量在不同的行输出DFS2(G,v);}}//for}//Get_SGraphvoid DFS1(OLGraph G,int v)//第一次深度优先遍历的算法{visited[v]=1;for(p=G.xlist[v].firstout;p;p=p->tlink){w=p->headvex;if(!visited[w]) DFS1(G,w);}//forfinished[++count]=v; //在第一次遍历中建立finished数组}//DFS1void DFS2(OLGraph G,int v)//第二次逆向的深度优先遍历的算法{visited[v]=1;printf("%d",v); //在第二次遍历中输出结点序号for(p=G.xlist[v].firstin;p;p=p->hlink){w=p->tailvex;if(!visited[w]) DFS2(G,w);}//for}//DFS2分析:求有向图的强连通分量的算法的时间复杂度和深度优先遍历相同,也为O(n+e).7.32void Forest_Prim(ALGraph G,int k,CSTree &T)//从顶点k出发,构造邻接表结构的有向图G的最小生成森林T,用孩子兄弟链表存储{for(j=0;j<G.vexnum;j++) //以下在Prim算法基础上稍作改动if(j!=k){closedge[j]={k,Max_int};for(p=G.vertices[j].firstarc;p;p=p->nextarc)if(p->adjvex==k) closedge[j].lowcost=p->cost;}//ifclosedge[k].lowcost=0;for(i=1;i<G.vexnum;i++){k=minimum(closedge);if(closedge[k].lowcost<Max_int){Addto_Forest(T,closedge[k].adjvex,k); //把这条边加入生成森林中closedge[k].lowcost=0;for(p=G.vertices[k].firstarc;p;p=p->nextarc)if(p->cost<closedge[p->adjvex].lowcost)closedge[p->adjvex]={k,p->cost};}//ifelse Forest_Prim(G,k); //对另外一个连通分量执行算法}//for}//Forest_Primvoid Addto_Forest(CSTree &T,int i,int j)//把边(i,j)添加到孩子兄弟链表表示的树T 中{p=Locate(T,i); //找到结点i对应的指针p,过程略q=(CSTNode*)malloc(sizeof(CSTNode));q->data=j;if(!p) //起始顶点不属于森林中已有的任何一棵树{p=(CSTNode*)malloc(sizeof(CSTNode));p->data=i;for(r=T;r->nextsib;r=r->nextsib);r->nextsib=p;p->firstchild=q;} //作为新树插入到最右侧else if(!p->firstchild) //双亲还没有孩子p->firstchild=q; //作为双亲的第一个孩子else //双亲已经有了孩子{for(r=p->firstchild;r->nextsib;r=r->nextsib);r->nextsib=q; //作为双亲最后一个孩子的兄弟}}//Addto_Forestmain(){...T=(CSTNode*)malloc(sizeof(CSTNode)); //建立树根T->data=1;Forest_Prim(G,1,T);...}//main分析:这个算法是在Prim算法的基础上添加了非连通图支持和孩子兄弟链表构建模块而得到的,其时间复杂度为O(n^2).7.33typedef struct {int vex; //结点序号int ecno; //结点所属的连通分量号} VexInfo;VexInfo vexs[MAXSIZE]; //记录结点所属连通分量号的数组void Init_VexInfo(VexInfo &vexs[ ],int vexnum)//初始化{for(i=0;i<vexnum;i++)vexs[i]={i,i}; //初始状态:每一个结点都属于不同的连通分量}//Init_VexInfoint is_ec(VexInfo vexs[ ],int i,int j)//判断顶点i和顶点j是否属于同一个连通分量{if(vexs[i].ecno==vexs[j].ecno) return 1;else return 0;}//is_ecvoid merge_ec(VexInfo &vexs[ ],int ec1,int ec2)//合并连通分量ec1和ec2{for(i=0;vexs[i].vex;i++)if(vexs[i].ecno==ec2) vexs[i].ecno==ec1;}//merge_ecvoid MinSpanTree_Kruscal(Graph G,EdgeSetType &EdgeSet,CSTree &T)//求图的最小生成树的克鲁斯卡尔算法{Init_VexInfo(vexs,G.vexnum);ecnum=G.vexnum; //连通分量个数while(ecnum>1){GetMinEdge(EdgeSet,u,v); //选出最短边if(!is_ec(vexs,u,v)) //u和v属于不同连通分量{Addto_CSTree(T,u,v); //加入到生成树中merge_ec(vexs,vexs[u].ecno,vexs[v].ecno); //合并连通分量ecnum--;}DelMinEdge(EdgeSet,u,v); //从边集中删除}//while}//MinSpanTree_Kruscalvoid Addto_CSTree(CSTree &T,int i,int j)//把边(i,j)添加到孩子兄弟链表表示的树T中{p=Locate(T,i); //找到结点i对应的指针p,过程略q=(CSTNode*)malloc(sizeof(CSTNode));q->data=j;if(!p->firstchild) //双亲还没有孩子p->firstchild=q; //作为双亲的第一个孩子else //双亲已经有了孩子{for(r=p->firstchild;r->nextsib;r=r->nextsib);r->nextsib=q; //作为双亲最后一个孩子的兄弟}}//Addto_CSTree分析:本算法使用一维结构体变量数组来表示等价类,每个连通分量所包含的所有结点属于一个等价类.在这个结构上实现了初始化,判断元素是否等价(两个结点是否属于同一个连通分量),合并等价类(连通分量)的操作.7.34Status TopoSeq(ALGraph G,int new[ ])//按照题目要求给有向无环图的结点重新编号,并存入数组new中{int indegree[MAXSIZE]; //本算法就是拓扑排序FindIndegree(G,indegree);Initstack(S);for(i=0;i<G.vexnum;i++)if(!indegree[i]) Push(S,i);count=0;while(!stackempty(S)){Pop(S,i);new[i]=++count; //把拓扑顺序存入数组的对应分量中for(p=G.vertices[i].firstarc;p;p=p->nextarc){k=p->adjvex;if(!(--indegree[k])) Push(S,k);}}//whileif(count<G.vexnum) return ERROR;return OK;}//TopoSeq7.35int visited[MAXSIZE];void Get_Root(ALGraph G)//求有向无环图的根,如果有的话{for(v=0;v<G.vexnum;v++){for(w=0;w<G.vexnum;w++) visited[w]=0;//每次都要将访问数组清零DFS(G,v); //从顶点v出发进行深度优先遍历for(flag=1,w=0;w<G.vexnum;w++)if(!visited[w]) flag=0; //如果v是根,则深度优先遍历可以访问到所有结点 if(flag) printf("Found a root vertex:%d\n",v);}//for}//Get_Root,这个算法要求图中不能有环,否则会发生误判void DFS(ALGraph G,int v){visited[v]=1;for(p=G.vertices[v].firstarc;p;p=p->nextarc){w=p->adjvex;if(!visited[w]) DFS(G,w);}}//DFS7.36void Fill_MPL(ALGraph &G)//为有向无环图G添加MPL域{FindIndegree(G,indegree);for(i=0;i<G.vexnum;i++)if(!indegree[i]) Get_MPL(G,i);//从每一个零入度顶点出发构建MPL域}//Fill_MPLint Get_MPL(ALGraph &G,int i)//从一个顶点出发构建MPL域并返回其MPL值{if(!G.vertices[i].firstarc){G.vertices[i].MPL=0;return 0; //零出度顶点}else{max=0;for(p=G.vertices[i].firstarc;p;p=p->nextarc){j=p->adjvex;if(G.vertices[j].MPL==0) k=Get_MPL(G,j);if(k>max) max=k; //求其直接后继顶点MPL的最大者}G.vertices[i]=max+1;//再加一,就是当前顶点的MPLreturn max+1;}//else}//Get_MPL7.37int maxlen,path[MAXSIZE]; //数组path用于存储当前路径int mlp[MAXSIZE]; //数组mlp用于存储已发现的最长路径void Get_Longest_Path(ALGraph G)//求一个有向无环图中最长的路径{maxlen=0;FindIndegree(G,indegree);for(i=0;i<G.vexnum;i++){for(j=0;j<G.vexnum;j++) visited[j]=0;if(!indegree[i]) DFS(G,i,0);//从每一个零入度结点开始深度优先遍历}printf("Longest Path:");for(i=0;mlp[i];i++) printf("%d",mlp[i]); //输出最长路径}//Get_Longest_Pathvoid DFS(ALGraph G,int i,int len){visited[i]=1;path[len]=i;if(len>maxlen&&!G.vertices[i].firstarc) //新的最长路径{for(j=0;j<=len;j++) mlp[j]=path[j]; //保存下来maxlen=len;}else{for(p=G.vertices[i].firstarc;p;p=p->nextarc){j=p->adjvex;if(!visited[j]) DFS(G,j,len+1);}}//elsepath[i]=0;visited[i]=0;}//DFS7.38void NiBoLan_DAG(ALGraph G)//输出有向无环图形式表示的表达式的逆波兰式{FindIndegree(G,indegree);for(i=0;i<G.vexnum;i++)if(!indegree[i]) r=i; //找到有向无环图的根PrintNiBoLan_DAG(G,i);}//NiBoLan_DAGvoid PrintNiBoLan_DAG(ALGraph G,int i)//打印输出以顶点i为根的表达式的逆波兰式{c=G.vertices[i].data;if(!G.vertices[i].firstarc) //c是原子printf("%c",c);else //子表达式{p=G.vertices[i].firstarc;PrintNiBoLan_DAG(G,p->adjvex);PrintNiBoLan_DAG(G,p->nexarc->adjvex);printf("%c",c);}}//PrintNiBoLan_DAG7.39void PrintNiBoLan_Bitree(Bitree T)//在二叉链表存储结构上重做上一题{if(T->lchild) PrintNiBoLan_Bitree(T->lchild);if(T->rchild) PrintNiBoLan_Bitree(T->rchild);printf("%c",T->data);}//PrintNiBoLan_Bitree7.40int Evaluate_DAG(ALGraph G)//给有向无环图表示的表达式求值{FindIndegree(G,indegree);for(i=0;i<G.vexnum;i++)if(!indegree[i]) r=i; //找到有向无环图的根return Evaluate_imp(G,i);}//NiBoLan_DAGint Evaluate_imp(ALGraph G,int i)//求子表达式的值{if(G.vertices[i].tag=NUM) return G.vertices[i].value;else{p=G.vertices[i].firstarc;v1=Evaluate_imp(G,p->adjvex);v2=Evaluate_imp(G,p->nextarc->adjvex);return calculate(v1,G.vertices[i].optr,v2);}}//Evaluate_imp分析:本题中,邻接表的vertices向量的元素类型修改如下:struct {enum tag{NUM,OPTR};union {int value;char optr;};ArcNode * firstarc;} Elemtype;7.41void Critical_Path(ALGraph G)//利用深度优先遍历求网的关键路径{FindIndegree(G,indegree);for(i=0;i<G.vexnum;i++)if(!indegree[i]) DFS1(G,i); //第一次深度优先遍历:建立vefor(i=0;i<G.vexnum;i++)if(!indegree[i]) DFS2(G,i); //第二次深度优先遍历:建立vlfor(i=0;i<=G.vexnum;i++)if(vl[i]==ve[i]) printf("%d",i); //打印输出关键路径}//Critical_Pathvoid DFS1(ALGraph G,int i){if(!indegree[i]) ve[i]=0;for(p=G.vertices[i].firstarc;p;p=p->nextarc){dut=*p->info;if(ve[i]+dut>ve[p->adjvex])ve[p->adjvex]=ve[i]+dut;DFS1(G,p->adjvex);}}//DFS1void DFS2(ALGraph G,int i){if(!G.vertices[i].firstarc) vl[i]=ve[i];else{for(p=G.vertices[i].firstarc;p;p=p->nextarc){DFS2(G,p->adjvex);dut=*p->info;if(vl[p->adjvex]-dut<vl[i])vl[i]=vl[p->adjvex]-dut;}}//else}//DFS27.42void ALGraph_DIJ(ALGraph G,int v0,Pathmatrix &P,ShortestPathTable &D)//在邻接表存储结构上实现迪杰斯特拉算法{for(v=0;v<G.vexnum;v++)D[v]=INFINITY;for(p=G.vertices[v0].firstarc;p;p=p->nextarc)D[p->adjvex]=*p->info; //给D数组赋初值for(v=0;v<G.vexnum;v++){final[v]=0;for(w=0;w<G.vexnum;w++) P[v][w]=0; //设空路径if(D[v]<INFINITY){P[v][v0]=1;P[v][v]=1;}}//forD[v0]=0;final[v0]=1; //初始化for(i=1;i<G.vexnum;i++){min=INFINITY;for(w=0;w<G.vexnum;w++)if(!final[w])if(D[w]<min) //尚未求出到该顶点的最短路径{v=w;min=D[w];}final[v]=1;for(p=G.vertices[v].firstarc;p;p=p->nextarc){w=p->adjvex;if(!final[w]&&(min+(*p->info)<D[w])) //符合迪杰斯特拉条件{D[w]=min+edgelen(G,v,w);P[w]=P[v];P[w][w]=1; //构造最短路径}}//for}//for}//ALGraph_DIJ分析:本算法对迪杰斯特拉算法中直接取任意边长度的语句作了修改.由于在原算法中,每次循环都是对尾相同的边进行处理,所以可以用遍历邻接表中的一条链来代替.第九章查找9.25int Search_Sq(SSTable ST,int key)//在有序表上顺序查找的算法,监视哨设在高下标端{ST.elem[ST.length+1].key=key;for(i=1;ST.elem[i].key>key;i++);if(i>ST.length||ST.elem[i].key<key) return ERROR;return i;}//Search_Sq分析:本算法查找成功情况下的平均查找长度为ST.length/2,不成功情况下为ST.length.9.26int Search_Bin_Recursive(SSTable ST,int key,int low,int high)//折半查找的递归算法{if(low>high) return 0; //查找不到时返回0mid=(low+high)/2;if(ST.elem[mid].key==key) return mid;else if(ST.elem[mid].key>key)return Search_Bin_Recursive(ST,key,low,mid-1);else return Search_Bin_Recursive(ST,key,mid+1,high);}}//Search_Bin_Recursive9.27int Locate_Bin(SSTable ST,int key)//折半查找,返回小于或等于待查元素的最后一个结点号{int *r;r=ST.elem;if(key<r.key) return 0;else if(key>=r[ST.length].key) return ST.length;low=1;high=ST.length;while(low<=high){mid=(low+high)/2;if(key>=r[mid].key&&key<r[mid+1].key) //查找结束的条件return mid;else if(key<r[mid].key) high=mid;else low=mid;} //本算法不存在查找失败的情况,不需要return 0;}//Locate_Bin9.28typedef struct {int maxkey;int firstloc;} Index;typedef struct {int *elem;int length;Index idx[MAXBLOCK]; //每块起始位置和最大元素,其中idx[0]不利用,其内容初始化为{0,0}以利于折半查找int blknum; //块的数目} IdxSqList; //索引顺序表类型int Search_IdxSeq(IdxSqList L,int key)//分块查找,用折半查找法确定记录所在块,块内采用顺序查找法{if(key>L.idx[L.blknum].maxkey) return ERROR; //超过最大元素low=1;high=L.blknum;found=0;while(low<=high&&!found) //折半查找记录所在块号mid{mid=(low+high)/2;if(key<=L.idx[mid].maxkey&&key>L.idx[mid-1].maxkey)found=1;else if(key>L.idx[mid].maxkey)low=mid+1;else high=mid-1;}i=L.idx[mid].firstloc; //块的下界j=i+blksize-1; //块的上界temp=L.elem[i-1]; //保存相邻元素L.elem[i-1]=key; //设置监视哨for(k=j;L.elem[k]!=key;k--); //顺序查找L.elem[i-1]=temp; //恢复元素if(k<i) return ERROR; //未找到return k;}//Search_IdxSeq分析:在块内进行顺序查找时,如果需要设置监视哨,则必须先保存相邻块的相邻元素,以免数据丢失.9.29typedef struct {LNode *h; //h指向最小元素LNode *t; //t指向上次查找的结点} CSList;LNode *Search_CSList(CSList &L,int key)//在有序单循环链表存储结构上的查找算法,假定每次查找都成功{if(L.t->data==key) return L.t;else if(L.t->data>key)for(p=L.h,i=1;p->data!=key;p=p->next,i++);elsefor(p=L.t,i=L.tpos;p->data!=key;p=p->next,i++);L.t=p; //更新t指针return p;}//Search_CSList分析:由于题目中假定每次查找都是成功的,所以本算法中没有关于查找失败的处理.由微积分可得,在等概率情况下,平均查找长度约为n/3.9.30typedef struct {DLNode *pre;int data;DLNode *next;} DLNode;typedef struct {DLNode *sp;int length;} DSList; //供查找的双向循环链表类型DLNode *Search_DSList(DSList &L,int key)//在有序双向循环链表存储结构上的查找算法,假定每次查找都成功{p=L.sp;if(p->data>key){while(p->data>key) p=p->pre;L.sp=p;}else if(p->data<key){while(p->data<key) p=p->next;L.sp=p;}return p;}//Search_DSList分析:本题的平均查找长度与上一题相同,也是n/3.9.31int last=0,flag=1;int Is_BSTree(Bitree T)//判断二叉树T是否二叉排序树,是则返回1,否则返回0 {if(T->lchild&&flag) Is_BSTree(T->lchild);if(T->data<last) flag=0; //与其中序前驱相比较last=T->data;if(T->rchild&&flag) Is_BSTree(T->rchild);return flag;}//Is_BSTree9.32int last=0;void MaxLT_MinGT(BiTree T,int x)//找到二叉排序树T中小于x的最大元素和大于x的最小元素{if(T->lchild) MaxLT_MinGT(T->lchild,x); //本算法仍是借助中序遍历来实现if(last<x&&T->data>=x) //找到了小于x的最大元素printf("a=%d\n",last);if(last<=x&&T->data>x) //找到了大于x的最小元素printf("b=%d\n",T->data);last=T->data;if(T->rchild) MaxLT_MinGT(T->rchild,x);}//MaxLT_MinGT9.33void Print_NLT(BiTree T,int x)//从大到小输出二叉排序树T中所有不小于x的元素{if(T->rchild) Print_NLT(T->rchild,x);if(T->data<x) exit(); //当遇到小于x的元素时立即结束运行printf("%d\n",T->data);if(T->lchild) Print_NLT(T->lchild,x); //先右后左的中序遍历}//Print_NLT9.34void Delete_NLT(BiTree &T,int x)//删除二叉排序树T中所有不小于x元素结点,并释放空间{if(T->rchild) Delete_NLT(T->rchild,x);if(T->data<x) exit(); //当遇到小于x的元素时立即结束运行q=T;T=T->lchild;free(q); //如果树根不小于x,则删除树根,并以左子树的根作为新的树根if(T) Delete_NLT(T,x); //继续在左子树中执行算法}//Delete_NLTvoid Print_Between(BiThrTree T,int a,int b)//打印输出后继线索二叉排序树T中所有大于a且小于b的元素{p=T;while(!p->ltag) p=p->lchild; //找到最小元素while(p&&p->data<b){if(p->data>a) printf("%d\n",p->data); //输出符合条件的元素if(p->rtag) p=p->rtag;else{p=p->rchild;while(!p->ltag) p=p->lchild;} //转到中序后继}//while}//Print_Between9.36void BSTree_Insert_Key(BiThrTree &T,int x)//在后继线索二叉排序树T中插入元素x{if(T->data<x) //插入到右侧{if(T->rtag) //T没有右子树时,作为右孩子插入{p=T->rchild;q=(BiThrNode*)malloc(sizeof(BiThrNode));q->data=x;T->rchild=q;T->rtag=0;q->rtag=1;q->rchild=p; //修改原线索}else BSTree_Insert_Key(T->rchild,x);//T有右子树时,插入右子树中}//ifelse if(T->data>x) //插入到左子树中{if(!T->lchild) //T没有左子树时,作为左孩子插入{q=(BiThrNode*)malloc(sizeof(BiThrNode));q->data=x;T->lchild=q;q->rtag=1;q->rchild=T; //修改自身的线索}else BSTree_Insert_Key(T->lchild,x);//T有左子树时,插入左子树中}//if}//BSTree_Insert_KeyStatus BSTree_Delete_key(BiThrTree &T,int x)//在后继线索二叉排序树T中删除元素x{BTNode *pre,*ptr,*suc;//ptr为x所在结点,pre和suc分别指向ptr的前驱和后继 p=T;last=NULL; //last始终指向当前结点p的前一个(前驱)while(!p->ltag) p=p->lchild; //找到中序起始元素while(p){if(p->data==x) //找到了元素x结点{pre=last;ptr=p;}else if(last&&last->data==x) suc=p; //找到了x的后继if(p->rtag) p=p->rtag;else{p=p->rchild;while(!p->ltag) p=p->lchild;} //转到中序后继last=p;}//while //借助中序遍历找到元素x及其前驱和后继结点if(!ptr) return ERROR; //未找到待删结点Delete_BSTree(ptr); //删除x结点if(pre&&pre->rtag)pre->rchild=suc; //修改线索return OK;}//BSTree_Delete_keyvoid Delete_BSTree(BiThrTree &T)//课本上给出的删除二叉排序树的子树T的算法,按照线索二叉树的结构作了一些改动{q=T;if(!T->ltag&&T->rtag) //结点无右子树,此时只需重接其左子树T=T->lchild;else if(T->ltag&&!T->rtag) //结点无左子树,此时只需重接其右子树T=T->rchild;else if(!T->ltag&&!T->rtag) //结点既有左子树又有右子树{p=T;r=T->lchild;while(!r->rtag){s=r;r=r->rchild; //找到结点的前驱r和r的双亲s}T->data=r->data; //用r代替T结点。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

上一张
下一张
例如,可类似于缓冲文件系统,用下列语句打开文 件test.txt: 定义用于保存文件代号的整型变量fd int fd; if(fd=open(“test.txt”, 1)=-1) { printf(“Cannot open file\n”); exit 0; }
上一张
下一张
【例9.10】 #include <io.h> int main(void) { int handle; char msg[] = "Hello world"; if ((handle = open("TEST.$$$",O_CREAT | O_TEXT)) == -1) { perror("Error:"); return 1; }
上一张
下一张
write(handle, msg, strlen(msg)); close(handle); return 0; } 若用写字板观察文件TEST.$$$,可看到以下结果:
Hello world
上一张
下一张
写 文 件
write(<文件代号>,<buff>,<字节数>)
ห้องสมุดไป่ตู้
上一张
下一张
表中: ① 访问方式:1(O_RDONLY)表示以只读方式打开文件;2 (O_WRONLY)表示以只写方式打开文件;4(O_RDWR)表示以 读写方式打开文件。0x0100(O_CREAT)创建并打开文件; 0x0100(_O_EOF)按^Z置文件结束标记;0x0800(O_APPEND) 表示在尾部追加数据;0x4000(O_TEXT)仅用于MS-DOS,表 示回车/换行转换。 ② 文件代号:为一大于0的整型变量。其中,0、1、2分别表 示标准输入、标准输出和标准错误三个文件的代号。用户文 件的代号通常由系统分配。 ③ buff:为一个指针,该指针指向由用户指定的、用于读写数据 的内存区域的首地址。
上一张 下一张
表9.6非缓冲文件系统中使用的常用函数
作 用 打开文件 创建文件 关闭文件 读 文 件 函数形式 open(<文件名>,<访问方式>) creat(<文件名>,<访问方式>) close(<文件代号>) read(<文件代号>,<buff>,<字节数>) 返回值 成功返回文件代号,否则为-1 成功返回文件代号,否则为-1 成功返回0,否则为-1 返回读入的字节数,若文件结 束返回0,否则为-1 返回输出的字节数,否则为-1
9.4 非缓冲文件系统
在TC2.0 可使用基于UNIX的非缓冲文件系 统对文件进行输入输出处理。其函数原型包含 在头文件io.h中,各种操件模式参数包含在头 文件fcntl.h中。缓冲文件系统是通对文件指针 来访问文件,而非缓冲文件系统则采用文件代 号(int类型)访问文件。非缓冲文件系统也定 义标准输入、标准输出和标准错误三个文件。 下面列表9.4简单介绍相关函数。
相关文档
最新文档