This page intentionally left blank
✐
✐
“main” — 2011/1/13 — 9:10 — page i — #1
✐
✐
✐
✐
✐
✐
Data Structures and
A
lgorithms in C
++
Second Edition
This page intentionally left blank
✐
✐
“main” — 2011/1/13 — 9:10 — page iii — #3
✐
✐
✐
✐
✐
✐
Data Structures and
A
lgorithms in C
++
Second Edition

A
T
E
X by the authors and printed and bound by Malloy Lithographers.
The cover was printed by Malloy Lithographers. The cover image is from Wuta Wuta Tjan-
gala, “Emu dreaming”
c
 estate of the artist 2009 licensed by Aboriginal Artists Agency.
Jennifer Steele/Art Resource, NY.
This book is printed on acid free paper. ∞
Trademark Acknowledgments: Java is a trademark of Sun Microsystems, Inc. UNIX
R

is
a registered trademark in the U nited States and other countries, licensed through X/Open
Company, Ltd. PowerPoint
R

is a trademark of Microsoft Co rporation. All other product
names mentioned herein are the trademarks of their respective owners.
Copyright
c
 2011, John Wiley & Sons, Inc. All rights reserved.
No part of this publication may be reproduced, stored in a retrieval system or transmitted
in any form or by any means, electronic, mechanical, photocopying, recording, scanning
or otherwise, except as permitted under Sections 107 or 108 of the 1976 United States
Copyright Act, without either the prior written permission of the Publisher, or authorization
through payment of the appropriate per-copy fee to the Copyright Clearance Center, Inc.
222 Rosewood Drive, Danvers, MA 01923, (978)750-8400, fax (978)646-8600.
Requests to the Publisher for permission should be addressed to the Permissions Depart-

To Jeanine
– David M. Mount
This page intentionally left blank
✐
✐
“main” — 2011/1/13 — 9:10 — page vii — #7
✐
✐
✐
✐
✐
✐
Preface
T
his second edition of Data Structures and Algorithms in C++ is designed to pro-
vide an introduction to data structures and algorithms, including their design, analy-
sis, and implementation. In terms of curricula based on the IEEE/ACM 2001 Com-
puting Curriculum, this book is appropriate for use in the courses CS102 (I/O/B
versions), CS103 (I/O/B versions), CS111 (A version), and CS112 (A/I/O/F/H ver-
sions). We discuss its use for such courses in more detail later in this preface.
The major changes in the second edition are the following:
• We added more examples of data structure and algorithm analysi
s.
• We enhanced consistency with the C++ Standard Template Library (STL).
• We incorporated STL data structures into many of our data structures.
• We added a chapter on arrays, linked lists, and iterators (Chapter 3).
• We added a chapter on memory management and B-trees (Chapter 14).
• We enhanced the discussion of algorithmic design techniques, like dynamic
programming and the greedy method.
• We simplified and reorganized the presentation of code fragments.

✐
✐
✐
viii
Preface
and deallocation (and the associated issues of destructors), virtual functions, stream
input and output, operator overloading, and C++’s safe run-time casting.
Use as a Textbook
T
he design and analysis of efficient data structures has long been recognized as a
vital subject in computing, because the study of data structures is part of the core
of every collegiate computer science and computer engineering major program we
are familiar with. Typically, the introductory courses are presented as a two- or
three-course sequence. Elementary data structures are often briefly introduced in
the first programming course or in an introduction to computer science course and
this is followed by a more in-depth introduction to data structures in the courses that
follow after this. Furthermore, this course sequence is typically followed at a later
point in the curriculum by a more in-depth study of data structures and algorithms.
We feel that the central role of data structure design and analysis in the curriculum
is fully justified, given the importance of efficient data structures in most software
systems, including the Web, operating systems, databases, compilers, and scientific
simulation systems.
With the emergence of the object-oriented paradigm as the framework of choice
for building robust and reusable software, we have tried to take a consistent object-
oriented viewpoint throughout this text. One of the main ideas behind the object-
oriented approach is that data should be presented as being encapsulated with the
methods that access and modify them. That is, rather than simply viewing data
as a collection of bytes and addresses, we think of data objects as instances of an
abstract data type (ADT), which includes a repertoire of methods for performing
operations on data objects of this type. Likewise, object-oriented solutions are often

Included on this Web site is a collection of educational aids th
at augment the
topics of this book, for both students and instructors. Students are encouraged to
use this site along with the book, to help with exercises and increase understand-
ing of the subject. Instructors are likewise welcome to use the site to help plan,
organize, and present their course materials. Because of their added value, some of
these online resources are password protected.
For the Student
For all readers, and especially for students, we include the following resources:
• All the C++ source code presented in this book.
• PDF handouts of Powerpoint slides (four-per-page) provided to instructors.
• A database of hints to all exercises, indexed by problem number.
• An online study guide, which includes solutions to selected exercises.
The hints should be of considerable use to anyone needing a little help getting
started on certain exercises, and the solutions should help anyone wishing to see
completed exercises. Students who have purchased a new copy of this book will
get password access to the hints and other password-protected online resources at
no extra charge. Other readers can purchase password access for a nominal fee.
For the Instructor
For instructors using this book, we include the following addi
tional teaching aids:
• Solutions to over 200 of the book’s exercises.
• A database of additional exercises, suitable for quizes and exams.
• Additional C++ source code.
• Slides in Powerpoint and PDF (one-per-page) format.
• Self-contained, special-topic supplements, including discussions on convex
hulls, range trees, and orthogonal segment intersection.
The slides are fully editable, so as to allow an instructor using this book full free-
dom in customizing his or her presentations. All the online resources are provided
at no extra charge to any instructor adopting this book for his or her course.

7
.3.7, 8.1.2, and 13.3.1
PF1. Fundamental Programming Constructs Chapters 1 and 2
PF2. Algorithms and Problem-Solving Sections 1.7 and 4.2
PF3. Fundamental Data Structures Sections 3.1, 3.2, 5.1–5.3, 6.1–6.3, 7.1,
7
.3, 8.1, 8.3, 9.1–9.4, 10.1, and 13.1.1
PF4. Recursion Section 3.5
SE1. Software Design Chapter 2 and Sections 6.2.1, 7.3.7,
8
.1.2, and 13.3.1
SE2. Using APIs Sections 2.2.5, 5.1–5.3, 6.1.1, 6.2.1, 6.3,
7
.1, 7.3.1, 8.1, 9.1, 9.5, 11.4, and 13.1.1
AL1. Basic Algorithmic Analysis Chapter 4
AL2. Algorithmic Strategies Sections 11.1.1, 11.5.1, 12.2, 12.3.1, and
1
2.4.2
AL3. Fundamental Computing Algorithms Sections 8.1.5, 8.2.2, 8.3.5, 9.2, and
9
.3.1, and Chapters 11, 12, and 13
DS1. Functions, Relations, and Sets Sections 4.1, 8.1, and 11.4
DS3. Proof Techniques Sections 4.3, 6.1.3, 7.3.3, 8.3, 10.2–10.5,
1
1.2.1, 11.3.1, 11.4.3, 13.1.1, 13.3.1,
13.4, and 13.5
DS4. Basics of Counting Sections 2.2.3 and 11.1.5
DS5. Graphs and Trees Chapters 7, 8, 10, and 13
DS6. Discrete Probability Appendix A and Sections 9.2, 9.4.2,
1

6. List and Iterator ADTs
7. Trees
8. Heaps and Priority Queues
9. Hash Tables, Maps, and Skip Lists
10. Search Trees
11. Sorting, Sets, and Selection
12. Strings and Dynamic Programming
13. Graph Algorithms
14. Memory Management and B-Trees
A. Useful Mathematical Facts
A more detailed listing of the contents of this book can be found
in the table of
contents.
✐
✐
“main” — 2011/1/13 — 9:10 — page xii — #12
✐
✐
✐
✐
✐
✐
xii
Preface
Prerequisites
W
e have written this book assuming that the reader comes to it with certain knowl-
edge. We assume that the reader is at least vaguely familiar with a high-level pro-
gramming language, such as C, C++, Python, or Java, and that he or she understands
the main constructs from such a high-level language, including:

science theory, computational geometry, and graph algorithms. He is an ACM Dis-
tinguished Scientist, a Fellow of the American Association for the Advancement of
Science (AAAS), a Fulbright Scholar, and a Fellow of the IEEE. He is a recipient of
the IEEE Computer Society Technical Achievement Award, the ACM Recognition
of Service Award, and the Pond Award for Excellence in Undergraduate Teaching.
✐
✐
“main” — 2011/1/13 — 9:10 — page xiii — #13
✐
✐
✐
✐
✐
✐
Preface
xiii
Roberto Tamassia received his Ph.D. in Electrical and Computer Engineering
from the University of Illinois at Urbana-Champaign in 1988. He is the Plastech
Professor of Computer Science and the Chair of the Department of Computer Sci-
ence at Brown University. He is also the Director of Brown’s Center for Geometric
Computing. His research interests include information security, cryptography, anal-
ysis, design, and implementation of algorithms, graph drawing, and computational
geometry. He is an IEEE Fellow and a recipient of the Technical Achievement
Award from the IEEE Computer Society for pioneering the field of graph drawing.
He is an editor of several journals in geometric and graph algorithms. He previously
served on the editorial board of IEEE Transactions on Computers.
David Mount received his Ph.D. in Computer Science from Purdue University
in 1983. He is currently a professor in the Department of Computer Science at
the University of Maryland with a joint appointment in the University of Mary-
land’s Institute for Advanced Computer Studies. He is an associate editor for ACM

✐
✐
✐
✐
✐
xiv
Preface
We are also grateful to Karen Goodrich, Art Moorshead, Scott Smith, and Ioannis
Tollis for their insightful comments.
We are also truly indebted to the outside reviewers and readers for their co-
pious comments, emails, and constructive criticism, which were extremely use-
ful in writing this edition. We specifically thank the following reviewers for their
comments and suggestions: Divy Agarwal, University of California, Santa Bar-
bara; Terry Andres, University of Manitoba; Bobby Blumofe, University of Texas,
Austin; Michael Clancy, University of California, Berkeley; Larry Davis, Univer-
sity of Maryland; Scott Drysdale, Dartmouth College; Arup Guha, University of
Central Florida; Chris Ingram, University of Waterloo; Stan Kwasny, Washington
University; Calvin Lin, University of Texas at Austin; John Mark Mercer, McGill
University; Laurent Michel, University of Connecticut; Leonard Myers, California
Polytechnic State University, San Luis Obispo; David Naumann, Stevens Institute
of Technology; Robert Pastel, Michigan Technological University; Bina Rama-
murthy, SUNY Buffalo; Ken Slonneger, University of Iowa; C.V. Ravishankar,
University of Michigan; Val Tannen, University of Pennsylvania; Paul Van Ar-
ragon, Messiah College; and Christopher Wilson, University of Oregon.
We are grateful to our editor, Beth Golub, for her enthusiastic support of this
project. The team at Wiley has been great. Many thanks go to Mike Berlin, Lil-
ian Brady, Regina Brooks, Paul Crockett, Richard DeLorenzo, Jen Devine, Simon
Durkin, Micheline Frederick, Lisa Gee, Katherine Hepburn, Rachael Leblond, An-
dre Legaspi, Madelyn Lesure, Frank Lyman, Hope Miller, Bridget Morrisey, Chris
Ruel, Ken Santor, Lauren Sapira, Dan Sayre, Diana Smith, Bruce Spatz, Dawn

1.1 Basic C++ Programming Elements . . . . . . . . . . . . . . . 2
1.1.1 A Simple C++ Program . . . . . . . . . . . . . . . . . . 2
1.1.2 Fundamental Types . . . . . . . . . . . . . . . . . . . . 4
1.1.3 Pointers, Arrays, and Structures . . . . . . . . . . . . . 7
1.1.4 Named Constants, Scope, and Namespaces . . . . . . . 13
1.2 Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.2.1 Changing Types through Casting . . . . . . . . . . . . . 20
1.3 Control Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.4.1 Argument Passing . . . . . . . . . . . . . . . . . . . . . 28
1.4.2 Overloading and Inlining . . . . . . . . . . . . . . . . . 30
1.5 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.5.1 Class Structure . . . . . . . . . . . . . . . . . . . . . . 33
1.5.2 Constructors and Destructors . . . . . . . . . . . . . . . 37
1.5.3 Classes and Memory Allocation . . . . . . . . . . . . . . 40
1.5.4 Class Friends and Class Members . . . . . . . . . . . . . 43
1.5.5 The Standard Template Library . . . . . . . . . . . . . . 45
1.6 C++ Program and File Organization . . . . . . . . . . . . . . 47
1.6.1 An Example Program . . . . . . . . . . . . . . . . . . . 48
1.7 Writing a C++ Program . . . . . . . . . . . . . . . . . . . . . 53
1.7.1 Design . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
1.7.2 Pseudo-Code . . . . . . . . . . . . . . . . . . . . . . . 54
1.7.3 Coding . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
1.7.4 Testing and Debugging . . . . . . . . . . . . . . . . . . 57
1.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
2 Object-Oriented Design 65
2.1 Goals, Principles, and Patterns . .
. . . . . . . . . . . . . . 66
2.1.1 Object-Oriented Design Goals . . . . . . . . . . . . . . 66
2.1.2 Object-Oriented Design Principles . . . . . . . . . . . . 67

3.1.1 Storing Game Entries i n an Array . . . . . . . . . . . . . 104
3.1.2 Sorting an Array . . . . . . . . . . . . . . . . . . . . . . 109
3.1.3 Two-Dimensional Arrays and Positional Games . . . . . 111
3.2 Singly Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . 117
3.2.1 Implementing a S ingly Linked List . . . . . . . . . . . . 117
3.2.2 Insertion to the Front of a Singly Linked Lis t . . . . . . 119
3.2.3 Removal from the Front of a Singly Linked List . . . . . 119
3.2.4 Implementing a Generic Singly Linked List . . . . . . . . 121
3.3 Doubly Linked Lists . . . . . . . . . . . . . . . . . . . . . . . 123
3.3.1 Insertion into a Doubly Linked List . . . . . . . . . . . . 123
3.3.2 Removal from a Doubly Linked List . . . . . . . . . . . 124
3.3.3 A C++ Implementation . . . . . . . . . . . . . . . . . . 125
3.4 Circularly Linked Lists a nd List Reversal . . . . . . . . . . . 129
3.4.1 Circularly Linked Lists . . . . . . . . . . . . . . . . . . . 129
3.4.2 Reversing a Linked Lis t . . . . . . . . . . . . . . . . . . 133
3.5 Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
3.5.1 Linear Recursion . . . . . . . . . . . . . . . . . . . . . . 140
3.5.2 Binary Recursion . . . . . . . . . . . . . . . . . . . . . 144
3.5.3 Multiple Recursion . . . . . . . . . . . . . . . . . . . . 147
3.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
4 Analysis Tools 153
4.1 The Seven Functions Used in This Book . .
. . . . . . . . . 154
4.1.1 The Constant Function . . . . . . . . . . . . . . . . . . 154
4.1.2 The Logarithm Function . . . . . . . . . . . . . . . . . 154
✐
✐
“main” — 2011/1/13 — 9:10 — page xvii — #17
✐
✐

5.1.3 A C++ Stack Interface . . . . . . . . . . . . . . . . . . 196
5.1.4 A Simple Array-Based Stack Implementation . . . . . . 198
5.1.5 Implementing a S tack with a Generic Linked List . . . . 202
5.1.6 Reversing a Vector Using a Stack . . . . . . . . . . . . . 203
5.1.7 Matching Parentheses and HTML Tags . . . . . . . . . 204
5.2 Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
5.2.1 The Queue Abs tract Data Ty pe . . . . . . . . . . . . . 208
5.2.2 The STL Queue . . . . . . . . . . . . . . . . . . . . . . 209
5.2.3 A C++ Queue Interface . . . . . . . . . . . . . . . . . . 210
5.2.4 A Simple Array-Based Implementation . . . . . . . . . . 211
5.2.5 Implementing a Queue with a Circularly Linked List . . . 213
5.3 Double-Ended Queues . . . . . . . . . . . . . . . . . . . . . . 217
5.3.1 The Deque Abstract Data Type . . . . . . . . . . . . . 217
5.3.2 The STL Deque . . . . . . . . . . . . . . . . . . . . . . 218
5.3.3 Implementing a Deque with a Doubly Linked List . . . . 218
5.3.4 Adapters and the Adapter Design Pattern . . . . . . . . 220
5.4 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
✐
✐
“main” — 2011/1/13 — 9:10 — page xviii — #18
✐
✐
✐
✐
✐
✐
xviii
Contents
6 List and Iterator ADTs 227
6.1 Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

7.3.1 The Binary Tree ADT . . . . . . . . . . . . . . . . . . . 285
7.3.2 A C++ Binary Tree Interface . . . . . . . . . . . . . . . 286
7.3.3 Properties of Binary Trees . . . . . . . . . . . . . . . . 287
7.3.4 A Linked Structure for Binary Trees . . . . . . . . . . . 289
7.3.5 A Vector-Based Structure for Binary Trees . . . . . . . . 295
7.3.6 Traversals of a Binary Tree . . . . . . . . . . . . . . . . 297
7.3.7 The Template Function Pattern . . . . . . . . . . . . . 303
7.3.8 Representing General Trees with Binary Trees . . . . . . 309
7.4 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
✐
✐
“main” — 2011/1/13 — 9:10 — page xix — #19
✐
✐
✐
✐
✐
✐
Contents
xix
8 Heaps and Priority Queues 321
8.1 The Priority Queue Abstract Data Type . . . . . . . . . . . 322
8.1.1 Keys, Priorities, and Total Order Relations . . . . . . . . 322
8.1.2 Comparators . . . . . . . . . . . . . . . . . . . . . . . . 324
8.1.3 The Priority Queue ADT . . . . . . . . . . . . . . . . . 327
8.1.4 A C++ Priority Queue Interface . . . . . . . . . . . . . . 328
8.1.5 Sorting with a Priority Queue . . . . . . . . . . . . . . . 329
8.1.6 The STL priority
queue Class . . . . . . . . . . . . . . . 3
30

9.3.1 Ordered Search Tables and Binary Search . . . . . . . . 395
9.3.2 Two Applications of Ordered Maps . . . . . . . . . . . . 399
9.4 Skip Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
✐
✐
“main” — 2011/1/13 — 9:10 — page xx — #20
✐
✐
✐
✐
✐
✐
xx
Contents
9.4.1 Search and Update Operations in a Skip List . . . . . . 404
9.4.2 A Probabilistic Analysis of Skip Lists ⋆ . . . . . . . . . 408
9.5 Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
9.5.1 The Dictionary ADT . . . . . . . . . . . . . . . . . . . 411
9.5.2 A C++ Dictionary Implementation . . . . . . . . . . . . 413
9.5.3 Implementations with Location-Aware Entries . . . . . . 415
9.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
10 Search Trees 423
10.1 Binary Search Trees . .
. . . . . . . . . . . . . . . . . . . . . 424
10.1.1 Searching . . . . . . . . . . . . . . . . . . . . . . . . . 426
10.1.2 Update Operations . . . . . . . . . . . . . . . . . . . . 428
10.1.3 C++ Implementation of a Binary Search Tree . . . . . . 432
10.2 AVL Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
10.2.1 Update Operations . . . . . . . . . . . . . . . . . . . . 440
10.2.2 C++ Implementation of an AVL Tree . . . . . . . . . . . 446

✐
✐
✐
✐
✐
Contents
xxi
11.4 Sets and Union/Find Structures . . . . . . . . . . . . . . . . 533
11.4.1 The Set A DT . . . . . . . . . . . . . . . . . . . . . . . 533
11.4.2 Mergable Sets and the Template Method Pattern . . . . 534
11.4.3 Partitions with Union-Find Operations . . . . . . . . . . 538
11.5 Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
11.5.1 Prune-and-Search . . . . . . . . . . . . . . . . . . . . . 542
11.5.2 Randomized Quick-Select . . . . . . . . . . . . . . . . . 543
11.5.3 Analyzing Randomized Quick-Select . . . . . . . . . . . 544
11.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
12 Strings and Dynamic Programming 553
12.1 St ring Operations . .
. . . . . . . . . . . . . . . . . . . . . . 554
12.1.1 The STL String Class . . . . . . . . . . . . . . . . . . . 555
12.2 Dynamic Programming . . . . . . . . . . . . . . . . . . . . . 557
12.2.1 Matrix Chain-Product . . . . . . . . . . . . . . . . . . . 557
12.2.2 DNA and Text Sequence Alignment . . . . . . . . . . . 560
12.3 Pattern Matching Algorithms . . . . . . . . . . . . . . . . . 564
12.3.1 Brute Force . . . . . . . . . . . . . . . . . . . . . . . . 564
12.3.2 The Boyer-Moore Algorithm . . . . . . . . . . . . . . . 566
12.3.3 The Knuth-Morris-Pratt Algorithm . . . . . . . . . . . . 570
12.4 Text Compression and the Greedy Method . . . . . . . . . 575
12.4.1 The Huffman-Coding Algorithm . . . . . . . . . . . . . 576
12.4.2 The Greedy Method . . . . . . . . . . . . . . . . . . . . 577

Contents
13.3.5 Breadth-First Search . . . . . . . . . . . . . . . . . . . 623
13.4 Directed Graphs . . . . . . . . . . . . . . . . . . . . . . . . . 626
13.4.1 Traversing a Digraph . . . . . . . . . . . . . . . . . . . 628
13.4.2 Transitive Closure . . . . . . . . . . . . . . . . . . . . . 630
13.4.3 Directed Acyclic Graphs . . . . . . . . . . . . . . . . . . 633
13.5 Shortest Paths . . . . . . . . . . . . . . . . . . . . . . . . . . 637
13.5.1 Weighted Graphs . . . . . . . . . . . . . . . . . . . . . 637
13.5.2 Dijkstra’s Algorithm . . . . . . . . . . . . . . . . . . . . 639
13.6 Minimum Spanning Trees . . . . . . . . . . . . . . . . . . . . 645
13.6.1 Kruskal’s Algorithm . . . . . . . . . . . . . . . . . . . . 647
13.6.2 The Prim-Jarn´ık Algorithm . . . . . . . . . . . . . . . . 651
13.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654
14 Memory M anagement and B-Trees 665
14.1 Memory Management . .
. . . . . . . . . . . . . . . . . . . . 666
14.1.1 Memory Allocation in C++ . . . . . . . . . . . . . . . . 669
14.1.2 Garbage Collection . . . . . . . . . . . . . . . . . . . . 671
14.2 External Memory and C aching . . . . . . . . . . . . . . . . . 673
14.2.1 The Memory Hierarchy . . . . . . . . . . . . . . . . . . 673
14.2.2 Caching Strat egies . . . . . . . . . . . . . . . . . . . . 674
14.3 External Searching and B-Trees . . . . . . . . . . . . . . . . 679
14.3.1 (a,b) Trees . . . . . . . . . . . . . . . . . . . . . . . . 680
14.3.2 B-Trees . . . . . . . . . . . . . . . . . . . . . . . . . . 682
14.4 External-Memory Sorting . . . . . . . . . . . . . . . . . . . . 683
14.4.1 Multi-Way Merging . . . . . . . . . . . . . . . . . . . . 684
14.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685
A Useful Mathematical Facts 689
Bi
bliography 697

1.5.3 Class e s and Memory Allocation . . . . . . . . . . . . 40
1.5.4 Class Friends and Class Memb e rs . . . . . . . . . . . 43
1.5.5 T h e Standard Template Library . . . . . . . . . . . . 45
1.6 C++ Program and File Organization . . . . . . . . . . 47
1.6.1 An Example Program . . . . . . . . . . . . . . . . . 48
1.7 Writing a C++ Program . . . . . . . . . . . . . . . . . 53
1.7.1 Design . . . . . . . . . . . . . . . . . . . . . . . . . 54
1.7.2 Pseudo-Code . . . . . . . . . . . . . . . . . . . . . 54
1.7.3 Codin g . . . . . . . . . . . . . . . . . . . . . . . . . 55
1.7.4 Testing and Debugging . . . . . . . . . . . . . . . . 57
1.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . 60