顶部
收藏

程序设计基础(第3版)

“十二五”普通高等教育本科国家级规划教材

作者:
陈娟 张长海
定价:
48.00 元
版面字数:
600千字
开本:
16开
装帧形式:
平装
版次:
3
最新版次
印刷时间:
2024年
ISBN:
978-7-04-051436-0
物料号:
51436-00
出版时间:
2019-08-13
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机类专业核心课程
三级分类:
程序设计基础

本书以C 语言为载体,引进问题分析图(Program Analysis Graph,PAD)表示程序逻辑,阐述基本的程序设计方法。全书共分14章,主要内容包括:程序设计的基本概念、思想和方法,数据组织方式,结构化程序开发等。每章都包含大量例题和习题。

本书最大的特点是以“程序设计”为主线,自始至终在讲“程序设计”,而不是讲“语言”,所有例题和习题全部以构造算法为基础,讲述程序设计,而不是解释语言概念。本书目的是教会读者编写程序,提高读者的程序设计能力,彻底改变 “学了程序设计而不会编程序”的现状。

本书整体结构清晰,图文并茂,力求体现“结构化程序设计”思想,注重培养和训练读者良好的程序设计风格。书中配套了重点内容视频、例题代码、部分习题参考答案、电子课件等多媒体资料,为读者提供立体化学习内容。

本书可作为高等学校“高级语言程序设计” “程序设计基础”“C程序设计”等课程的教材和参考书,也可以供从事计算机工作的有关人员阅读参考。

  • 目录
    • 前辅文
      • 第1章 绪论
        • 思维导图
          • 1.1 “鸡兔同笼”——计算
            • 1.2 算法——程序设计精髓
              • 1.2.1 算法概念
                • 1.2.2 表示算法——PAD
                • 1.3 程序设计
                  • 1.3.1 程序设计语言
                    • 1.3.2 程序
                      • 1.3.3 程序执行
                      • 1.4 C 语言
                        • 1.5 Code::Blocks集成开发环境
                          • 1.5.1 启动开发环境
                            • 1.5.2 独立文件模式
                              • 1.5.3 项目管理模式
                                • 1.5.4 警告与错误
                                  • 1.5.5 文件结构
                                  • 1.6 Visual C++集成开发环境
                                    • 1.6.1 启动开发环境
                                      • 1.6.2 独立文件模式
                                        • 1.6.3 项目管理模式
                                          • 1.6.4 警告与错误
                                            • 1.6.5 文件结构
                                            • 本章小结
                                              • 习题1
                                              • 第2章 顺序程序设计
                                                • 思维导图
                                                  • 2.1 计算平均成绩——顺序程序设计
                                                    • 2.2 基本符号
                                                      • 2.2.1 字符集
                                                        • 2.2.2 特定符
                                                          • 2.2.3 标识符
                                                            • 2.2.4 间隔符
                                                              • 2.2.5 注释
                                                              • 2.3 数据
                                                                • 2.3.1 数据类型
                                                                  • 2.3.2 常量
                                                                    • 2.3.3 变量
                                                                    • 2.4 表达式
                                                                      • 2.4.1 组成
                                                                        • 2.4.2 计算
                                                                        • 2.5 语句
                                                                          • 2.5.1 表达式语句
                                                                            • 2.5.2 赋值语句
                                                                              • 2.5.3 复合语句——顺序控制结构
                                                                              • 2.6 输入输出
                                                                                • 2.6.1 字符输入
                                                                                  • 2.6.2 字符输出
                                                                                    • 2.6.3 格式输出
                                                                                      • 2.6.4 格式输入
                                                                                      • 2.7 程序设计实例
                                                                                        • 本章小结
                                                                                          • 习题2
                                                                                          • 第3章 分支程序设计
                                                                                            • 思维导图
                                                                                              • 3.1 判断成绩是否及格——双分支程序设计
                                                                                                • 3.2 成绩加上获奖信息——单分支程序设计
                                                                                                  • 3.3 if语句相关问题
                                                                                                    • 3.4 逻辑判断——布尔类型
                                                                                                      • 3.4.1 关系运算
                                                                                                        • 3.4.2 布尔运算
                                                                                                        • 3.5 获奖分等级——多分支程序设计
                                                                                                          • 本章小结
                                                                                                            • 习题3
                                                                                                            • 第4章 循环程序设计
                                                                                                              • 思维导图
                                                                                                                • 4.1 计算平均成绩——单层循环程序设计
                                                                                                                  • 4.1.1 后判断条件循环
                                                                                                                    • 4.1.2 先判断条件循环
                                                                                                                      • 4.1.3 for语句
                                                                                                                      • 4.2 计算全班每人平均成绩——多重循环程序设计
                                                                                                                        • 4.3 程序设计实例
                                                                                                                          • 本章小结
                                                                                                                            • 习题4
                                                                                                                            • 第5章 模块化程序设计——函数
                                                                                                                              • 思维导图
                                                                                                                                • 5.1 求给定三角形重心——模块化程序设计
                                                                                                                                  • 5.2 函数
                                                                                                                                    • 5.2.1 函数定义
                                                                                                                                      • 5.2.2 函数调用
                                                                                                                                        • 5.2.3 先调用后定义——函数原型
                                                                                                                                        • 5.3 程序设计实例
                                                                                                                                          • 5.4 程序调试
                                                                                                                                            • 5.4.1 适当增加打印变量值语句
                                                                                                                                              • 5.4.2 Code::Blocks环境下调试
                                                                                                                                                • 5.4.3 VC环境下调试
                                                                                                                                                • 本章小结
                                                                                                                                                  • 习题5
                                                                                                                                                  • 第6章 批量数据组织——数组
                                                                                                                                                    • 思维导图
                                                                                                                                                      • 6.1 成绩统计——数组类型
                                                                                                                                                        • 6.1.1 数组声明
                                                                                                                                                          • 6.1.2 下标表达式
                                                                                                                                                            • 6.1.3 数组操作
                                                                                                                                                            • 6.2 统计多科成绩——多维数组
                                                                                                                                                              • 6.3 程序设计实例
                                                                                                                                                                • 6.4 线性表——分类与检索
                                                                                                                                                                  • 6.4.1 分类
                                                                                                                                                                    • 6.4.2 检索
                                                                                                                                                                    • 6.5 带学号的成绩排序——数组初值
                                                                                                                                                                      • 6.5.1 一维数组初值
                                                                                                                                                                        • 6.5.2 多维数组初值
                                                                                                                                                                        • 6.6 表示姓名——字符串
                                                                                                                                                                          • 6.6.1 结束标志
                                                                                                                                                                            • 6.6.2 初始化
                                                                                                                                                                              • 6.6.3 输入输出
                                                                                                                                                                                • 6.6.4 运算
                                                                                                                                                                                • 6.7 类型定义
                                                                                                                                                                                  • 6.7.1 定义已有类型名
                                                                                                                                                                                    • 6.7.2 定义数组类型名
                                                                                                                                                                                    • *6.8 线性表——栈和队列
                                                                                                                                                                                      • 6.8.1 栈
                                                                                                                                                                                        • 6.8.2 队列
                                                                                                                                                                                        • 本章小结
                                                                                                                                                                                          • 习题6
                                                                                                                                                                                          • 第7章 指针
                                                                                                                                                                                            • 思维导图
                                                                                                                                                                                              • 7.1 二维数组排序——指针
                                                                                                                                                                                                • 7.2 指针与变量
                                                                                                                                                                                                  • 7.2.1 指针类型和指针变量
                                                                                                                                                                                                    • 7.2.2 指针所指变量
                                                                                                                                                                                                      • 7.2.3 空指针与无效指针
                                                                                                                                                                                                      • 7.3 指针操作
                                                                                                                                                                                                        • 7.4 指向指针的指针
                                                                                                                                                                                                          • 7.5 指针与数组
                                                                                                                                                                                                            • 7.5.1 指针标识数组
                                                                                                                                                                                                              • 7.5.2 指针运算
                                                                                                                                                                                                                • 7.5.3 应注意的问题
                                                                                                                                                                                                                  • 7.5.4 多维数组与指针
                                                                                                                                                                                                                    • 7.5.5 指针数组
                                                                                                                                                                                                                    • 7.6 指针与字符串
                                                                                                                                                                                                                      • 本章小结
                                                                                                                                                                                                                        • 习题7
                                                                                                                                                                                                                        • 第8章 表单数据组织——结构体
                                                                                                                                                                                                                          • 思维导图
                                                                                                                                                                                                                            • 8.1 成绩单管理——结构体
                                                                                                                                                                                                                              • 8.2 结构体
                                                                                                                                                                                                                                • 8.2.1 结构体类型
                                                                                                                                                                                                                                  • 8.2.2 结构体类型名
                                                                                                                                                                                                                                    • 8.2.3 结构体变量
                                                                                                                                                                                                                                      • 8.2.4 指向结构体变量的指针
                                                                                                                                                                                                                                        • 8.2.5 访问结构体变量的成员
                                                                                                                                                                                                                                          • 8.2.6 对结构体变量的操作
                                                                                                                                                                                                                                          • 8.3 程序设计实例
                                                                                                                                                                                                                                            • 本章小结
                                                                                                                                                                                                                                              • 习题8
                                                                                                                                                                                                                                              • 第9章 再论函数
                                                                                                                                                                                                                                                • 思维导图
                                                                                                                                                                                                                                                  • 9.1 参数
                                                                                                                                                                                                                                                    • 9.1.1 C语言中参数传递规则
                                                                                                                                                                                                                                                      • 9.1.2 传递直线方程系数——指针作参数
                                                                                                                                                                                                                                                        • 9.1.3 对任意数组排序——数组作参数
                                                                                                                                                                                                                                                          • 9.1.4 输出成绩单——结构体作参数
                                                                                                                                                                                                                                                          • 9.2 函数值
                                                                                                                                                                                                                                                            • 9.2.1 打印月份名——返回指针值的函数
                                                                                                                                                                                                                                                              • 9.2.2 读入一张成绩单——返回结构体值的函数
                                                                                                                                                                                                                                                              • 9.3 作用域
                                                                                                                                                                                                                                                                • 9.3.1 作用域
                                                                                                                                                                                                                                                                  • 9.3.2 局部量和全局量
                                                                                                                                                                                                                                                                  • 本章小结
                                                                                                                                                                                                                                                                    • 习题9
                                                                                                                                                                                                                                                                    • 第10章 递归程序设计
                                                                                                                                                                                                                                                                      • 思维导图
                                                                                                                                                                                                                                                                        • 10.1 计算n!—— 递归程序设计
                                                                                                                                                                                                                                                                          • 10.2 程序设计实例
                                                                                                                                                                                                                                                                            • 10.3 递归程序执行过程
                                                                                                                                                                                                                                                                              • *10.4 间接递归
                                                                                                                                                                                                                                                                                • 本章小结
                                                                                                                                                                                                                                                                                  • 习题10
                                                                                                                                                                                                                                                                                  • 第11章 外部数据组织——文件
                                                                                                                                                                                                                                                                                    • 思维导图
                                                                                                                                                                                                                                                                                      • 11.1 重新考虑成绩单管理问题——文件
                                                                                                                                                                                                                                                                                        • 11.2 文件概述
                                                                                                                                                                                                                                                                                          • 11.3 打开关闭文件
                                                                                                                                                                                                                                                                                            • 11.4 I/O操作
                                                                                                                                                                                                                                                                                              • 11.4.1 字符读写
                                                                                                                                                                                                                                                                                                • 11.4.2 字符串读写
                                                                                                                                                                                                                                                                                                  • 11.4.3 格式化读写
                                                                                                                                                                                                                                                                                                    • 11.4.4 数据块读写
                                                                                                                                                                                                                                                                                                      • 11.4.5 文件定位
                                                                                                                                                                                                                                                                                                      • 11.5 与操作系统文件联系——程序参数
                                                                                                                                                                                                                                                                                                        • 11.5.1 基本概念
                                                                                                                                                                                                                                                                                                          • 11.5.2 命令行设定程序参数
                                                                                                                                                                                                                                                                                                            • 11.5.3 VC6.0设定程序参数
                                                                                                                                                                                                                                                                                                              • 11.5.4 Code::Blocks设定程序参数
                                                                                                                                                                                                                                                                                                                • 11.5.5 程序健壮性
                                                                                                                                                                                                                                                                                                                • 11.6 程序设计实例
                                                                                                                                                                                                                                                                                                                  • 本章小结
                                                                                                                                                                                                                                                                                                                    • 习题11
                                                                                                                                                                                                                                                                                                                    • 第12章 程序开发
                                                                                                                                                                                                                                                                                                                      • 思维导图
                                                                                                                                                                                                                                                                                                                        • 12.1 验证三角形内心定理——自顶向下、逐步求精
                                                                                                                                                                                                                                                                                                                          • 12.2 结构化程序设计原则
                                                                                                                                                                                                                                                                                                                            • 12.3 程序风格
                                                                                                                                                                                                                                                                                                                              • 12.3.1 行文格式
                                                                                                                                                                                                                                                                                                                                • 12.3.2 标识符
                                                                                                                                                                                                                                                                                                                                  • 12.3.3 注释
                                                                                                                                                                                                                                                                                                                                    • 12.3.4 关于程序的“说明和定义”
                                                                                                                                                                                                                                                                                                                                    • *12.4 八皇后——穷举与试探
                                                                                                                                                                                                                                                                                                                                      • 12.4.1 数据表示
                                                                                                                                                                                                                                                                                                                                        • 12.4.2 穷举法迭代实现
                                                                                                                                                                                                                                                                                                                                          • 12.4.3 试探法迭代实现
                                                                                                                                                                                                                                                                                                                                            • 12.4.4 穷举法递归实现
                                                                                                                                                                                                                                                                                                                                              • 12.4.5 试探法递归实现
                                                                                                                                                                                                                                                                                                                                                • 12.4.6 检验函数
                                                                                                                                                                                                                                                                                                                                                • 本章小结
                                                                                                                                                                                                                                                                                                                                                  • 习题12
                                                                                                                                                                                                                                                                                                                                                  • 第13章 动态数据组织
                                                                                                                                                                                                                                                                                                                                                    • 思维导图
                                                                                                                                                                                                                                                                                                                                                      • 13.1 保存实数序列——动态数据结构
                                                                                                                                                                                                                                                                                                                                                        • 13.2 动态变量
                                                                                                                                                                                                                                                                                                                                                          • 13.3 链表
                                                                                                                                                                                                                                                                                                                                                            • 13.3.1 基本概念
                                                                                                                                                                                                                                                                                                                                                              • 13.3.2 基本操作
                                                                                                                                                                                                                                                                                                                                                                • 13.3.3 栈与队列
                                                                                                                                                                                                                                                                                                                                                                • 13.4 程序设计实例
                                                                                                                                                                                                                                                                                                                                                                  • *13.5 树
                                                                                                                                                                                                                                                                                                                                                                    • 13.5.1 基本概念
                                                                                                                                                                                                                                                                                                                                                                      • 13.5.2 基本操作
                                                                                                                                                                                                                                                                                                                                                                      • *13.6 图
                                                                                                                                                                                                                                                                                                                                                                        • 13.6.1 基本概念
                                                                                                                                                                                                                                                                                                                                                                          • 13.6.2 存储方式
                                                                                                                                                                                                                                                                                                                                                                            • 13.6.3 基本操作
                                                                                                                                                                                                                                                                                                                                                                            • 本章小结
                                                                                                                                                                                                                                                                                                                                                                              • 习题13
                                                                                                                                                                                                                                                                                                                                                                              • *第14章 若干深入问题
                                                                                                                                                                                                                                                                                                                                                                                • 思维导图
                                                                                                                                                                                                                                                                                                                                                                                  • 14.1 函数
                                                                                                                                                                                                                                                                                                                                                                                    • 14.1.1 不定方向的数组排序——函数指针
                                                                                                                                                                                                                                                                                                                                                                                      • 14.1.2 计算定积分——函数作参数
                                                                                                                                                                                                                                                                                                                                                                                        • 14.1.3 指针形参作指针参数的实参
                                                                                                                                                                                                                                                                                                                                                                                          • 14.1.4 实参计算顺序
                                                                                                                                                                                                                                                                                                                                                                                            • 14.1.5 函数副作用
                                                                                                                                                                                                                                                                                                                                                                                            • 14.2 运算
                                                                                                                                                                                                                                                                                                                                                                                              • 14.2.1 复合赋值
                                                                                                                                                                                                                                                                                                                                                                                                • 14.2.2 顺序表达式
                                                                                                                                                                                                                                                                                                                                                                                                  • 14.2.3 条件表达式
                                                                                                                                                                                                                                                                                                                                                                                                    • 14.2.4 位运算
                                                                                                                                                                                                                                                                                                                                                                                                      • 14.2.5 左值
                                                                                                                                                                                                                                                                                                                                                                                                      • 14.3 语句
                                                                                                                                                                                                                                                                                                                                                                                                        • 14.3.1 break
                                                                                                                                                                                                                                                                                                                                                                                                          • 14.3.2 continue
                                                                                                                                                                                                                                                                                                                                                                                                            • 14.3.3 for的延伸
                                                                                                                                                                                                                                                                                                                                                                                                              • 14.3.4 goto和标号
                                                                                                                                                                                                                                                                                                                                                                                                              • 14.4 数据组织
                                                                                                                                                                                                                                                                                                                                                                                                                • 14.4.1 行指针
                                                                                                                                                                                                                                                                                                                                                                                                                  • 14.4.2 枚举类型
                                                                                                                                                                                                                                                                                                                                                                                                                    • 14.4.3 职工登记卡——共用体
                                                                                                                                                                                                                                                                                                                                                                                                                      • 14.4.4 位段
                                                                                                                                                                                                                                                                                                                                                                                                                      • 14.5 存储类别
                                                                                                                                                                                                                                                                                                                                                                                                                        • 14.5.1 数据在内存中的存储
                                                                                                                                                                                                                                                                                                                                                                                                                          • 14.5.2 生存期
                                                                                                                                                                                                                                                                                                                                                                                                                            • 14.5.3 局部变量的存储类别
                                                                                                                                                                                                                                                                                                                                                                                                                              • 14.5.4 全局变量的存储类别
                                                                                                                                                                                                                                                                                                                                                                                                                                • 14.5.5 函数的存储类别
                                                                                                                                                                                                                                                                                                                                                                                                                                • 14.6 编译预处理
                                                                                                                                                                                                                                                                                                                                                                                                                                  • 14.6.1 宏
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 14.6.2 条件编译
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 习题14
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 附录A ASCII字符集
                                                                                                                                                                                                                                                                                                                                                                                                                                        • 附录B 标准函数库头文件表
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 附录C 常用函数库中所含常用函数
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 参考文献
                                                                                                                                                                                                                                                                                                                                                                                                                                            课程网址: null

                                                                                                                                                                                                                                                                                                                                                                                                                                            相关图书