顶部
收藏

数据结构(Java版)

“十二五”职业教育国家规划教材

作者:
杨淑萍 聂哲
定价:
26.80 元
版面字数:
420千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
2020年
ISBN:
978-7-04-037626-5
物料号:
37626-A0
出版时间:
2013-07-16
读者对象:
高等职业教育
一级分类:
计算机大类
二级分类:
计算机类
三级分类:
计算机类专业基础课程

本书是全国高职高专教育规划教材,也是国家示范性高职院校深圳职业技术学院软件技术专业Java 方向工学结合系列精品教材。

本书讨论了几种经典数据结构(顺序表、链表、栈、队列、树、二叉树和图)的逻辑结构与存储结构,以及几种经典的排序和查找技术的算法思想和实现过 程。以Java 为程序设计语言,从问题入手,采用项目驱动、层层拓展的教学思路详细讨论了各种数据结构的设计方法、实现步骤和使用方法,讨论了各种排序查找算法的实现和 使用方法,同时,还对Java类库中相关数据结构类及接口的使用方法进行了简单的讨论。书中例题程序思路清晰、代码简洁完整,易于教师教学和学生自学。

本书适合作为高职高专计算机及相关专业的“数据结构&rdquo

  • 目录
    • 前辅文
      • 第1章 数据结构概述
        • 1.1 什么是数据结构
          • 1.1.1 计算机处理问题的分类
            • 1.1.2 数据结构包含的内容
              • 1.1.3 数据结构课程的发展状况
              • 1.2 数据结构的基本概念及分类
                • 1.2.1 数据结构的基本概念
                  • 1.2.2 数据结构的分类
                  • 1.3 数据的逻辑结构和存储结构
                    • 1.3.1 数据的逻辑结构
                      • 1.3.2 数据的存储结构
                      • 1.4 数据类型与抽象数据类型
                        • 1.4.1 数据类型
                          • 1.4.2 抽象数据类型
                          • 1.5 算法和算法分析
                            • 1.5.1 算法特性
                              • 1.5.2 算法描述
                                • 1.5.3 算法性能分析与度量
                                • 1.6 Java语言数据结构工具包
                                  • 1.7 小结
                                    • 习题1
                                    • 第2章 顺序表与链表
                                      • 2.1 线性表
                                        • 2.1.1 问题引入
                                          • 2.1.2 线性表的定义
                                            • 2.1.3 线性表的抽象数据类型
                                            • 2.2 顺序表
                                              • 2.2.1 顺序表的结构
                                                • 2.2.2 顺序表的操作
                                                  • 2.2.3 顺序表的实现与使用
                                                    • 2.2.4 顺序表的性能分析
                                                      • 2.2.5 实战演练
                                                      • 2.3 Java类库中的顺序表
                                                        • 2.3.1 ArrayList类
                                                          • 2.3.2 使用ArrayList类
                                                            • 2.3.3 实战演练
                                                            • 2.4 单链表
                                                              • 2.4.1 单链表的结构
                                                                • 2.4.2 单链表的操作
                                                                  • 2.4.3 单链表的实现与使用
                                                                    • 2.4.4 单链表的性能分析
                                                                      • 2.4.5 实战演练
                                                                      • 2.5 双向链表
                                                                        • 2.5.1 双向链表的结构
                                                                          • 2.5.2 双向链表的操作
                                                                            • 2.5.3 双向链表的实现与使用
                                                                              • 2.5.4 双向链表的性能分析
                                                                                • 2.5.5 实战演练
                                                                                • 2.6 循环链表
                                                                                  • 2.6.1 循环单链表
                                                                                    • 2.6.2 循环双链表
                                                                                    • 2.7 Java类库中的链表
                                                                                      • 2.8 小结
                                                                                        • 习题2
                                                                                        • 第3章 栈与队列
                                                                                          • 3.1 栈
                                                                                            • 3.1.1 问题引入
                                                                                              • 3.1.2 栈的基本概念
                                                                                                • 3.1.3 栈的抽象数据类型
                                                                                                  • 3.1.4 栈的存储结构
                                                                                                    • 3.1.5 栈的实现及使用
                                                                                                      • 3.1.6 实战演练
                                                                                                        • 3.2 Java类库中的栈
                                                                                                          • 3.2.1 Stack类
                                                                                                            • 3.2.2 使用Stack类
                                                                                                              • 3.2.3 实战演练
                                                                                                              • 3.3 队列
                                                                                                                • 3.3.1 问题引入
                                                                                                                  • 3.3.2 队列的基本概念
                                                                                                                    • 3.3.3 队列的抽象数据类型
                                                                                                                      • 3.3.4 队列的存储结构
                                                                                                                        • 3.3.5 队列的实现与使用
                                                                                                                          • 3.3.6 实战演练
                                                                                                                          • 3.4 使用Java类库实现模拟营业厅
                                                                                                                            • 3.4.1 Queue接口和LinkedList类
                                                                                                                              • 3.4.2 使用Queue接口和LinkedList类
                                                                                                                                • 3.4.3 实战演练
                                                                                                                                • 3.5 小结
                                                                                                                                  • 习题3
                                                                                                                                  • 第4章 树与二叉树
                                                                                                                                    • 4.1 树
                                                                                                                                      • 4.1.1 问题引入
                                                                                                                                        • 4.1.2 树的基本概念
                                                                                                                                          • 4.1.3 树的表示方法
                                                                                                                                            • 4.1.4 树的存储结构
                                                                                                                                              • 4.1.5 Java类库中的树及其使用
                                                                                                                                                • 4.1.6 实战演练
                                                                                                                                                • 4.2 二叉树
                                                                                                                                                  • 4.2.1 问题引入
                                                                                                                                                    • 4.2.2 二叉树的基本概念
                                                                                                                                                      • 4.2.3 二叉树的存储结构
                                                                                                                                                        • 4.2.4 二叉树的抽象数据类型
                                                                                                                                                          • 4.2.5 二叉树的遍历
                                                                                                                                                            • 4.2.6 二叉树的实现与使用
                                                                                                                                                              • 4.2.7 实战演练
                                                                                                                                                              • 4.3 二叉树、树及森林之间的转换
                                                                                                                                                                • 4.3.1 树转换为二叉树
                                                                                                                                                                  • 4.3.2 森林转换为二叉树
                                                                                                                                                                    • 4.3.3 二叉树还原为树或森林
                                                                                                                                                                      • 4.3.4 实战演练
                                                                                                                                                                      • 4.4 哈夫曼树
                                                                                                                                                                        • 4.4.1 问题引入
                                                                                                                                                                          • 4.4.2 哈夫曼树与哈夫曼编码
                                                                                                                                                                            • 4.4.3 哈夫曼树的实现与使用
                                                                                                                                                                              • 4.4.4 实战演练
                                                                                                                                                                              • 4.5 小结
                                                                                                                                                                                • 习题4
                                                                                                                                                                                • 第5章 图
                                                                                                                                                                                  • 5.1 图的基本概念
                                                                                                                                                                                    • 5.1.1 图的定义
                                                                                                                                                                                      • 5.1.2 基本术语
                                                                                                                                                                                        • 5.1.3 图的抽象数据类型
                                                                                                                                                                                        • 5.2 图的存储表示
                                                                                                                                                                                          • 5.2.1 邻接矩阵
                                                                                                                                                                                            • 5.2.2 邻接表
                                                                                                                                                                                            • 5.3 图的遍历
                                                                                                                                                                                              • 5.3.1 深度优先搜索遍历
                                                                                                                                                                                                • 5.3.2 广度优先搜索遍历
                                                                                                                                                                                                  • 5.3.3 图遍历的实现与使用
                                                                                                                                                                                                    • 5.3.4 实战演练
                                                                                                                                                                                                    • 5.4 最小生成树
                                                                                                                                                                                                      • 5.4.1 问题引入
                                                                                                                                                                                                        • 5.4.2 最小生成树的基本概念
                                                                                                                                                                                                          • 5.4.3 最小生成树的构造方法
                                                                                                                                                                                                            • 5.4.4 最小生成树的实现与使用
                                                                                                                                                                                                              • 5.4.5 实战演练
                                                                                                                                                                                                              • 5.5 最短路径
                                                                                                                                                                                                                • 5.5.1 问题引入
                                                                                                                                                                                                                  • 5.5.2 最短路径问题的基本概念
                                                                                                                                                                                                                    • 5.5.3 求解最短路径的算法思想
                                                                                                                                                                                                                      • 5.5.4 最短路径的实现与使用
                                                                                                                                                                                                                        • 5.5.5 实战演练
                                                                                                                                                                                                                        • 5.6 拓扑排序
                                                                                                                                                                                                                          • 5.6.1 问题引入
                                                                                                                                                                                                                            • 5.6.2 拓扑排序的基本概念
                                                                                                                                                                                                                              • 5.6.3 拓扑排序的算法过程
                                                                                                                                                                                                                                • 5.6.4 拓扑排序的实现与使用
                                                                                                                                                                                                                                  • 5.6.5 实战演练
                                                                                                                                                                                                                                  • 5.7 小结
                                                                                                                                                                                                                                    • 习题5
                                                                                                                                                                                                                                    • 第6章 排序
                                                                                                                                                                                                                                      • 6.1 概述
                                                                                                                                                                                                                                        • 6.1.1 问题引入
                                                                                                                                                                                                                                          • 6.1.2 基本概念与相关知识
                                                                                                                                                                                                                                          • 6.2 冒泡排序
                                                                                                                                                                                                                                            • 6.2.1 冒泡排序的算法思想
                                                                                                                                                                                                                                              • 6.2.2 冒泡排序的排序过程
                                                                                                                                                                                                                                                • 6.2.3 冒泡排序的实现与使用
                                                                                                                                                                                                                                                  • 6.2.4 冒泡排序的性能分析
                                                                                                                                                                                                                                                    • 6.2.5 实战演练
                                                                                                                                                                                                                                                    • 6.3 选择排序
                                                                                                                                                                                                                                                      • 6.3.1 选择排序的算法思想
                                                                                                                                                                                                                                                        • 6.3.2 选择排序的排序过程
                                                                                                                                                                                                                                                          • 6.3.3 选择排序的实现与使用
                                                                                                                                                                                                                                                            • 6.3.4 选择排序的性能分析
                                                                                                                                                                                                                                                              • 6.3.5 实战演练
                                                                                                                                                                                                                                                              • 6.4 归并排序
                                                                                                                                                                                                                                                                • 6.4.1 归并排序的算法思想
                                                                                                                                                                                                                                                                  • 6.4.2 归并排序的排序过程
                                                                                                                                                                                                                                                                    • 6.4.3 归并排序的实现与使用
                                                                                                                                                                                                                                                                      • 6.4.4 归并排序的性能分析
                                                                                                                                                                                                                                                                        • 6.4.5 实战演练
                                                                                                                                                                                                                                                                        • 6.5 插入排序
                                                                                                                                                                                                                                                                          • 6.5.1 插入排序的算法思想
                                                                                                                                                                                                                                                                            • 6.5.2 插入排序的排序过程
                                                                                                                                                                                                                                                                              • 6.5.3 插入排序的实现与使用
                                                                                                                                                                                                                                                                                • 6.5.4 插入排序的性能分析
                                                                                                                                                                                                                                                                                  • 6.5.5 实战演练
                                                                                                                                                                                                                                                                                  • 6.6 快速排序
                                                                                                                                                                                                                                                                                    • 6.6.1 快速排序的算法思想
                                                                                                                                                                                                                                                                                      • 6.6.2 快速排序的排序过程
                                                                                                                                                                                                                                                                                        • 6.6.3 快速排序的实现与使用
                                                                                                                                                                                                                                                                                          • 6.6.4 快速排序的性能分析
                                                                                                                                                                                                                                                                                            • 6.6.5 实战演练
                                                                                                                                                                                                                                                                                            • 6.7 各种排序算法的比较
                                                                                                                                                                                                                                                                                              • 6.7.1 排序算法性能分析比较
                                                                                                                                                                                                                                                                                                • 6.7.2 实战演练
                                                                                                                                                                                                                                                                                                • 6.8 小结
                                                                                                                                                                                                                                                                                                  • 习题6
                                                                                                                                                                                                                                                                                                  • 第7章 查找
                                                                                                                                                                                                                                                                                                    • 7.1 概述
                                                                                                                                                                                                                                                                                                      • 7.1.1 问题引入
                                                                                                                                                                                                                                                                                                        • 7.1.2 基本概念与相关知识
                                                                                                                                                                                                                                                                                                        • 7.2 顺序查找
                                                                                                                                                                                                                                                                                                          • 7.2.1 顺序查找的算法思想及查找过程
                                                                                                                                                                                                                                                                                                            • 7.2.2 顺序查找的实现与使用
                                                                                                                                                                                                                                                                                                              • 7.2.3 顺序查找的性能分析
                                                                                                                                                                                                                                                                                                              • 7.3 折半查找
                                                                                                                                                                                                                                                                                                                • 7.3.1 折半查找的算法思想及查找过程
                                                                                                                                                                                                                                                                                                                  • 7.3.2 折半查找的实现与使用
                                                                                                                                                                                                                                                                                                                    • 7.3.3 折半查找的性能分析
                                                                                                                                                                                                                                                                                                                    • 7.4 分块查找
                                                                                                                                                                                                                                                                                                                      • 7.4.1 分块查找的算法思想及查找过程
                                                                                                                                                                                                                                                                                                                        • 7.4.2 分块查找的实现与使用
                                                                                                                                                                                                                                                                                                                          • 7.4.3 分块查找的性能分析
                                                                                                                                                                                                                                                                                                                            • 7.4.4 实战演练
                                                                                                                                                                                                                                                                                                                            • 7.5 二叉排序树查找
                                                                                                                                                                                                                                                                                                                              • 7.5.1 基本概念
                                                                                                                                                                                                                                                                                                                                • 7.5.2 二叉排序树的基本操作
                                                                                                                                                                                                                                                                                                                                  • 7.5.3 二叉排序树查找的实现与使用
                                                                                                                                                                                                                                                                                                                                    • 7.5.4 二叉排序树查找的性能分析
                                                                                                                                                                                                                                                                                                                                      • 7.5.5 Java类库中的二叉排序树
                                                                                                                                                                                                                                                                                                                                        • 7.5.6 实战演练
                                                                                                                                                                                                                                                                                                                                        • 7.6 哈希表查找
                                                                                                                                                                                                                                                                                                                                          • 7.6.1 哈希表的基本概念
                                                                                                                                                                                                                                                                                                                                            • 7.6.2 哈希函数构造方法
                                                                                                                                                                                                                                                                                                                                              • 7.6.3 处理冲突的方法
                                                                                                                                                                                                                                                                                                                                                • 7.6.4 哈希表构造方法
                                                                                                                                                                                                                                                                                                                                                  • 7.6.5 哈希表的查找算法及查找过程
                                                                                                                                                                                                                                                                                                                                                    • 7.6.6 哈希表的实现与使用
                                                                                                                                                                                                                                                                                                                                                      • 7.6.7 哈希查找的性能分析
                                                                                                                                                                                                                                                                                                                                                        • 7.6.8 Java类库中的哈希表
                                                                                                                                                                                                                                                                                                                                                          • 7.6.9 实战演练
                                                                                                                                                                                                                                                                                                                                                          • 7.7 小结
                                                                                                                                                                                                                                                                                                                                                            • 习题7
                                                                                                                                                                                                                                                                                                                                                            • 附录 Java语言工具包
                                                                                                                                                                                                                                                                                                                                                              • 附录1 容器
                                                                                                                                                                                                                                                                                                                                                                • 附录1.1 Collection接口
                                                                                                                                                                                                                                                                                                                                                                  • 附录1.2 Set接口
                                                                                                                                                                                                                                                                                                                                                                    • 附录1.3 List接口
                                                                                                                                                                                                                                                                                                                                                                      • 附录1.4 Map接口
                                                                                                                                                                                                                                                                                                                                                                        • 附录1.5 SortedSet接口
                                                                                                                                                                                                                                                                                                                                                                          • 附录1.6 SortedMap接口
                                                                                                                                                                                                                                                                                                                                                                          • 附录2 线性结构容器类
                                                                                                                                                                                                                                                                                                                                                                            • 附录2.1 Vector类
                                                                                                                                                                                                                                                                                                                                                                              • 附录2.2 ArrayList类
                                                                                                                                                                                                                                                                                                                                                                                • 附录2.3 Stack类
                                                                                                                                                                                                                                                                                                                                                                                  • 附录2.4 LinkedList类
                                                                                                                                                                                                                                                                                                                                                                                  • 附录3 非线性结构容器类
                                                                                                                                                                                                                                                                                                                                                                                    • 附录3.1 TreeMap类
                                                                                                                                                                                                                                                                                                                                                                                      • 附录3.2 TreeSet类
                                                                                                                                                                                                                                                                                                                                                                                      • 附录4 哈希容器类
                                                                                                                                                                                                                                                                                                                                                                                        • 附录4.1 HashMap类
                                                                                                                                                                                                                                                                                                                                                                                          • 附录4.2 Hashtable类
                                                                                                                                                                                                                                                                                                                                                                                            • 附录4.3 HashSet类
                                                                                                                                                                                                                                                                                                                                                                                            • 附录5 排序和查找
                                                                                                                                                                                                                                                                                                                                                                                              • 附录5.1 Arrays类
                                                                                                                                                                                                                                                                                                                                                                                                • 附录5.2 Collections类
                                                                                                                                                                                                                                                                                                                                                                                              • 参考文献

                                                                                                                                                                                                                                                                                                                                                                                              相关图书