前言
第一章 让你的PPT讲故事
第一节 抓住眼球的雷人主标题
一、标题=震撼力
二、三步起一个精妙的主标题
三、找到一个精妙标题的路径
第二节 用副标题点破窗户纸
一、清晰副标题的必要性
二、清晰副标题的要点
第三节 不简单的简单完整句
一、简单完整句其实不简单
二、完整你的简单句
第四节 骨灰级的PPT结构——总分总
一、第一个总：概述
二、把你的分论点制作成页标题
三、第二个总：总结
第五节 随手拈来的创意线索
一、魅力线索——被遗忘的法宝
二、线索就要这样挖 

 第二章 让你的模板与众不同 第一节 模板里的小细节与大学问 一、页面布局，功能来分类 二、结构变活，要靠概述页和章节过渡页 三、让内容页清晰完整 四、结束页要表达一颗感恩的心 第二节 省心型模板简单不“撞衫” 一、给现成模板做个整容小手术 二、让模板有些新变化

 第三章 让PPT3分钟能看懂 第一节 清晰表达你的信息 一、PPT清晰表达信息的三个层次 二、PPT清晰表达信息的三大原则 第二节 中规中矩使用字体字号 一、不同字体对号入座 二、字体的混搭要混而不杂 三、字号的中庸原则 四、线条粗细有讲究 第三节 和谐不张扬的颜色搭配 一、色彩里的哆来咪 二、留心颜色的意义

 第四章 玩转PPT的5种武器 第一节 与众不同的PPT文字风格 一、PPT行文就像课堂笔记 二、两个小窍门让文字更好用 三、小心文字里的5宗罪 第二节 横竖有理的表格表达 一、表格是PPT的天敌 二、别把Excel原样贴过来 三、循规蹈矩地做表格 四、表格不能过度图形化 五、讲述表格的4步套路 六、表格里的变形金刚 第三节 一目了然的趋势图 一、分清图中的“虚”与“实” 二、选对图的类型 三、跟着国画学画图 四、关注细节 五、讲述趋势图的6步 第四节 画龙必点睛的图片 一、一图值千言 二、图片分类有讲究 三、图片是信息的好助手 四、让图片各就各位 …… 第五节 存在必精彩的动画

 第五章 大胆Show出PPT 第一节 良好的开场白是成功演讲的一半 第二节 虎头更虎尾的完美结束 第三节 让紧张情绪见鬼去吧 后记 致谢

第1章 重构，第一个案例1
1.1 起点1
1.2 重构的第一步7
1.3 分解并重组statement()8
1.4 运用多态取代与价格相关的条件逻辑34
1.5 结语52 

 第2章 重构原则53 2.1 何谓重构53 2.2 为何重构55 2.3 何时重构57 2.4 怎么对经理说60 2.5 重构的难题62 2.6 重构与设计66 2.7 重构与性能69 2.8 重构起源何处71

 第3章 代码的坏味道75 3.1 DuplicatedCode（重复代码）76 3.2 LongMethod（过长函数）76 3.3 LargeClass（过大的类）78 3.4 LongParameterList（过长参数列）78 3.5 DivergentChange（发散式变化）79 3.6 ShotgunSurgery（霰弹式修改）80 3.7 FeatureEnvy（依恋情结）80 3.8 DataClumps（数据泥团）81 3.9 PrimitiveObsession（基本类型偏执）81 3.10 SwitchStatements（switch惊悚现身）82 3.11 ParallelInheritanceHierarchies（平行继承体系）83 3.12 LazyClass（冗赘类）83 3.13 SpeculativeGenerality（夸夸其谈未来性）83 3.14 TemporaryField（令人迷惑的暂时字段）84 3.15 MessageChains（过度耦合的消息链）84 3.16 MiddleMan（中间人）85 3.17 InappropriateIntimacy（狎昵关系）85 3.18 AlternativeClasseswithDifferentInterfaces（异曲同工的类）85 3.19 IncompleteLibraryClass（不完美的库类）86 3.20 DataClass（纯稚的数据类）86 3.21 RefusedBequest（被拒绝的遗赠）87 3.22 Comments（过多的注释）87

 第4章 构筑测试体系89 4.1 自测试代码的价值89 4.2 JUnit测试框架91 4.3 添加更多测试97

 第5章 重构列表103 5.1 重构的记录格式103 5.2 寻找引用点105 5.3 这些重构手法有多成熟106

 第6章 重新组织函数109 6.1 ExtractMethod（提炼函数）110 6.2 InlineMethod（内联函数）117 6.3 InlineTemp（内联临时变量）119 6.4 ReplaceTempwithQuery（以查询取代临时变量）120 6.5 IntroduceExplainingVariable（引入解释性变量）124 6.6 SplitTemporaryVariable（分解临时变量）128 6.7 RemoveAssignmentstoParameters（移除对参数的赋值）131 6.8 ReplaceMethodwithMethodObject（以函数对象取代函数）135 6.9 SubstituteAlgorithm（替换算法）139

 第7章 在对象之间搬移特性141 7.1 MoveMethod（搬移函数）142 7.2 MoveField（搬移字段）146 7.3 ExtractClass（提炼类）149 7.4 InlineClass（将类内联化）154 7.5 HideDelegate（隐藏“委托关系”）157 7.6 RemoveMiddleMan（移除中间人）160 7.7 IntroduceForeignMethod（引入外加函数）162 7.8 IntroduceLocalExtension（引入本地扩展）164

 第8章 重新组织数据169 8.1 SelfEncapsulateField（自封装字段）171 8.2 ReplaceDataValuewithObject（以对象取代数据值）175 8.3 ChangeValuetoReference（将值对象改为引用对象）179 8.4 ChangeReferencetoValue（将引用对象改为值对象）183 8.5 ReplaceArraywithObject（以对象取代数组）186 8.6 DuplicateObservedData（复制“被监视数据”）189 8.7 ChangeUnidirectionalAssociationtoBidirectional（将单向关联改为双向关联）197 8.8 ChangeBidirectionalAssociationtoUnidirectional（将双向关联改为单向关联）200 8.9 ReplaceMagicNumberwithSymbolicConstant（以字面常量取代魔法数）204 8.10 EncapsulateField（封装字段）206 8.11 EncapsulateCollection（封装集合）208 8.12 ReplaceRecordwithDataClass（以数据类取代记录）217 8.13 ReplaceTypeCodewithClass（以类取代类型码）218 8.14 ReplaceTypeCodewithSubclasses（以子类取代类型码）223 8.15 ReplaceTypeCodewithState/Strategy（以State/Strategy取代类型码）227 8.16 ReplaceSubclasswithFields（以字段取代子类）232

 第9章 简化条件表达式237 9.1 DecomposeConditional（分解条件表达式）238 9.2 ConsolidateConditionalExpression（合并条件表达式）240 9.3 ConsolidateDuplicateConditionalFragments（合并重复的条件片段）243 9.4 RemoveControlFlag（移除控制标记）245 9.5 ReplaceNestedConditionalwithGuardClauses（以卫语句取代嵌套条件表达式）250 9.6 ReplaceConditionalwithPolymorphism（以多态取代条件表达式）255 9.7 IntroduceNullObject（引入Null对象）260 9.8 IntroduceAssertion（引入断言）267

 第10章 简化函数调用271 10.1 RenameMethod（函数改名）273 10.2 AddParameter（添加参数）275 10.3 RemoveParameter（移除参数）277 10.4 SeparateQueryfromModifier（将查询函数和修改函数分离）279 10.5 ParameterizeMethod（令函数携带参数）283 10.6 ReplaceParameterwithExplicitMethods（以明确函数取代参数）285 10.7 PreserveWholeObject（保持对象完整）288 10.8 ReplaceParameterwithMethods（以函数取代参数）292 10.9 IntroduceParameterObject（引入参数对象）295 10.10 RemoveSettingMethod（移除设值函数）300 10.11 HideMethod（隐藏函数）303 10.12 ReplaceConstructorwithFactoryMethod（以工厂函数取代构造函数）304 10.13 EncapsulateDowncast（封装向下转型）308 10.14 ReplaceErrorCodewithException（以异常取代错误码）310 10.15 ReplaceExceptionwithTest（以测试取代异常）315

 第11章 处理概括关系319 11.1 PullUpField（字段上移）320 11.2 PullUpMethod（函数上移）322 11.3 PullUpConstructorBody（构造函数本体上移）325 11.4 PushDownMethod（函数下移）328 11.5 PushDownField（字段下移）329 11.6 ExtractSubclass（提炼子类）330 …… 第12章 大型重构359 第13章 重构，复用与现实379 第14章 重构工具401 第15章 总结409 参考书目413 要点列表417 索引419

推荐序一：设计是无言的服务 柳冠中
推荐序二：“小”是一种更伟大的关怀
新版序
初版序
第一章 日用品中的设计问题
要想弄明白操作方法．你需要获得工程学学位
日常生活中的烦恼
日用品心理学
易理解性和易使用性的设计原则
可怜的设计人员
技术进步带来的矛盾
注释 

 第二章 日常操作心理学 替设计人员代过 日常生活中的错误观念 找错怪罪对象 人类思考和解释的本质 采取行动的七个阶段 执行和评估之间的差距 行动的七阶段分析法 .注释

 第三章 头脑中的知识与外界知识 行为的精确性与知识的不精确性 记忆是储存在头脑中的知识 记忆也是储存于外界的知识 外界知识和头脑中知识之间的权衡 注释

 第四章 知道要做什么 常用限制因素的类别 预设用途和限制因素的应用 可视性和反馈 注释

 第五章 人非圣贤，孰能无过 失误 错误 日常活动的结构 有意识行为和下意识行为 与差错相关的设计原则 设计哲学 注释

 第六章 设计中的挑战 设计的自然演进 设计人员为何误入歧途 设计过程的复杂性 水龙头：设计中所遇到的种种难题 设计人员的两大致命诱惑 注释

 第七章 以用户为中心的设计 化繁为简的七个原则 故意增加操作难度 设计的社会功能 日用品的设计 注释

译者序
前言
模式列表
引言 1
0.1 架构 1
0.2 企业应用 2
0.3 企业应用的种类 3
0.4 关于性能的考虑 4
0.5 模式 6
0.5.1 模式的结构 7
0.5.2 模式的局限性 9 

 第一部分 表述 第1章 分层 12 1.1 企业应用中层次的演化 13 1.2 三个基本层次 14 1.3 为各层选择运行环境 15

 第2章 组织领域逻辑 19 2.1 抉择 22 2.2 服务层 23

 第3章 映射到关系数据库 25 .3.1 架构模式 25 3.2 行为问题 28 3.3 读取数据 29 3.4 结构映射模式 30 3.4.1 关系的映射 30 3.4.2 继承 33 3.5 建立映射 34 3.6 使用元数据 35 3.7 数据库连接 36 3.8 其他问题 38 3.9 进一步阅读 38

 第4章 Web表现层 39 4.1 视图模式 41 4.2 输入控制器模式 43 4.3 进一步阅读 43

 第5章 并发 45 5.1 并发问题 45 5.2 执行语境 46 5.3 隔离与不变性 47 5.4 乐观并发控制和悲观并发控制 48 5.4.1 避免不一致读 49 5.4.2 死锁 49 5.5 事务 50 5.5.1 ACID 51 5.5.2 事务资源 51 5.5.3 减少事务隔离以提高灵活性 52 5.5.4 业务事务和系统事务 53 5.6 离线并发控制的模式 54 5.7 应用服务器并发 55 5.8 进一步阅读 56

 第6章 会话状态 57 6.1 无状态的价值 57 6.2 会话状态 58 6.3 存储会话状态的方法 59

 第7章 分布策略 61 7.1 分布对象的诱惑 61 7.2 远程接口和本地接口 62 7.3 必须使用分布的情况 63 7.4 关于分布边界 64 7.5 分布接口 64

 第8章 通盘考虑 67 8.1 从领域层开始 67 8.2 深入到数据源层 68 8.2.1 事务脚本的数据源 68 8.2.2 表模块的数据源 69 8.2.3 领域模型的数据源 69 8.3 表现层 69 8.4 一些关于具体技术的建议 70 8.4.1 Java和J2EE 70 8.4.2 .NET 71 8.4.3 存储过程 71 8.4.4 Web Services 72 8.5 其他分层方式 72

 第二部分 模 式 第9章 领域逻辑模式 76 9.1 事务脚本（Transaction Script） 76 9.1.1 运行机制 76 9.1.2 使用时机 77 9.1.3 收入确认问题 78 9.1.4 例：收入确认（Java） 78 9.2 领域模型（Domain Model） 81 9.2.1 运行机制 81 9.2.2 使用时机 83 9.2.3 进一步阅读 83 9.2.4 例：收入确认（Java） 84 9.3 表模块（Table Module） 87 9.3.1 运行机制 88 9.3.2 使用时机 90 9.3.3 例：基于表模块的收入确认（C#） 90 9.4 服务层（Service Layer） 93 9.4.1 运行机制 94 9.4.2 使用时机 96 9.4.3 进一步阅读 96 9.4.4 例：收入确认（Java） 96

 第10章 数据源架构模式 101 10.1 表数据入口（Table Data Gateway） 101 10.1.1 运行机制 101 10.1.2 使用时机 102 10.1.3 进一步阅读 102 10.1.4 例：人员入口（C#） 103 10.1.5 例：使用ADO.NET数据集（C#） 104 10.2 行数据入口（Row Data Gateway） 106 10.2.1 运行机制 107 10.2.2 使用时机 108 10.2.3 例：人员记录（Java） 108 10.2.4 例：领域对象的数据保持器（Java） 111 10.3 活动记录（Active Record） 112 10.3.1 运行机制 112 10.3.2 使用时机 113 10.3.3 例：一个简单的Person类（Java） 113 10.4 数据映射器（Data Mapper） 115 10.4.1 运行机制 116 10.4.2 使用时机 119 10.4.3 例：一个简单的数据映射器（Java） 119 10.4.4 例：分离查找方法（Java） 123 10.4.5 例：创建一个空对象（Java） 126

 第11章 对象－关系行为模式 129 11.1 工作单元（Unit of Work） 129 11.1.1 运行机制 129 11.1.2 使用时机 133 11.1.3 例：使用对象注册的工作单元（Java） 134 11.2 标识映射（Identity Map） 137 11.2.1 运行机制 137 11.2.2 使用时机 139 11.2.3 例：标识映射中的方法（Java） 139 11.3 延迟加载（Lazy Load） 140 11.3.1 运作机制 140 11.3.2 使用时机 142 11.3.3 例：延迟初始化（Java） 142 11.3.4 例：虚代理（Java） 142 11.3.5 例：使用值保持器（Java） 144 11.3.6 例：使用重影（C#） 144

 第12章 对象－关系结构模式 151 12.1 标识域（Identity Field） 151 12.1.1 工作机制 151 12.1.2 使用时机 154 12.1.3 进一步阅读 154 12.1.4 例：整型键（C#） 154 12.1.5 例：使用键表（Java） 155 12.1.6 例：使用组合键（Java） 157 12.2 外键映射（Foreign Key Mapping） 166 12.2.1 运行机制 167 12.2.2 使用时机 169 12.2.3 例：单值引用（Java） 169 12.2.4 例：多表查询（Java） 172 12.2.5 例：引用集合（C#） 173 12.3 关联表映射（Association Table Mapping） 175 12.3.1 运行机制 176 12.3.2 使用时机 176 12.3.3 例：雇员和技能（C#） 177 12.3.4 例：使用直接的SQL（Java） 179 12.3.5 例：用一次查询查多个雇员（Java） 182 12.4 依赖映射（Dependent Mapping） 186 12.4.1 运行机制 186 12.4.2 使用时机 187 12.4.3 例：唱片和曲目（Java） 188 12.5 嵌入值（Embedded Value） 190 12.5.1 运行机制 190 12.5.2 使用时机 190 12.5.3 进一步阅读 191 12.5.4 例：简单值对象（Java） 191 12.6 序列化LOB（Serialized LOB） 192 12.6.1 运行机制 193 12.6.2 使用时机 194 12.6.3 例：在XML中序列化一个部门层级（Java） 194 12.7 单表继承（Single Table Inheritance） 196 12.7.1 运行机制 197 12.7.2 使用时机 197 12.7.3 例：运动员的单表（C#） 198 12.7.4 从数据库中加载对象 199 12.8 类表继承（Class Table Inheritance） 202 12.8.1 运行机制 202 12.8.2 使用时机 203 12.8.3 进一步阅读 203 12.8.4 例：运动员和他们的家属（C#） 203 12.9 具体表继承（Concrete Table Inheritance） 208 12.9.1 运行机制 209 12.9.2 使用时机 210 12.9.3 例：具体运动员（C#） 210 12.10 继承映射器（Inheritance Mappers） 214 12.10.1 运行机制 215 12.10.2 使用时机 216

 第13章 对象－关系元数据映射模式 217 13.1 元数据映射（Metadata Mapping） 217 13.1.1 运行机制 217 13.1.2 使用时机 218 13.1.3 例：使用元数据和反射（Java） 219 13.2 查询对象（Query Object） 224 13.2.1 运行机制 225 13.2.2 使用时机 225 13.2.3 进一步阅读 226 13.2.4 例：简单的查询对象（Java） 226 13.3 资源库（Repository） 228 13.3.1 运行机制 229 13.3.2 使用时机 230 13.3.3 进一步阅读 231 13.3.4 例：查找一个人所在的部门（Java） 231 13.3.5 例：资源库交换策略（Java） 231

 第14章 Web表现模式 233 14.1 模型－视图－控制器（Model View Controller） 233 14.1.1 运行机制 233 14.1.2 使用时机 234 14.2 页面控制器（Page Controller） 235 14.2.1 运行机制 235 14.2.2 使用时机 236 14.2.3 例：Servlet控制器和JSP视图的简单演示（Java） 236 14.2.4 例：使用JSP充当处理程序（Java） 238 14.2.5 例：代码隐藏的页面控制器（C#） 241 14.3 前端控制器（Front Controller） 243 14.3.1 运行机制 244 14.3.2 使用时机 245 14.3.3 进一步阅读 246 14.3.4 例：简单的显示（Java） 246 14.4 模板视图（Template View） 248 14.4.1 运行机制 249 14.4.2 使用时机 251 14.4.3 例：分离的控制器，使用JSP充当视图（Java） 252 14.4.4 例：ASP.NET服务器页面（C#） 253 14.5 转换视图（Transform View） 256 14.5.1 运行机制 256 14.5.2 使用时机 257 14.5.3 例：简单的转换（Java） 257 14.6 两步视图（Two Step View） 259 14.6.1 运行机制 259 14.6.2 使用时机 260 14.6.3 例：两阶XSLT（XSLT） 264 14.6.4 例：JSP和定制标记（Java） 266 14.7 应用控制器（Application Controller） 269 14.7.1 运行机制 270 14.7.2 使用时机 271 14.7.3 进一步阅读 271 14.7.4 例：状态模型应用控制器（Java） 271

 第15章 分布模式 275 15.1 远程外观（Remote Facade） 275 15.1.1 运行机制 276 15.1.2 使用时机 278 15.1.3 例：使用Java语言的会话bean来作为远程外观（Java） 278 15.1.4 例：Web Service（C#） 281 15.2 数据传输对象（Data Transfer Object） 285 15.2.1 运行机制 285 15.2.2 使用时机 288 15.2.3 进一步阅读 289 15.2.4 例：传输唱片信息（Java） 289 15.2.5 例：使用XML实现序列化（Java） 293

 第16章 离线并发模式 295 16.1 乐观离线锁（Optimistic Offline Lock） 295 16.1.1 运行机制 296 16.1.2 使用时机 298 16.1.3 例：领域层与数据映射器（Java） 298 16.2 悲观离线锁（Pessimistic Offline Lock） 302 16.2.1 运行机制 303 16.2.2 使用时机 305 16.2.3 例：简单锁管理对象（Java） 305 16.3 粗粒度锁（Coarse-Grained Lock） 310 16.3.1 运行机制 310 16.3.2 使用时机 312 16.3.3 例：共享的乐观离线锁（Java） 312 16.3.4 例：共享的悲观离线锁（Java） 316 16.3.5 例：根对象乐观离线锁（Java） 317 16.4 隐含锁（Implicit Lock） 318 16.4.1 运行机制 318 16.4.2 使用时机 319 16.4.3 例：隐含的悲观离线锁（Java） 319

 第17章 会话状态模式 321 17.1 客户会话状态（Client Session State） 321 17.1.1 运行机制 321 17.1.2 使用时机 322 17.2 服务器会话状态（Server Session State） 322 17.2.1 运行机制 322 17.2.2 使用时机 324 17.3 数据库会话状态（Database Session State） 324 17.3.1 运行机制 324 17.3.2 使用时机 325

 第18章 基本模式 327 18.1 入口（Gateway） 327 18.1.1 运行机制 327 18.1.2 使用时机 328 18.1.3 例：私有消息服务的入口（Java） 329 18.2 映射器（Mapper） 331 18.2.1 运行机制 332 18.2.2 使用时机 332 18.3 层超类型（Layer Supertype） 332 18.3.1 运行机制 332 18.3.2 使用时机 333 18.3.3 例：领域对象（Java） 333 18.4 分离接口（Separated Interface） 333 18.4.1 运行机制 334 18.4.2 使用时机 335 18.5 注册表（Registry） 335 18.5.1 运行机制 336 18.5.2 使用时机 337 18.5.3 例：单子注册表（Java） 337 18.5.4 例：线程安全的注册表（Java） 338 18.6 值对象（Value Object） 339 18.6.1 运行机制 339 18.6.2 使用时机 340 18.7 货币（Money） 340 18.7.1 运行机制 341 18.7.2 使用时机 342 18.7.3 例：货币类（Java） 343 18.8 特殊情况（Special Case） 346 18.8.1 运行机制 347 18.8.2 使用时机 347 18.8.3 进一步阅读 347 18.8.4 例：一个简单的空对象（C#） 347 18.9 插件（Plugin） 348 18.9.1 运行机制 349 18.9.2 使用时机 350 18.9.3 例：ID生成器（Java） 350 18.10 服务桩（Service Stub） 352 18.10.1 运行机制 352 18.10.2 使用时机 353 18.10.3 例：销售税服务（Java） 353 18.11 记录集（Record Set） 355 18.11.1 运行机制 355 18.11.2 使用时机 356 参考文献 359

第1章 选择市场
1 稳定成熟的技术还是未成熟的新技术?
2 供应和需求
3 只会编程是不够的
4 做团队中最差的
5 在思维上投资
6 不要听从父母
7 做一名通才
8 成为一名专家
9 切忌孤注一掷
10 热爱它，不然就离开它 

 第2章 在产品上投资 11 学习钓鱼 12 学习行业是如何运转的 13 寻找良师 14 做一名良师 15 练习，练习．再练习 16 做事的方法 17 站在巨人的肩膀上 18 在工作中，将自己自动化

 第3章 执行 19 就是现在 20 读心术 21 每日成绩 22 别忘了你在为谁工作 23 安分守己 24 今天我能把工作做到多好? 25 你的价值是多少 26 一桶水中的鹅卵石 27 爱上维护 28 8小时激情燃烧 29 学习如何失败 30 说。不 31 不要恐慌 32 说出来、行动、展示

 第4章 推销不仅仅是迎合 33 不要忽视感觉 34 探险向导 35 学会沟通，善于写作 36 到场 37 适当的言语 38 改变世界 39 让人们听到你的声音 40 创建自己的商标 41 发布你编写的程序 42 变为卓越的能力 43 建立关系

 第5章 保持技术领先 44 已经过时的技术 45 你已经失去工作了 46 没有终点的道路 47 给自己傲一份蓝图 48 要注意观察市场变化 49 镜子里的胖子 50 南印度捉猴陷阱 51 避免瀑布型职业计划 52 每天都有进步 53 独立 祝你开心 参考文献

目录（简要版）
引言
1 伟大的软件开发：让客户满意
2 收集需求：知道客户需要什么
3 项目规划：为成功而筹划
4 使用情节和任务：开始你实际的工作
5 足够好的设计：以良好的设计完成工作
6 版本控制：防御性开发
6．5 构建你的软件代码：自动化构建……
7 测试和连续集成：智者千虑必有一失
8 测试驱动开发：让代码负起责来
9 结束开发循环：涓涓细流归大海……
10 下一轮开发循环：无事就要生非
11 软件错误：专业排错
12 真实的世界：落实流程 

 目录（详实版） 引言 把你的心思放在软件开发上。此时，你们围坐在一起，准备开始学习，但你的大脑不停地告诉你，要学习的内容并不重要。你的大脑告诉你说，“最好在大脑中留一点空间，因为还有更重要的事情，就像油价要不要上涨，徒手攀登是不是一个错误的想法。”所以，你如何哄骗你的大脑去思考你的生活真地依赖于你学习怎样开发伟大的软件? 本书适合谁? 我们知道你们在想什么 元认知 让你的大脑顺从你 读我 技术审阅团队 致谢

 1 伟大的软件开发 让客户满意 如果你的客户不爽，每个人都不会爽! 软件系统中每段伟大的代码都源自客户的宏大想法。身为职业的软件开发人员，你的工作就是把这些想法付诸实现。但是，要把客户模糊不清的想法转换为可工作的软件代码——客户满意的代码，并不是一件很容易的事情。在本章中，你将学到如何通过交付满足需求、且在预计的时间和预算内的软件，避免成为软件开发战役的阵亡将士。打开你的笔记本电脑，让我们踏上交付伟大软件的征途吧! Tom’s Trail即将上线 大多数项目都有两个焦点 大霹雳式开发法 时间飞驰：两周以后 大霹雳开发法通常以一团糟结束 伟大的软件开发是…… 通过开发循环达到目标 每个开发循环是一个微型项目 每个开发循环都会产生有品质的软件 客户会请求变更 由你来进行调整 然而，有一些大的问题 开发循环自动处理变更(好啦，一点点啦) 直到软件交付，你的开发工作才算完成 软件开发工具箱

 2 收集需求 知道客户想要什么 你不能总能得到你想要的……但你的客户应该可以! 伟大的软件开发交付客户所需要的软件系统。本章的内容都将讲述与客户沟通以弄清他们对软件系统的需求。你将学会使用情节(UserStories)、头脑风暴(Brainstorming)、估计游戏(Estimationgame)如何有助于你获得客户的真实想法的。这样的话，在你完成项目之时，你就能深信你开发的软件系统就是客户所想要的，而不是一个低劣的、其他系统的仿制品。 orion’s Orbits正在进行现代化 与客户沟通，获得更多的信息 与客户共筑愿景 有时你的共筑愿景的会议可以这样…… 找出人们真正在做的事情 需求一定是面向客户的 通过客户反馈，澄清需求 使用情节定义了项目要构建什么…… 时间估计值定义了什么时候完成开发 小组交流 玩计划扑克牌的游戏 验证假设 大而不当的使用情节估计值 目标是收敛 需求与估计的反复循环 最后，你准备估计整个项目……

 3 项目规划 为成功而筹划 每段伟大的代码始于伟大的计划。 在本章，你就要学会如何创建计划。你要学会与客户一道按优先顺序排序他们的需求。你还要确定开发循环，使你和你的团队向一个方向努力。最后，你还要创建一个有可行性的开发计划，你和你的团队有信心地执行和监控该计划。到你工作完成之时，你就确切地知道如何从需求到软件的第一次交付。 客户现在就要他们的软件! 与客户一起确定优先级顺序 我们知道什么是Milestone 1.0版(好吧，可能知道) 如果功能太多，重新进行优先顺序排序 更多人力有时意味着减损绩效 找到合理的Milestone 1.0 开发循环应该简短和易行 将你的计划与真实情况作比较 时间效率值是在作估计时需要考虑的时间开销 理想国里的程序员…… 现实世界里的开发人员…… 你的开发循环何时算太长? 在你着手开发循环之前，先处理时间效率值 该进行评估了 管理爱炭脾气的客户 墙上的大白板 如何毁了团队的生活

 4 使用情节和任务 开始你实际的工作 开始去工作。使用情节抓住了你需要为客户开发什么，但现在是认真开始工作并分派所需要完成的工作的时候了，这样你才能使使用情节成为现实。在这一章里，你将学会如何将使用情节分解成任务，任务估计(Task Estimates)如何帮助你从头到尾跟踪项目。你将学会如何更新你的白板，使进行中的任务成为完成，最终完成整个使用情节。沿着这条道路，你将处理和优先顺序排序你的客户不可避免地增加给你的工作。 iSwoon简介 你的任务汇总了吗? 标注剩余的任务 把任务写在白板上 开始为任务工作 “正在进行中”表示任务正在进行 万一我同时做两件事呢? 你的第一次碰头会…… 任务1：创建：Data类 碰头会：第五天，第一周的最后一天…… 碰头会：第二周的第二天…… 在此先打断一下…… 你必须跟踪计划外的任务 意料之外的任务会让你的工作量完成情况呈上升趋势 时间效率值有帮助，但…… 我们有很多事情要做…… ……但是，我们确切地知道我们身在何处 Velocity的心声 …… 5 足够好的设计 6.1 版本控制 6.2 构建代码 7 测试和连续集成 8 测试驱动开发 9 结束开发循环 10 下一劳务出口开发循环 11 软件错误 12 真实的世界 附录

Chapter 5 Sorting 1
5.1 Combinatorial Properties of Permutations 11
5.1.1 Inversions 11
5.1.2 Permutations of a Multiset 22
5.1.3 Runs 35
5.1.4 Tableaux and Involutions 47
5.2 Internal sorting 73
5.2.1 Sorting by Insertion 80
5.2.2 Sorting by Exchanging 105
5.2.3 Sorting by Selection 138
5.2.4 Sorting by Merging 158
5.2.5 Sorting by Distribution 168
5.3 Optimum Sorting 180
5.3.1 Minimum-Comparison Sorting 180
5.3.2 Minimum-Comparison Merging 197
5.3.3 Minimum-Comparison Selection 207
5.3.4 Networks for Sorting 219
5.4 External Sorting 248
5.4.1 Multiway Merging and Replacement Selection 252
5.4.2 The Polyphase Merge 267
5.4.3 The Cascade Merge 288
5.4.4 Reading Tape Backwards 299
5.4.5 The Oscillating Sort 311
5.4.6 Practical Considerations for Tape Merging 317
5.4.7 External Radix Sorting 343
5.4.8 Two-Tape Sorting 348
5.4.9 Disks and Drums 356
5.5 Summary, History, and Bibliography 380
Chapter 6 Searching 392
6.1 Sequential Searching 396
6.2 Searching by Comparison of Keys 409
6.2.1 Searching an Ordered Table 409
6.2.2 Binary Tree Searching 426
6.2.3 Balanced Trees 458
6.2.4 Multiway Trees 481
6.3 Digital Searching 492
6.4 Hashing 513
6.5 Retrieval on Secondary Keys 559
Answers to Exercises 584
Appendix A Tables of Numerical Quantities 748
1. Fundamental Constants (decimal) 748
2. Fundamental Constants (octal) 749
3. Harmonic Numbers, Bernoulli Numbers, Fibonacci Numbers 750
Appendix B Index to Notations 752
Index and Glossary 757

前言
序
第1章 注重实效的哲学 1
1 我的源码让猫给吃了 2
2 软件的熵 3
3 石头汤与煮青蛙 5
4 足够好的软件 8
5 你的知识资产 10
6 交流 14 

 第2章 注重实效的途径 19 7 重复的危害 20 8 正交性 25 9 可撤消性 33 10 曳光弹 36 11 原型与便笺 40 12 领域语言 43 13 估算 48

 第3章 基本工具 55 14 纯文本的威力 56 15 shell游戏 60 16 强力编辑 63 17 源码控制 67 18 调试 69 19 文本操纵 77 20 代码生成器 80

 第4章 注重实效的偏执 85 21 按合约设计 86 22 死程序不说谎 95 23 断言式编程 97 24 何时使用异常 100 25 怎样配平资源 103

 第5章 弯曲，或折断 111 26 解耦与得墨忒耳法则 112 27 元程序设计 117 28 时间耦合 121 29 它只是视图 127 30 黑板 134

 第6章 当你编码时 139 31 靠巧合编程 140 32 算法速率 144 33 重构 149 34 易于测试的代码 153 35 邪恶的向导 160

 第7章 在项目开始之前 163 36 需求之坑 163 37 解开不可能解开的谜题 172 38 等你准备好 174 39 规范陷阱 176 40 圆圈与箭头 178

 第8章 注重实效的项目 181 41 注重实效的团队 181 42 无处不在的自动化 186 43 无情的测试 191 44 全都是写 200 45 极大的期望 205 46 傲慢与偏见 208

 附录A 资源 209 专业协会 209 建设藏书库 210 Internet资源 212 参考文献 221 附录B 练习解答 225 索引 249 注重实效的程序员之快速参考指南 263

第一部分 易语言的基础知识
第一章 概述
1.1 易语言概述
1.1.1 易语言简介
1.1.2 易语言的发展史
1.1.3 易语言的特点
1.2 易语言的安装
1.3 易语言的工作界面
1.3.1 易语言的界面
1.3.2 易语言的菜单栏
1.4 代码编辑环境
1.4.1 代码输入提示
1.4.2 前层提示信息
1.4.3 代码输入方式
1.4.4 参数分步输入
1.4.5 输入注释与代码屏蔽
1.4.6 易语言语句分类
1.4.7 易语言中的关键字
1.4.8 书签
1.4.9 即时帮助和帮助文档
1.5 第一个易语言程序
1.6 我的播放器(一)
1.7 小结 

 第二章 易语言编程基础 2.1 变量与常量 2.1.1 数据类型 2.1.2 变量 2.1.3 常量 2.1.4 资源表 2.2 运算符和表达式 2.2.1 运算符 2.2.2 表达式 2.2.3 赋值运算符和赋值表达式 2.3 子程序的编写与调用 2.3.1 了解子程序 2.3.2 事件子程序 2.3.3 用户自定义子程序 2.3.4 子程序的返回值 2.3.5 子程序的调用 2.3.6 子程序的参数 2.3.7 子程序的递归调用 2.4 我的播放器(二) 2.5 小结 2.6 习题

 第二部分 易语言的命令与组件 第三章 易语言的命令 3.1 了解易语言命令i 3.1.1 易语言命令概述 3.1.2 易语言命令的格式 3.1.3 易语言命令的参数 3.1.4易语言命令的返回值 3.1.5 易语言命令嵌套调用 3.1.6 数组参数与数组返回值 3.2 流程控制命令 3.2.1 了解流程控制类命令 3.2.2 分支类流程控制命令 3.2.3 循环类流程控制命令 3.2.4 跳转类流程控制命令 3.3 算术运算命令 3.3.1 基本算术运算命令及其运算符 3.3.2 扩展算术运算命令 3.4 逻辑比较 3.4.1 逻辑比较命令 3.4.2 多条件逻辑比较时的运算顺序 3.5 位运算命令 3.5.1 了解位运算 3.5.2 常用进制 3.5.3 位运算命令 3.6 数组操作命令 3.6.1 了解数组 3.6.2 数组操作命令 3.7 环境存取命令 3.8 拼音处理命令 3.9 文本操作命令 3.9.1 文字编码和存储方式 3.9.2 ASCII 3.9.3 区别键代码和文字编码 3.9.4 文本操作命令 3.10 时间操作命令 3.11 数值转换命令 3.12 字节集操作命令 3.13 磁盘操作命令 3.13.1 相关知识 3.13.2 易语言中的磁盘操作命令 3.14 文件读写命令 3.15 系统处理命令 3.15.1 了解剪辑板 3.15.2 了解注册表 3.15.3 系统处理命令 3.16 媒体播放命令 3.16.1 常见的音频格式 3.16.2 媒体播放命令 3.17网络通信命令 3.17.1 了解IP地址 3.17.2 一I解域名与主机名 3.17.3 易语言中的网络通信命令 3.18 其他命令 3.19 我的播放器(三) 3.2 0小结 3.2 1习题

 第四章 易语言组件 4.1 窗口 4.1.1 窗口的定义 4.1.2 共有属性 4.1.3 独有属性 4.1.4.共有事件 4.1.5 独有事件 4.1.6 共有命令 4.2 菜单 4.2.1 创建菜单 4.2.2 菜单的热键及属性 4.3 按钮类组件 4.3.1 按钮 4.3.2 图形按钮 4.4 列表类组件 4.4.1 组合框 4.4.2 列表框 4.4.3 选择列表框 4.5 系统类组件 4.5.1 通用对话框 4.5.2 文件框 4.5.3 目录框 4.5.4 驱动器框 4.5.5 端口 4.6 图形类组件 4.6.1 图片框 4.6.2 画板 4.6.3 颜色选择器 4.7 分组类组件 4.7.1 分组框 4.7.2 外形框 4.7.3 选择框 4.7.4 单选框 4.7.5 选择夹 4.8 位置控制类组件 4.8.1 进度条 4.8.2 滑块条 4.8.3 横向滚动条 4.8.4 纵向滚动条 4.8.5 调节器 4.9 网络与通信组件 4.9.1 客户 4.9.2 服务器 4.9.3 数据报 4.9.4 超级链接框 4.10时间类组件 4.10.1 时钟 4.10.2 月历 4.10.3 日期框 4.11显示类组件 4.11.1 编辑框 4.11.2 标签 4.11.3表格 4.11.4 打印机 4.11.5 影像框 4.12数据库类组件 4.12.1 数据库提供者 4.12.2 数据源 4.12.3 通用提供者 4.13核心库内置数据类型 4.13.1 库内置数据类型的使用 4.13.2 字体 4.13.3 打印设置信息 4.14.我的播放器(四) 4.15小结 4.16习题

 第三部分 易语言的数据库应用 第五章 易语言数据库的应用 5.1 了解易语言数据库 5.2 创建易数据库 5.2.1 使用菜单创建易数据库 5.2.2 使用代码创建易数据库 5.3 为易数据库添加记录 5.4 易数据库密码的设置 5.5 易数据库相关组件 5.5.1 易数据库相关组件分类 5.5.2 易数据库相关组件介绍 5.5.3 易数据库组件关联方法 5.6 程序界面设计与组件关联 5.6.1 易数据库程序的界面设计 5.6.2 易数据库程序的组件关联 5.7 易数据库的操作命令 5.7.1 数据库的打开与关闭 5.7.2 数据库指针的跳转命令 5.7.3 记录读取命令 5.7.4.数据源的常用命令 5.7.5 记录的添加与修改命令 5.7.6 记录的删除命令 5.7.7 复制记录与复制结构命令 5.7.8 数值统计类命令 5.7.9 记录的查找 5.7.1 0索引的创建与使用 5.8 我的播放器(五) 5.9 小结 5.1 0习题

 第六章 外部数据库的应用 6.1 外部数据库简介 6.1.1 外部数据库组件 6.1.2 ODBC与ADO 6.1.3 Access数据库 6.2 SQL语言应用 6.2.1 常用的SQL语句 6.2.2 定义数据库用户的权限 6.2.3 定义表的结构 6.2.4 数据检索 6.3 外部数据库组件 6.3.1 “外部数据提供者”组件 6.3.2 J_立用实例 6.3.3 “外部数据库”组件 6.4.数据库连接和记录集 6.4.1 应用实例 6.4.2 “数据库连接”组件 6.4.3 “记录集”组件 6.5 小结 6.6 习题

 第四部分 易语言高级应用 第七章 DLL的应用 7.1 了解DLI 7.2 编写DLI 7.3 编译DLI 7.4 调用DLI 7.5 小结 7.6 习题

 第八章 API的应用 8.1 了解API 8.2 定义API 8.3 调用API 8.3.1 调用系统API 8.3.2 调用非系统API 8.4 应用实例 8.5 小结 8.6 习题

 第九章 OCX组件与类型库 9.1 OCX组件 9.1.1 OCX组件的安装 9.1.2 OCX组件的使用 9.2 类型库 9.2.1 类型库的安装 9.2.2 类型库的使用 9.3 小结 9.4 习题

 第十章 面向对象 10.1 了解面向对象 10.1.1 类的概念 10.1.2 类的创建 10.2 类的特性 10.2.1 类的封装性 10.2.2 类的继承性 10.2.3 类的多态性 10.3 小结 10.4 习题

 第十一章 对象和COM对象 11.1 对象的应用 11.1.1 对象型变量的定义 11.1.2 “对象”数据类型 11.1.3 “变体型”数据类型 11.2 COM对象的应用 11.3 小结 11_4习题

 第十二章 易模块的应用 12.1 了解易模块 12.2 易模块的开发与编译 12.2.1 易模块的开发 12.2.2 易模块的编译 12.3 易模块的引用方法 12.4 易模块的应用实例 12.5 小结 12.6 习题

 第十三章 易语言向导 13.1 了解易语言向导 13.2 易语言向导支持库 ：13.3 易语言向导的编写 13.4.易语言向导的使用方法 13.5 小结 13.6 习题

 第十四章 程序调试 14.1 了解程序调试 14.2 运行调试 14.2.1 预编译调试 14.2.2 运行中的调试 14.3 调试命令 14.4 小结 14.5 习题

 第十五章 程序的编译与发布 15.1 编译前的配置 15.2 易语言程序的编译 ：15.2.1 易语言5.x版本的编译 15.2.2 易语言4.x版本的编译 15.3 编译生成安装软件 15.4 编译安装应用实例 15.5 小结 15.6 习题

 第五部分 易语言程序的解读和程序设计思路 第十六章 解读学校图书管理系统 16.1 软件需求分析 16.1.1 软件使用环境 16.1.2 功能需求分析 16.1.3 软件运行环境需求 16.2 解读学校图书管理系统 16.2.1 试运行程序 16.2.2 解读程序 16.3 后记

 第十七章 解读游戏——对对碰 17.1 游戏策划分析 17.1 JJ游戏策划文档实例 17.1.2 小结 17.2 解读游戏——对对碰 17.2.1 解读游戏构架 17.2.2 解读游戏逻辑 17.2.3 解读特殊块功能的实现 17.2.4 解读重绘画面 17.3 后记

第1章  数据结构绪论 1
1.1  开场白  2
如果你交给某人一个程序，你将折磨他一整天；如果你教某人如何编写程序，你将折磨他一辈子。
1.2  你数据结构怎么学的？ 3
他完成开发并测试通过后，得意地提交了代码。项目经理看完代码后拍着桌子对他说：“你数据结构是怎么学的？”
1.3  数据结构起源 4
1.4  基本概念和术语 5
正所谓“巧妇难为无米之炊”，再强大的计算机，也要有“米”下锅才可以干活，否则就是一堆破铜烂铁。这个“米”就是数据。
1.4.1  数据 5
1.4.2  数据元素 5
1.4.3  数据项 6
1.4.4  数据对象 6
1.4.5  数据结构 6
1.5  逻辑结构与物理结构 7
1.5.1  逻辑结构 7
1.5.2  物理结构 9
1.6  抽象数据类型 11
大家都需要房子住，但显然没钱考虑大房子是没有意义的。于是商品房就出现了各种各样的户型，有几百平米的别墅，也有仅两平米的胶囊公寓……
1.6.1  数据类型 11
1.6.2  抽象数据类型 12
1.7  总结回顾 14
1.8  结尾语 15
最终的结果一定是，你对着别人很牛的说“数据结构——就那么回事。” 

 第2章 算法 17 2.1 开场白 18 2.2 数据结构与算法关系 18 计算机界的前辈们，是一帮很牛很牛的人，他们使得很多看似没法解决或者很难解决的问题，变得如此美妙和神奇。 2.3 两种算法的比较 19 高斯在上小学的一天，老师要求每个学生都计算1+2+…+100的结果，谁先算出来谁先回家…… 2.4 算法定义 20 现实世界中的算法千变万化，没有通用算法可以解决所有问题。甚至一个小问题，某个解决此类问题很优秀的算法却未必就适合它。 2.5 算法的特性 21 2.5.1 输入输出 21 2.5.2 有穷性 21 2.5.3 确定性 21 2.5.4 可行性 21 2.6 算法设计的要求 22 求100个人的高考成绩平均分与求全省所有考生的成绩平均分在占用时间和内存存储上有非常大的差异，我们自然追求高效率和低存储的算法来解决问题。 2.6.1 正确性 22 2.6.2 可读性 23 2.6.3 健壮性 23 2.6.4 时间效率高和存储量低 23 2.7 算法效率的度量方法 24 随着n值越来越大，它们在时间效率上的差异也就越来越大。好比有些人每天都在学习，而另一些人，打打游戏、睡睡大觉，毕业后前者名企争着要，后者求职处处无门。 2.7.1 事后统计方法 24 2.7.2 事前分析估算方法 25 2.8 函数的渐近增长 27 2.9 算法时间复杂度 29 理解大O推导不算难，难的其实是对数列的一些相关运算，这考察的更多的是数学知识和能力。 2.9.1 算法时间复杂度定义 29 2.9.2 推导大O阶方法 30 2.9.3 常数阶 30 2.9.4 线性阶 31 2.9.5 对数阶 32 2.9.6 平方阶 32 2.10 常见的时间复杂度 35 有些时候，告诉你某些东西不可以去尝试，也是一种知识的传递。总不能非要去被毒蛇咬一口才知道蛇不可以去招惹吧。 2.11 最坏情况与平均情况 35 2.12 算法空间复杂度 36 事先建立一个有2050大的数组，然后把所有年份按下标数字对应，如果是闰年，此数组项的值就是1，如果不是就是0。这样，所谓的判断某一年是否是闰年就变成了查找这个数组的某一项的值是多少的问题。 2.13 总结回顾 37 2.14 结尾语 38 愚公移山固然可敬，但发明炸药和推土机，可能更加实在和聪明。

 第3章 线性表 41 3.1 开场白 42 门外家长都挤在大门口与门里的小孩子的井然有序，形成了鲜明对比。哎，有时大人的所作所为，其实还不如孩子。 3.2 线性表的定义 42 3.3 线性表的抽象数据类型 45 有时我们想知道某个小朋友（比如麦兜）是否是班级的同学，老师会告诉我说，没有，麦兜是在春田花花幼儿园里。这种查找某个元素是否存在的操作很常用。 3.4 线性表的顺序存储结构 47 他每次一吃完早饭就冲着去了图书馆，挑一个好地儿，把他书包里的书，一本一本的按座位放好，长长一排，九个座硬是被他占了。 3.4.1 顺序存储定义 47 3.4.2 顺序存储方式 47 3.4.3 数据长度与线性表长度区别 48 3.4.4 地址计算方法 49 3.5 顺序存储结构的插入与删除 50 春运时去买火车票，大家都排队排着好好的，这时来了一个美女：“可否让我排在你前面？”这可不得了，后面的人像蠕虫一样，全部都得退后一步。 3.5.1 获得元素操作 50 3.5.2 插入操作 51 3.5.3 删除操作 52 3.5.4 线性表顺序存储结构的优缺点 54 3.6 线性表的链式存储结构 55 反正也是要让相邻元素间留有足够余地，那干脆所有元素都不要考虑相邻位置了，哪有空位就到哪里。而只是让每个元素知道它下一个元素的位置在哪里。 3.6.1 顺序存储结构不足的解决 办法 55 3.6.2 线性表链式存储结构定义 56 3.6.3 头指针与头结点的异同 58 3.6.4 线性表链式存储结构代码描述 58 3.7 单链表的读取 60 3.8 单链表的插入与删除 61 本来是爸爸左牵着妈妈的手、右牵着宝宝的手在马路边散步。突然迎面走来一美女，爸爸失神般地望着，此情景被妈妈逮个正着，于是扯开父子俩，拉起宝宝的左手就快步朝前走去。 3.8.1 单链表的插入 61 3.8.2 单链表的删除 64 3.9 单链表的整表创建 66 3.10 单链表的整表删除 69 3.11 单链表结构与顺序存储结构优缺点 70 3.12 静态链表 71 对于一些语言，如Basic、Fortran等早期的编程高级语言，由于没有指针，这链表结构，按照前面我们的讲法，它就没法实现了。怎么办呢？ 3.12.1 静态链表的插入操作 73 3.12.2 静态链表的删除操作 75 3.12.3 静态链表优缺点 77 3.13 循环链表 78 这个轮回的思想很有意思。它强调了不管你今生是穷是富，如果持续行善积德，下辈子就会好过，反之就会遭到报应。 3.14 双向链表 81 就像每个人的人生一样，欲收获就得付代价。双向链表既然是比单链表多了如可以反向遍历查找等的数据结构，那么也就需要付出一些小的代价。 3.15 总结回顾 84 3.16 结尾语 85 如果你觉得上学读书是受罪，假设你可以活到80岁，其实你最多也就吃了20年苦。用人生四分之一的时间来换取其余时间的幸福生活，这点苦不算啥。

 第4章 栈与队列 87 4.1 开场白 88 想想看，在你准备用枪的时候，突然这手枪明明有子弹却打不出来，这不是要命吗。 4.2 栈的定义 89 类似的很多软件，比如Word、Photoshop等，都有撤消（undo）的操作，也是用栈这种思想方式来实现的。 4.2.1 栈的定义 89 4.2.2 进栈出栈变化形式 90 4.3 栈的抽象数据类型 91 4.4 栈的顺序存储结构及实现 92 4.4.1 栈的顺序存储结构 92 4.4.2 栈的顺序存储结构进栈操作 93 4.4.3 栈的顺序存储结构出栈操作 94 4.5 两栈共享空间 94 两个大学室友毕业同时到北京工作，他们都希望租房时能找到独自住的一室户或一室一厅，可找来找去发现，实在是承受不起。 4.6 栈的链式存储结构及实现 97 4.6.1 栈的链式存储结构 97 4.6.2 栈的链式存储结构进栈操作 98 4.6.3 栈的链式存储结构出栈操作 99 4.7 栈的作用 100 4.8 栈的应用——递归 100 当你往镜子前面一站，镜子里面就有一个你的像。但你试过两面镜子一起照吗？如果A、B两面镜子相互面对面放着，你往中间一站，嘿，两面镜子里都有你的千百个“化身”。 4.8.1 斐波那契数列实现 101 4.8.2 递归定义 103 4.9 栈的应用——四则运算表达式求值 104 4.9.1 后缀（逆波兰）表示法定义 104 4.9.2 后缀表达式计算结果 106 4.9.3 中缀表达式转后缀表达式 108 4.10 队列的定义 111 电脑有时会处于疑似死机的状态。就当你失去耐心，打算了Reset时。突然它像酒醒了一样，把你刚才点击的所有操作全部都按顺序执行了一遍。 4.11 队列的抽象数据类型 112 4.12 循环队列 113 你上了公交车发现前排有两个空座位，而后排所有座位都已经坐满，你会怎么做？立马下车，并对自己说，后面没座了，我等下一辆？没这么笨的人，前面有座位，当然也是可以坐的。 4.12.1 队列顺序存储的不足 112 4.12.2 循环队列定义 114 4.13 队列的链式存储结构及实现 117 4.13.1 队列链式存储结构入队操作118 4.13.2 队列链式存储结构出队操作 119 4.14 总结回顾 120 4.15 结尾语 121 人生，需要有队列精神的体现。南极到北极，不过是南纬90度到北纬90度的队列，如果你中途犹豫，临时转向，也许你就只能和企鹅相伴永远。可事实上，无论哪个方向，只要你坚持到底，你都可以到达终点。

 第5章 串 123 5.1 开场白 124 “枯眼望遥山隔水，往来曾见几心知？壶空怕酌一杯酒，笔下难成和韵诗。途路阻人离别久，讯音无雁寄回迟。孤灯夜守长寥寂，夫忆妻兮父忆儿。”……可再仔细一读发现，这首诗竟然可以倒过来读。 5.2 串的定义 124 我所提到的“over”、“end”、“lie”其实就是“lover”、“friend”、“believe”这些单词字符串的子串。 5.3 串的比较 126 5.4 串的抽象数据类型 127 5.5 串的存储结构 128 感情上发生了问题，为了向女友解释一下，我准备发一条短信，一共打了75个字。最后八个字是“我恨你是不可能的”，点发送。后来得知对方收到的，只有70个字，短信结尾是“……我恨你”。 5.5.1 串的顺序存储结构 129 5.5.2 串的链式存储结构 131 5.6 朴素的模式匹配算法 131 主串为S=”00000000000000000000000000000000000000000000000001”，而要匹配的子串为T=”0000000001”，……在匹配时，每次都得将T中字符循环到最后一位才发现，哦，原来它们是不匹配的。 5.7 KMP模式匹配算法 135 很多年前我们的科学家觉得像这种有多个0和1重复字符的字符串，却需要挨个遍历的算法，是非常糟糕的事情。 5.7.1 KMP模式匹配算法原理 135 5.7.2 next数组值推导 139 5.7.3 KMP模式匹配算法实现 141 5.7.4 KMP模式匹配算法改进 142 5.7.5 nextval数组值推导 144 5.8 总结回顾 146 5.9 结尾语 146 《璇玑图》共八百四十字，纵横各二十九字，纵、横、斜、交互、正、反读或退一字、迭一字读均可成诗，诗有三、四、五、六、七言不等，目前有人统计可组成七千九百五十八首诗。听清楚哦，是7958首。

 第6章 树 149 6.1 开场白 150 无论多高多大的树，那也是从小到大的，由根到叶，一点点成长起来的。俗话说十年树木，百年树人，可一棵大树又何止是十年这样容易。 6.2 树的定义 150 树的定义其实就是我们在讲解栈时提到的递归的方法。也就是在树的定义之中还用到了树的概念，这是比较新的一种定义方法。 6.2.1 结点分类 152 6.2.2 结点间关系 152 6.2.3 树的其他相关概念 153 6.3 树的抽象数据类型 154 6.4 树的存储结构 155 6.4.1 双亲表示法 155 6.4.2 孩子表示法 158 6.4.3 孩子兄弟表示法 162 6.5 二叉树的定义 163 苏东坡曾说：“人有悲欢离合，月有阴晴圆缺，此事古难全”。意思就是完美是理想，不完美才是人生。我们通常举的例子也都是左高右低、参差不齐的二叉树。那是否存在完美的二叉树呢？ 6.5.1 二叉树特点 164 6.5.2 特殊二叉树 166 6.6 二叉树的性质 169 6.6.1 二叉树性质1 169 6.6.2 二叉树性质2 169 6.6.3 二叉树性质3 169 6.6.4 二叉树性质4 170 6.6.5 二叉树性质5 171 6.7 二叉树的存储结构 172