本书用“从外向里”的方式，先介绍数据结构的性质和实际应用，再讲解如何构建数据结构。全书从应用的角度考虑对数据结构需要实现的功能及其时间效率提出要求，随后讨论如何设计并实现符合这些要求的数据结构。这种讲述方式可以使读者很容易地将所学的知识运用于实际的应用开发中，真正做到理论与实践相结合，并最终回归应用。
通过本书的学习，读者可以学会在开发中如何根据实际需要选择已有的数据结构或者设计满足特定要求的数据结构，如何利用这些数据结构实际开发应用软件，并把握所开发的应用软件的效率。
本书可作为高等院校计算机及相关专业的数据结构教材，也可供已经学过数据结构但希望更好地将其应用于实际应用开发的技术人员和专业人士阅读参考。
无
对于数据结构，有两种学习的途径。
一种是“从里向外”的途径，在学习如何把数据结构应用于解决问题之前，我们首先学习数据结构的实现，即如何构建数据结构。换句话说，从数据结构的核心开始，向外建立它在实际问题中的使用。
然而，从里向外的途径与实践中软件的构建习惯不协调。在实践中，我们是通过对象库的应用程序设计接口（API）了解对象库。在这里，“从外向里”的途径成为规范：首先，通常也仅能通过组件或对象的接口看到它们，接口刻画对象或组件的行为，因而刻画它是否适合给定的应用。也就是说，在学习如何构建一个组件之前研究它做什么。
从外向里：从价格标签接口到实现
在本书，我们对接口与数据结构的实现同样感兴趣。按着从外向里的途径展示它们，因为这样做可以使学生很容易地把课堂上所学的东西应用于实际的软件开发。下面的一系列步骤概述我们学习数据结构的途径。
1. 通过讲述数据结构的性质及其实际应用来引入数据结构。
这一步骤使学生熟悉数据结构的特征行为，为把数据和操作封装到Java类做准备。
2. 通过给出实现数据结构的Java类的公有接口来形式化这个数据结构的特征性质。
这一步骤定义可以应用于这个数据结构的一组操作，在步骤1的讨论中对这些操作进行了阐述。对于这个接口，我们还给出一个“价格标签”，即接口操作的运行时间。
价格标签是为应用软件选择数据结构过程的一个重要考虑因素。有人会说，只有在数据结构实现之后，才能确定价格标签。尽管事实的确如此，但是，实践中用于构建软件的从外向里方式通常是一些人构建数据结构，而另一些人在外部使用数据结构。负责外部工作的人员必须完全且只有依赖于接口所带来的信息。给接口附带一个价格标签是外部工作人员为手边的应用评估并选择最好对象的关键。
为了与这一方法保持一致，我们给接口附加价格标签，但是我们采用了一个有效的折中：在接口中，指定最小的实现需求，使得操作的运行时间保持在价格标签内。
我们承认这使接口与实现间的分离变得模糊。使这一分离变得模糊的另一个原因是，同一个人即学生，既工作于外部（使用数据结构）又工作于内部（构建数据结构），尽管时间不同。对于学生来说处理接口和实现分离的最好方法是，首先想像自己是对接口和价格标签有充分认知的数据结构的客户，然后，想像自己是这一数据结构的实现者，被告知构建这个数据结构的限制（价格标签）是什么。
3. 通过使用在步骤2中所给出的Java的类接口编写Java应用程序来进一步说明数据结构的用途。
这一步骤使学生明确理解如何利用公有接口已知的数据结构构建Java应用程序，但是，这时它的内部实现是隐藏的。
步骤2和步骤3强调数据结构的接口。通过反复地只使用数据结构的公有接口来构建应用程序，学生们可以获得利用组件来进行软件开发的实际感受，对组件内部的实现细节（确实可能）无需了解。
4. 设计并实现数据结构，即开发在步骤2中给出接口的Java类的代码，分析操作的运行时间，并对照价格标签验证这些运行时间。
这一步骤强调两种方式的代码复用：（a）合成：在构建或合成新的数据结构中使用前面的数据结构作为组件（Java）对象，（b）继承：通过继承前面构建的数据结构（Java类）来构建新的数据结构。
尽管我们遵循从外向里的学习途径，但是，这个“里”的部分并没有退化成使用Java集成框架中的类。相反，它与“外”的部分处于相同的立足点，理解实现细节使学生可以学习构建数据结构的方方面面，包括评估在一组候选实现中进行选择时的权衡。
以上这些步骤除提供一致的教学形式之外，还可以帮助学生理解并运用封装、接口与实现的分离以及代码复用等重要的面向对象设计原则。
Java的必备知识
本书假定学生对Java 1.5具有CS1级别的背景知识，具体范围如下：程序结构、数据类型、选择和循环的控制结构（包括if，if-else，for，while和repeat语句）以及数组。本书还假定学生熟悉广泛使用的String类。
在假定CS1级别背景的前提下，第1章是面向对象程序设计的Java导引，介绍对象和类、继承、类Object、异常、核心输入与输出特征、类包及访问控制。在输入与输出部分，描述类java.util.StringTokenizer和java.util.Scanner（对于Java 1.5是新的），并讨论它们的典型用途。
这一导引部分还特别介绍面向设计的各种特性，包括多态性、抽象类和接口。
最后一节讨论构建实用且健壮的数据结构时，不可或缺的工具：新Java 1.5的通用性。这一讨论还详述类java.util.ArrayList的设计与使用，这个类是实现容器结构或集合的非常有用的组件。
本书的使用方案
作为以基本数据结构和排序算法为主要内容的一门基础课程，在两个星期对所需的Java工具和技术的回顾或学习之后，可以讲授第1～10章，跳过10.7节（AVL树），以及第12～13章，跳过13.3节（堆排序）和13.4节（基数排序）。
作为以实验而不是讲授为主的Java课程，可以增加第11章的堆，以及第13.3和13.4节的堆排序和基数排序。
高级课程可以加入的题材包含10.7节的AVL树，及第14章和第15章的图论。在时间有限的情况下，可以不讲第15章图论算法的实现细节，第14章足以使学生熟悉图论算法。
作为两学期课程，可以讲授全书的内容，包括第1章的Java背景知识。第一个学期可以包含第1～9章，直到二叉树/普通树。第二学期包含从第10章的二叉查找树/AVL树开始的余下各章。
教学组织
·第1章和第2章的预备知识之外，每一章从学习目标的列表开始。学习目标给出本章学习内容的精确概括。
·以下面的方式给出每一章的关键点：
这些关键点在每一章结束的总结中逐条列出。
·以下面的方式给出数据结构的Java类的公用接口：
Class classname
构造器
每一个公用构造器的署名和描述
方法
每一个公用方法的运行时间（价格标签）、署名和描述
·以下面的风格给出每一个完整的Java类实现：
Class File number Class File Name
类的概况，其中可能包括若干构造器或方法。
·全书使用伪代码书写算法，提供独立于语言的过程描述。这些算法的算法头有如下形式：
算法
伪代码中所使用的记号是自行解释的。
·除第2章外，每一章以一个要点总结（Summary）列表结束，其中包括这一章中的关键点，以及其他需要记住的重要内容，包括关于Java的问题。
·除第2章外，每一章以练习和程序设计问题的形式检测学生对题材的理解程度：
·练习大部分是概念性的与语言无关的题目，特别关注对所学内容的回顾、抽象设计问题及时空分析。
·程序设计问题集中讨论Java类的构建，特别关注设计和实现中的各种选择以及代码复用。
致谢
我要忠心感谢鲁特格斯大学（Rutgers University）计算科学系的数据结构小组的成员，我同他们一起教授这门课程十余年，他们为这本书的成型提供了直接和间接的帮助。特别要感谢现在和之前的教员Diane Souvaine，Ken Kaplan，Miles Murdocca和Don Smith对本书内容进行的讨论和审阅。
感谢我的朋友和以前的研究生同僚Nathalie Japkowicz，George Katsaros和Dan Arena，他们认真地审查了最初的C++草稿，感谢Gabriela Hristescu，他在排版方面提供了帮助，感谢Sri Divakaran审查了部分Java手稿。1997年秋季数据结构课程的几位学生阅读了本书最初的全部手稿，并给出很有价值的反馈。感谢所有本书的忠实支持者，特别是Alex Chang。还要感谢2002年秋季和2003年春季的全体同学，他们指出书中的各种错误以及为鲁特格斯大学编写的早期版本中的不足之处。
还要感谢米德塞科斯县立学院（Middlesex County College）数据结构课程的教师们，以及我在朗讯技术公司工作时的前同僚，我与他们讨论本书的某些内容。特别要感谢朗讯的Tom Walsh对我的鼓励。
感谢使本书做得更好的所有审稿人员：北西雅图社区学院的Barbara Goldner，佛罗里达中央大学的Mark Llewellyn，明尼苏达大学的Chris Dovolis，亚斯兰德大学的Iyad A. Ajwa，罗切斯特理工学院的Minseok Kwon，北卡罗莱那州立大学的George Rouskas，罗切斯特理工学院的Roxanne Canosa，西伊利诺伊大学的Mary Horstman，马里兰大学大学院大学的Ray Whitney，以及伯明翰扬大学的Robert P. Burton。
Prentice Hall的编辑组在这项计划中给予我方方面面的支持。感谢我的编辑Tracy Dunkelberger，她坚信出版这本书的计划是一件有价值的事情，她令人愉快的自信使得我安心地使这本书成为现实。感谢Christianna Lee和Carole Snyder，他们引导我通过了评审过程，并友好耐心地回应我的所有问题。
Laserwords公司的John Shannon，Irwin Zucker，Camille Trentacoste和制作人员帮助改正了书中大量排印和文法上的错误，并保证页码准确无误。由于他们的努力，亲爱的读者可以远离我在这些方面的不经意的错误或疏忽。为此，我要忠心地感谢他们。
我还要深深感谢我的家人和我妻子的家人，他们给予我忠告和鼓励，当事情进展不顺利时给予我安慰。我要特别感谢我的父母和我的岳母，以及我妻子的祖父母对我自始至终的支持。尤其要感谢我的父亲C.N. Venugopal和我妻子的祖父Dr. Hayrettin Tanacan的特别参与。尽管二位平时都不接触计算机，特别是数据结构，但是他们尽心地阅读此书，设法准确理解我在这本篇幅如此长的书中讲的到底是什么。
感谢我的妻子Zehra Tulin在我写这本书期间给我各方面的帮助，更重要的是她一如既往的爱和支持。热烈拥抱我的儿子Amar，他对爸爸坚定不移的自豪永远激励着我。
最后，感谢鲁特格斯大学和米德塞科斯县立学院这么多年选修我的课的学生们。他们在我成为教育工作者的成长过程中帮助了我，我希望这本书可以作为我感激他们每一位的象征。
最后，我非常乐于听到读者对这本书的看法—你们喜欢或不喜欢什么，以及你发现的错误。你可以通过sesh_venugopal@rutgers.edu把电子邮件发给我。你的反馈将帮助我为你更好服务。
Sesh Venugopal
皮斯卡特韦，新泽西州
2006年11月
Sesh Venugopal：Sesh Venugopal :拥有拉特格大学博士学位，现为拉特格大学计算机科学系教授和本科生指导主管。他还经营自己的，T和教育咨询公司。
冯速 张青 冯丁妮：暂无简介
数据结构的研究及教学一直促进着计算机科学与技术的发展，计算机科学与技术的发展也同样影响着数据结构的研究与教学。
数据结构同时研究两个方面的内容：数据结构的设计和数据结构的使用。前者研究如何设计并实现高效、基础的数据结构，以供应用软件使用；后者则研究如何利用这些数据结构有效地实现应用软件。迄今为止的数据结构教学把重点放在数据结构的设计和实现方面，讲授基本的数据结构、如何设计并实现数据结构、如何分析数据结构的效率，并从可选的数据结构或数据结构的实现中进行选择。但总体来说，对于数据结构的使用方面，大多停留在比较浅显的程度。从数据结构的发展来看，这样做也是无可非议的。
然而，数据结构发展到今天，基本的数据结构的设计与实现已不再是高深的技术，流行语言的数据结构实现已唾手可得，人们已不能满足于了解数据结构的设计与实现，而更加渴望深入学习为什么要设计这样的数据结构、为什么要这样设计并实现数据结构，以及如何利用数据结构来更方便地设计开发应用软件。
本书就是为了满足这样的需求而产生的。本书从应用的角度考虑对数据结构需要实现的功能及其时间效率提出要求，然后考虑如何设计并实现符合要求的数据结构。通过本书的学习，读者可以学会在开发中如何根据实际需要选择已有的数据结构或者设计满足特殊要求的数据结构，如何利用这些数据结构实际开发应用软件并把握所开发的应用软件的效率。
因此，这是一本顺应计算机科学与技术的发展和数据结构教学需求的教科书，为数据结构的教学变革提供了一个选择和思路。本书可以用于数据结构的教学，也可以为那些已经学过数据结构并希望能够更好地使用数据结构的读者提供极大的帮助。
为了能够让读者更好地理解书中的内容，我们在翻译过程中对一些难懂之处进行了适当的改写，并纠正了原书中的几处错误。由于译者水平有限，难免有误译的地方，请读者指正。
译者
2007年12月
译者序
前言
第1章 Java面向对象的程序设计 1
1.1 对象与封装 1
1.1.1 对象 1
1.1.2 生存期、状态和消息 2
1.1.3 对象的客户 2
1.1.4 接口与实现的分离 2
1.2 类 2
1.2.1 状态与行为 3
1.2.2 方法重载 4
1.2.3 对象创建、构造器及垃圾回收 4
1.2.4 方法调用 7
1.2.5 静态域和静态方法 7
1.2.6 对象引用 9
1.3 继承 9
1.3.1 超类与子类 9
1.3.2 继承域与特化域 11
1.3.3 构造器 11
1.3.4 创建对象 12
1.3.5 继承方法和特化方法 12
1.3.6 方法覆盖 13
1.4 类Object 13
1.4.1 方法equals 14
1.4.2 方法toString 15
1.4.3 方法clone 15
1.5 异常 16
1.5.1 异常消息的解释 16
1.5.2 特有的错误处理 18
1.5.3 抛出异常 22
1.5.4 捕获异常 23
1.5.5 异常类 27
1.6 输入与输出 28
1.6.1 终端驱动IO 28
1.6.2 基于文件的输入与输出 29
1.6.3 字符串分解 32
1.6.4 编写异常类 33
1.7 类包 34
1.7.1 Java包 34
1.7.2 组建包 35
1.7.3 名字冲突解析 38
1.8 访问控制 39
1.8.1 私有访问 39
1.8.2 包访问 39
1.8.3 受保护访问 39
1.8.4 公有访问 40
1.8.5 一个例子 40
1.9 多态性 40
1.9.1 多态引用 41
1.9.2 提升类层次 42
1.9.3 降低类层次 42
1.9.4 instanceof操作符 43
1.10 抽象类 44
1.10.1 抽象类Shape 44
1.10.2 抽象类的性质 44
1.11 游乐园的例子 45
1.12 接口 47
1.12.1 Java接口结构 47
1.12.2 实现接口 47
1.12.3 接口作为类型 48
1.12.4 对接口的需求 48
1.12.5 扩展接口 49
1.13 通用性 49
1.13.1 把java.util.ArrayList用于集合 50
1.13.2 java.util.ArrayList的公有接口 51
1.13.3 通用类的实现 52
1.13.4 通用接口的实现 52
1.13.5 静态模板方法 54
1.14 总结 56
1.15 练习 58
1.16 程序设计问题 59
第2章 数据结构概观 62
2.1 什么是数据结构 62
2.2 我们学习什么数据结构 62
2.3 什么是抽象数据类型 64
2.4 OOP和Java在数据结构有什么优势 65
2.5 如何选择正确的数据结构 67
第3章 算法的效率 69
3.1 多项式的算术运算：一个具体
例子 69
3.2 基本操作 70
3.3 输入规模 72
3.4 函数的渐近增长 72
3.5 阶与大O 73
3.5.1 典型运行时间的阶 75
3.5.2 多变元的阶 77
3.5.3 阶的相对顺序 77
3.5.4 阶的算术运算 78
3.6 最坏情况与平均情况 78
3.7 总结 80
3.8 练习 81
第4章 无序列表 84
4.1 无序列表的性质 84
4.2 顺序搜索 85
4.2.1 平均情况分析 86
4.2.2 基于搜索模式的数据重排列 87
4.3 类List 88
4.4 使用List的类ExpenseList 89
4.4.1 类Expense的接口 89
4.4.2 类Expense 90
4.4.3 类ExpenseList的接口 91
4.4.4 类ExpenseList的实现 92
4.4.5 对象的相等与搜索 94
4.5 链表 96
4.5.1 节点的定义 97
4.5.2 插入操作 98
4.5.3 删除操作 99
4.5.4 访问操作 100
4.5.5 循环链表 100
4.6 类LinkedList 102
4.7 类List的实现 106
4.8 总结 107
4.9 练习 108
4.10 程序设计问题 109
第5章 有序列表 112
5.1 介绍 112
5.2 二分搜索 113
5.2.1 分成两半 113
5.2.2 算法 114
5.3 排序：接口java.lang.Comparable 115
5.4 类OrderedList 117
5.5 合并有序列表 119
5.6 使用OrderedList的列表归并 123
5.6.1 Merger：一个实用类 123
5.6.2 归并类 125
5.7 类OrderedList的实现 126
5.8 总结 128
5.9 练习 129
5.10 程序设计问题 131
第6章 队列 133
6.1 队列的性质 133
6.2 UNIX打印队列 134
6.3 类Queue 135
6.4 使用Queue的类PrintQueue 136
6.5 类Queue的实现 139
6.5.1 设计1：使用基于数组的存储 139
6.5.2 设计2：使用LinkedList 141
6.6 总结 142
6.7 练习 143
6.8 程序设计问题 144
第7章 栈 146
7.1 栈的性质 146
7.2 栈的应用 147
7.2.1 括号匹配 147
7.2.2 后缀表达式求值 147
7.2.3 中缀表达式到后缀表达式的
转换 149
7.3 类Stack 149
7.4 后缀表达式求值包 150
7.4.1 类PostfixEvaluator 150
7.4.2 类StatusKeeper 152
7.4.3 类StackKeeper 152
7.4.4 类PostfixEvaluator的实现 154
7.5 类Stack的实现 155
7.5.1 设计1：使用数组列表进行
存储 156
7.5.2 设计2：使用链表进行存储 156
7.6 总结 157
7.7 练习 157
7.8 程序设计问题 159
第8章 递归 161
8.1 递归定义 161
8.1.1 列表 161
8.1.2 有序列表 162
8.1.3 阶乘函数 163
8.1.4 斐波那契数列 163
8.2 递归程序与退回 164
8.2.1 计算阶乘 164
8.2.2 计算斐波那契数列 166
8.2.3 关于链表的递归 166
8.3 对数组的递归：二分搜索 168
8.4 汉诺塔：一个应用 168
8.4.1 递归定义 169
8.4.2 递归程序 170
8.5 递归与栈 171
8.6 递归的缺点 171
8.7 尾递归 172
8.8 总结 174
8.9 练习 174
8.10 程序设计问题 175
第9章 二叉树和普通树 178
9.1 二叉树的性质 178
9.1.1 组件 178
9.1.2 节点位置代表的意义 179
9.1.3 结构 180
9.1.4 递归定义 181
9.2 二叉树的遍历 182
9.3 类BinaryTree 184
9.4 二叉树的存储与重构 186
9.4.1 二叉树的署名 187
9.4.2 从二叉树的署名构建二叉树 188
9.5 赫夫曼编码 190
9.5.1 统计编码与字典编码 190
9.5.2 算法 190
9.5.3 平均代码长度和前缀性质 191
9.5.4 使用BinaryTree的类Huffman 192
9.6 类BinaryTree的实现 196
9.7 基于栈的遍历 198
9.7.1 二叉树的中序遍历 198
9.7.2 类Visitor 200
9.8 普通树 200
9.8.1 例子：大学中的组织层次 200
9.8.2 例子：UNIX文件系统 200
9.8.3 实现中的空间问题 201
9.8.4 与二叉树的对应关系 202
9.8.5 普通树的署名 203
9.9 总结 204
9.10 练习 205
9.11 程序设计问题 207
第10章 二叉查找树和AVL树 210
10.1 比较树 210
10.1.1 使用比较树的搜索时间 211
10.1.2 比较树的高度 212
10.2 二叉查找树的性质 213
10.3 二叉查找树的操作 214
10.3.1 搜索操作 214
10.3.2 插入操作 215
10.3.3 删除操作 215
10.4 类BinarySearchTree 217
10.5 使用类BinarySearchTree 218
10.5.1 例子：树排序 218
10.5.2 例子：计数关键字 219
10.6 类BinarySearchTree的实现 220
10.6.1 搜索操作的实现 220
10.6.2 插入操作的实现 220
10.6.3 删除操作的实现 221
10.6.4 便利方法与遍历 223
10.7 AVL树 223
10.7.1 AVL树结构 224
10.7.2 搜索、插入和删除操作概述 225
10.7.3 旋转操作 225
10.7.4 插入操作 226
10.7.5 删除操作 227
10.7.6 AVL树操作的运行时间 231
10.7.7 AVL插入和删除：一般化 231
10.8 二分搜索：平均比较次数 234
10.9 总结 236
10.10 练习 236
10.11 程序设计问题 239
第11章 堆 241
11.1 作为优先队列的堆 241
11.2 堆的性质 242
11.3 堆的操作 242
11.3.1 插入操作 243
11.3.2 删除操作 243
11.3.3 运行时间分析 244
11.4 类Heap 244
11.5 使用堆的优先调度 245
11.5.1 纵览 245
11.5.2 使用堆的调度包 246
11.6 使用类Heap的排序 250
11.7 类Heap的实现 251
11.7.1 数组存储 251
11.7.2 使用ArrayList的实现 253
11.8 可更新堆 254
11.8.1 设计一个可更新堆 254
11.8.2 堆项的句柄 255
11.8.3 共享句柄数组 255
11.8.4 在堆中封装句柄 255
11.8.5 循环使用空闲句柄空间 256
11.9 总结 256
11.10 练习 257
11.11 程序设计问题 258
第12章 散列表 260
12.1 动机 260
12.2 散列 261
12.3 冲突解决方案 262
12.3.1 线性探查法 262
12.3.2 二次探查法 263
12.3.3 链表法 264
12.3.4 运行时间比较 265
12.4 类java.util.HashMap 265
12.4.1 表和负载因子 266
12.4.2 项的存储 267
12.4.3 添加项 267
12.4.4 再散列过程 269
12.4.5 搜索操作 270
12.5 二次探查法：探查位置的重复 270
12.6 总结 271
12.7 练习 271
12.8 程序设计问题 272
第13章 排序 273
13.1 插入排序 273
13.2 用分治法排序 275
13.2.1 快速排序 276
13.2.2 归并排序 280
13.3 堆排序 281
13.3.1 以线性时间构建堆 281
13.3.2 排序堆 283
13.4 基数排序 283
13.5 实现：类Quicksort 285
13.6 构建堆：线性运行时间 287
13.7 总结 288
13.8 练习 288
13.9 程序设计问题 290
第14章 图I：算法 292
14.1 使用图模拟关系 292
14.1.1 无向图 292
14.1.2 有向图 293
14.1.3 加权图 295
14.2 图的表示 295
14.3 图的遍历 297
14.3.1 无向图的深度优先搜索 297
14.3.2 无向图的广度优先搜索 298
14.3.3 遍历驱动器 299
14.3.4 有向图的遍历 300
14.4 有向图的拓扑排序 301
14.4.1 偏序和全序 301
14.4.2 拓扑编号 302
14.4.3 使用深度优先搜索的拓扑
排序 302
14.4.4 使用广度优先搜索的拓扑
排序 304
14.5 无向图的连通分支 305
14.6 加权有向图中的最短路径 306
14.7 总结 311
14.8 练习 311
第15章 图II：实现 314
15.1 有向图类：DirGraph 314
15.1.1 顶点编号 315
15.1.2 类Neighbor 316
15.1.3 运用类DirGraph 317
15.2 无向图类：UndirGraph 317
15.3 深度优先搜索类：DFS 319
15.3.1 设计与接口 319
15.3.2 类Visitor 320
15.3.3 DFS的实现 321
15.4 拓扑排序类：DFSTopsort 322
15.4.1 TopVisitor：扩展类Visitor 322
15.4.2 DFSTopsort的实现 322
15.5 连通分支类：DFSConncomp 323
15.5.1 ConnVisitor：扩展类Visitor 323
15.5.2 DFSConncomp的实现 324
15.6 最短路径类：ShortestPaths 324
15.6.1 WeightedNeighbor：扩展类Neighbor 325
15.6.2 ShortestPaths的实现 325
15.7 图的实现 328
15.7.1 DirGraph的实现 328
15.7.2 类UndirGraph的实现 331
15.7.3 加权图的实现 331
15.8 总结 332
15.9 程序设计问题 332
索引 335
