Structures and Abstractions
with Java
Third Edition
Frank M. CarranoUniversity of Rhode Island
International Edition contributions by
Arup Kumar BhattacharjeeRCC Institute of Information Technology
Soumen MukherjeeRCC Institute of Information Technology
Prentice Hall
Boston Columbus Indianpolis New York San Francisco Upper Saddle River
Amsterdam Cape Town Dubai London Madrid Milan Munich Paris Montreal Toronto
Delhi Mexico City Sao Paulo Sydney Hong Kong Seoul Singapore Taipei Tokyo
Contents
Introduction 29
Chapter 1 Bags 33
The Bag 34
A Bag's Behaviors 34
Specifying a Bag 35
An Interface 41
Using the ADT Bag 43
Using an ADT Is Like Using a Vending Machine 48
Java Class Library: The Interface Set 49
Chapter 2 Bag Implementations That Use Arrays 55
Using a Fixed-Size Array to Implement the ADT Bag 56
An Analogy 56
A Group ofCore Methods 57
Implementing the Core Methods 5 8
Testing the Core Methods 65
Implementing More Methods 68
Methods That Remove Entries 70
Using Array Resizing to Implement the ADT Bag 78
Resizing an Array 78
A New Implementation of a Bag 81
The Pros and Cons of Using an Array to Implement the ADT Bag 83
Chapter 3 A Bag Implementation That Links Data 89
Linked Data 90
Forming a Chain by Adding to Its Beginning 91
A Linked Implementation ofthe ADT Bag 93
The Private Class Node 93
An Outline ofthe Class Li nkedBag 94
Defining Some Core Methods 95
Testing the Core Methods 99
The Method getFrequencyOf 100
The Method contains 101
Removing an Item from a Linked Chain 102
The Methods remove and cl ear 103
A Class Node That Has Set and Get Methods 106
The Pros and Cons of Using a Chain to Implement the ADT Bag 109
Chapter 4 The Efficiency of Algorithms 115
Motivation 116
Measuring an Algorithm's Efficiency 117
Counting Basic Operations 119
Best, Worst, and Average Cases 121
Big Oh Notation 122
The Complexities ofProgram Constructs 125
Picturing Efficiency 126
The Efficiency ofImplementations ofthe ADT Bag 130
An Array-Based Implementation 130
A Linked Implementation 131
Comparing the Implementations 132
Chapter 5 Stacks 141
Specifications of the ADT Stack 142
Using a Stack to Process Algebraic Expressions 146
A Problem Solved: Checking for Balanced Delimiters in an
Infix Algebraic Expression 147
A Problem Solved: Transforming an Infix Expressionto a Postfix Expression 151
A Problem Solved: Evaluating Postfix Expressions 156
A Problem Solved: Evaluating Infix Expressions 15 8
The Program Stack 160
Java Class Library: The Class Stack 161
Chapter 6 Stack Implementations 169A Linked Implementation 169
An Array-Based Implementation 173
A Vector-Based Implementation 177
Java Class Library: The Class Vector 178
Using a Vector to Implement the ADT Stack 178
Chapter 7 Recursion 185
What Is Recursion? 186
Tracing a Recursive Method 190Recursive Methods That Return a Value 194
Recursively Processing an Array 196
Recursively Processing a Linked Chain 199The Time Efficiency of Recursive Methods 200
The Time Efficiency of countDown 200The Time Efficiency of Computing xP 202
A Simple Solution to a Difficult Problem 203
A Poor Solution to a Simple Problem 208Tail Recursion 210Indirect Recursion 212
Using a Stack Instead of Recursion 213
Chapter 8 An Introduction to Sorting 223
Organizing Java Methods That Sort an Array 224
Selection Sort 226
Iterative Selection Sort 227
Recursive Selection Sort 229The Efficiency of Selection Sort 230
Insertion Sort 231
Iterative Insertion Sort 232Recursive Insertion Sort 234The Efficiency ofInsertion Sort 236Insertion Sort of a Chain ofLinked Nodes 236
Shell Sort 239The Java Code 241
The Efficiency of Shell Sort 242
Comparing the Algorithms 242
Chapter 9 Faster Sorting Methods 249
Merge Sort 250
Merging Arrays 250
Recursive Merge Sort 251
The Efficiency of Merge Sort 253
Iterative Merge Sort 255
Merge Sort in the Java Class Library 255
Quick Sort 256
The Efficiency of Quick Sort 256
Creating the Partition 257
Java Code for Quick Sort 260
Quick Sort in the Java Class Library 262
Radix Sort 263
Pseudocode for Radix Sort 264
The Efficiency ofRadix Sort 265
Comparing the Algorithms 265
Chapter 10 Queues, Deques, and Priority Queues 273
The ADT Queue 274
A Problem Solved: Simulating a Waiting Line 278
A Problem Solved: Computing the Capital Gain in a Sale of Stock 284
Java Class Library: The Interface Queue 287
The ADT Deque 288
A Problem Solved: Computing the Capital Gain in a Sale of Stock 290
Java Class Library: The Interface Deque 291
Java Class Library: The Class ArrayDeque 292
The ADT Priority Queue 293
A Problem Solved: Tracking Your Assignments 294
Java Class Library: The Class Prion' tyQueue 296
Chapter 11 Queue, Deque, and Priority Queue Implementations 301
A Linked Implementation of a Queue 302
An Array-Based Implementation of a Queue 306
A Circular Array 306
A Circular Array with One Unused Location 309
A Vector-Based Implementation ofa Queue 314
Circular Linked Implementations of a Queue 316
A Two-Part Circular Linked Chain 317
Java Class Library: The Class AbstractQueue 322
A Doubly Linked Implementation ofa Deque 323
Possible Implementations of a Priority Queue 327
Chapter 12 Lists 333
Specifications for the ADT List 334
Using the ADT List 340
Java Class Library: The Interface Li st 344
Java Class Library: The Class ArrayLi st 344
Chapter 13 List Implementations That Use Arrays 349
Using an Array to Implement the ADT List 350
An Analogy 350
The Java Implementation 352
The Efficiency of Using an Array to Implement the ADT List 359
Using a Vector to Implement the ADT List 360
Chapter 14 A List Implementation That Links Data 367
Operations on a Chain of Linked Nodes 368
Adding a Node at Various Positions 368
Removing a Node from Various Positions 372
The Private Method getNodeAt 373
Beginning the Implementation 374
The Data Fields and Constructor 375
Adding to the End ofthe List 376
Adding at a Given Position Within the List 377
The Methods i sEmpty and toArray 378
Testing the Core Methods 3 81
Continuing the Implementation 382
A Refined Implementation 384
The Tail Reference 385
The Efficiency of Using a Chain to Implement the ADT List 388
Java Class Library: The Class Li nkedLi st 390
Chapter 15 Iterators 397
What Is an Iterator? 398
The Interface Iterator 399
Using the Interface Ite rator 400
A Separate Class Iterator 405
An Inner Class Iterator 409
A Linked Implementation 409
An Array-Based Implementation 413
Why Are Iterator Methods in Their Own Class? 416
The Interface Listlterator 418
Using the Interface Li stlterator 421
An Array-Based Implementation ofthe Interface Li stlterator 423
The Inner Class 425
Java Class Library: The Interface Iterabl e 430
Iterabl e and for-each loops 431
The Interface Li st Revisited 431
Chapter 16 Sorted Lists 439
Specifications for the ADT Sorted List 440
Using the ADT Sorted List 443
A Linked Implementation 444
The Method add 445
The Efficiency ofthe Linked Implementation 452
An Implementation That Uses the ADT List 452
Efficiency Issues 455
Chapter 17 Inheritance and Lists 461
Using Inheritance to Implement a Sorted List 462
Designing a Base Class 464
Creating an Abstract Base Class 469
An Efficient Implementation of a Sorted List 471
The Method add 471
Chapter 18 Searching 475
The Problem 476
Searching an Unsorted Array 476
An Iterative Sequential Search of an Unsorted Array 477
A Recursive Sequential Search of an Unsorted Array 478
The Efficiency of a Sequential Search of an Array 480
Searching a Sorted Array 480
A Sequential Search ofa Sorted Array 480
A Binary Search of a Sorted Array 481
Java Class Library: The Method bi narySearch 486
The Efficiency of a Binary Search of an Array 486
Searching an Unsorted Chain 488
An Iterative Sequential Search of an Unsorted Chain 488
A Recursive Sequential Search ofan Unsorted Chain 489
The Efficiency of a Sequential Search of a Chain 490
Searching a Sorted Chain 490
A Sequential Search of a Sorted Chain 490
A Binary Search of a Sorted Chain 490
Choosing a Search Method 491
Chapter 19 Dictionaries 499
Specifications for the ADT Dictionary 500
A Java Interface 504
Iterators 505
Using the ADT Dictionary 506
A Problem Solved: A Directory of Telephone Numbers 507
A Problem Solved: The Frequency ofWords 512
A Problem Solved: A Concordance ofWords 516
Java Class Library: The Interface Map 518
Chapter 20 Dictionary Implementations 525
Array-Based Implementations 526
An Unsorted Array-Based Dictionary 526
A Sorted Array-Based Dictionary 531
Vector-Based Implementations 536
Linked Implementations 540
An Unsorted Linked Dictionary 542
A Sorted Linked Dictionary 542
Chapter 21 Introducing Hashing 551
What Is Hashing? 552
Hash Functions 555
Computing Hash Codes 555
Compressing a Hash Code into an Index for the Hash Table 558
Resolving Collisions 559
Open Addressing with Linear Probing 559
Open Addressing with Quadratic Probing 565
Open Addressing with Double Hashing 565
A Potential Problem with Open Addressing 567
Separate Chaining 567
Chapter 22 Hashing as a Dictionary Implementation 575
The Efficiency of Hashing 576
The Load Factor 576
The Cost of Open Addressing 577
The Cost of Separate Chaining 579
Rehashing 580
Comparing Schemes for Collision Resolution 581
A Dictionary Implementation That Uses Hashing 582
Entries in the Hash Table 582
Data Fields and Constructors 583
The Methods getVal ue, remove, and add 585
Iterators 590
Java Class Library: The Class HashMap 592
Java Class Library: The Class HashSet 592
Chapter 23 Trees 597
Tree Concepts 598
Hierarchical Organizations 598
Tree Terminology 600
Traversals of a Tree 604
Traversals of a Binary Tree 604
Traversals of a General Tree 607
Java Interfaces for Trees 607
Interfaces for All Trees 608
An Interface for Binary Trees 608
Examples ofBinary Trees 610
Expression Trees 610
Decision Trees 612
Binary Search Trees 616
Heaps 618
Examples of General Trees 621
Parse Trees 621
Game Trees 621
Chapter 24 Tree Implementations 631
The Nodes in a Binary Tree 632
An Interface for a Node 633
An Implementation of Bi naryNode 634
An Implementation of the ADT Binary Tree 635
Creating a Basic Binary Tree 636The Method pri vateSetTree 637Accessor and Mutator Methods 640
Computing the Height and Counting Nodes 641
Traversals 642
An Implementation of an Expression Tree 647
General Trees 649
A Node for a General Tree 649
Using a Binary Tree to Represent a General Tree 650
Chapter 25 A Binary Search Tree Implementation 657
Getting Started 658
An Interface for the Binary Search Tree 659
Duplicate Entries 661
Beginning the Class Definition 662
Searching and Retrieving 663
Traversing 665
Adding an Entry 665
A Recursive Implementation 666
An Iterative Implementation 670
Removing an Entry 671
Removing an Entry Whose Node Is a Leaf 672
Removing an Entry Whose Node Has One Child 672
Removing an Entry Whose Node Has Two Children 673
Removing an Entry in the Root 676
A Recursive Implementation 677
An Iterative Implementation 680
The Efficiency of Operations 684
The Importance of Balance 685
The Order in Which Nodes Are Added 686
An Implementation of the ADT Dictionary 687
Chapter 26 A Heap Implementation 701
Reprise: The ADT Heap 702
Using an Array to Represent a Heap 702
Adding an Entry 705
Removing the Root 708
Creating a Heap 711
Heap Sort 714
Chapter 27 Balanced Search Trees 723AVL Trees 724
Single Rotations 724
Double Rotations 727
Implementation Details 731
2-3 Trees 735
Searching a 2-3 Tree 736
Adding Entries to a 2-3 Tree 737
Splitting Nodes During Addition 739
2-4 Trees 740
Adding Entries to a 2-4 Tree 741
Comparing AVL, 2-3, and 2-4 Trees 743
Red-Black Trees 744
Properties ofa Red-Black Tree 745
Adding Entries to a Red-Black Tree 746
Java Class Library: The Class TreeMap 752
B-Trees 752
Chapter 28 Graphs 759
Some Examples and Terminology 760
Road Maps 760
Airline Routes 763
Mazes 764
Course Prerequisites 764
Trees 765
Traversals 765
Breadth-First Traversal 766
Depth-First Traversal 768
Topological Order 769
Paths 772
Finding a Path 772
The Shortest Path in an Unweighted Graph 772
The Shortest Path in a Weighted Graph 775
Java Interfaces for the ADT Graph 779
Chapter 29 Graph Implementations 789
An Overview ofTwo Implementations 790
The Adjacency Matrix 790
The Adjacency List 791
Vertices and Edges 792
Specifying the Class Vertex 793
The Inner Class Edge 795
Implementing the Class Vertex 796
An Implementation ofthe ADT Graph 800
Basic Operations 800
Graph Algorithms 803
Chapter 30 Mutable, Immutable, and Cloneable Objects Online
Mutable and Immutable Objects 30-2
Creating a Read-Only Class 30-4
Companion Classes 30-6
Cloneable Objects 30-8
Cloning an Array 30-14
Cloning a Chain 30-16
A Sorted List ofClones 30-19
Appendices
A. Java Essentials A-l
Introduction A-2
Applications and Applets A-2
Objects and Classes A-3
A First Java Application Program A-3
Java Basics A-5
Identifiers A-5
Reserved Words A-6
Variables A-6
Primitive Types A-7
Constants A-7
Assignment Statements A-8
Assignment Compatibilities A-9
Type Casting A-9
Arithmetic Operators and Expressions A-10
Parentheses and Precedence Rules A-11
Increment and Decrement Operators A-12
Special Assignment Operators A-13
Named Constants A-14
The Class Math A-15
Simple Input and Output Using the Keyboard and Screen A-15
Screen Output A-15
Keyboard Input Using the Class Scanner A-17
The i f-el se Statement A-19
Boolean Expressions A-20
Nested Statements A-23
Multiway if-else Statements A-24
The Conditional Operator (Optional) A-25
The swi tch Statement A-26
Enumerations A-28
Scope A-30
Loops A-30The whi 1 e Statement A-31
The for Statement A-32
The do-while Statement A-34Additional Loop Information A-35
The Class String A-36
Characters Within Strings A-36Concatenation of Strings A-37
String Methods A-38
The Class StringBuilder A-40
Using Scanner to Extract Pieces of a String A-42
Arrays A-44
Array Parameters and Returned Values A-46
Initializing Arrays A-47
Array Index Out of Bounds A-47
Use of = and == with Arrays A-47
Arrays and the For-Each Loop A-48Multidimensional Arrays A-49
Wrapper Classes A-51
B. Java Classes B-1
Objects and Classes B-1
Using the Methods in a Java Class B-3
References and Aliases B-4
Defining a Java Class B-5
Method Definitions B-7
Arguments and Parameters B-9
Passing Arguments B-9
A Definition ofthe Class Name B-13
Constructors B-15
The Method toStri ng B-17
Methods That Call Other Methods B-17
Methods That Return an Instance ofTheir Class B-19
Static Fields and Methods B-19
Overloading Methods B-21
Enumeration as a Class B-22
Packages B-25
The Java Class Library B-25
Generic Data Types B-26
C. Creating Classes from Other Classes C-1
Composition C-2
Adapters C-4
Inheritance C-5
Invoking Constructors from Within Constructors C-9
Private Fields and Methods of the Superclass C-10
Protected Access C-11
Overriding and Overloading Methods C-11
Multiple Inheritance C-16
Type Compatibility and Superclasses C-16
The Class Object C-18
Abstract Classes and Methods C-19
Polymorphism C-21
D. Designing Classes D-1
Encapsulation D-2
Specifying Methods D-4
Comments D-4
Preconditions and Postconditions D-5
Assertions D-6
Java Interfaces D-7
Writing an Interface D-8
Implementing an Interface D-10
An Interface as a Data Type D-11
Generic Types Within an Interface D-12
Extending an Interface D-14
Interfaces Versus Abstract Classes D-15
Named Constants Within an Interface D-17
Choosing Classes D-18
Identifying Classes D-20
CRC Cards D-20
The Unified Modeling Language D-21
Reusing Classes D-23
E. Handling Exceptions E-1
The Basics E-2
Handling an Exception E-4
Postpone Handling: The throws Clause E-4
Handle ItNow: The try-catch Blocks E-5
Multiple catch Blocks E-6
Throwing an Exception E-8
Programmer-Defined Exception Classes E-9
Inheritance and Exceptions E-14
The finally Block E-15
F. File Input and Output F-1Preliminaries F-2
Why Files? F-2
Streams F-2
The Kinds ofFiles F-3
File Names F-3
Text Files F-3
Creating a Text File F-3
Reading a Text File F-8
Changing Existing Data in a Text File F-12
Defining a Method to Open a Stream F-13
Binary Files F-13
Creating a Binary File ofPrimitive Data F-14
Reading a Binary File ofPrimitive Data F-18
Strings in a Binary File F-20
Object Serialization F-23
G. Documentation and Programming Style G-1
Naming Variables and Classes G-1
Indenting G-2
Comments G-2
Single-Line Comments G-3
Comment Blocks G-3When to Write Comments G-3
Java Documentation Comments G-3
Running j avadoc G-5
Glossary Online
Index I-l