Schaum's Outline sof Data Structures with Java

SCHAUM’S OUTLINE OF

DATA STRUCTURES WITH JAVA Second Edition JOHN R. HUBBARD, Ph.D. Professor of Mathematics and Computer Science University of Richmond

Schaum’s Outline Series McGRAW-HILL New York Chicago San Francisco Lisbon London Madrid Mexico City Milan New Delhi San Juan Singapore Sydney Toronto

Copyright © 2007, 2001 by The McGraw-Hill Companies, Inc. All rights reserved. Manufactured in the United States of America. Except as permitted under the United States Copyright Act of 1976, no part of this publication may be reproduced or distributed in any form or by any means, or stored in a database or retrieval system, without the prior written permission of the publisher. 0-07-150993-3 The material in this eBook also appears in the print version of this title: 0-07-147698-9. All trademarks are trademarks of their respective owners. Rather than put a trademark symbol after every occurrence of a trademarked name, we use names in an editorial fashion only, and to the benefit of the trademark owner, with no intention of infringement of the trademark. Where such designations appear in this book, they have been printed with initial caps. McGraw-Hill eBooks are available at special quantity discounts to use as premiums and sales promotions, or for use in corporate training programs. For more information, please contact George Hoare, Special Sales, at [email protected] or (212) 904-4069. TERMS OF USE This is a copyrighted work and The McGraw-Hill Companies, Inc. (“McGraw-Hill”) and its licensors reserve all rights in and to the work. Use of this work is subject to these terms. Except as permitted under the Copyright Act of 1976 and the right to store and retrieve one copy of the work, you may not decompile, disassemble, reverse engineer, reproduce, modify, create derivative works based upon, transmit, distribute, disseminate, sell, publish or sublicense the work or any part of it without McGraw-Hill’s prior consent. You may use the work for your own noncommercial and personal use; any other use of the work is strictly prohibited. Your right to use the work may be terminated if you fail to comply with these terms. THE WORK IS PROVIDED “AS IS.” McGRAW-HILL AND ITS LICENSORS MAKE NO GUARANTEES OR WARRANTIES AS TO THE ACCURACY, ADEQUACY OR COMPLETENESS OF OR RESULTS TO BE OBTAINED FROM USING THE WORK, INCLUDING ANY INFORMATION THAT CAN BE ACCESSED THROUGH THE WORK VIA HYPERLINK OR OTHERWISE, AND EXPRESSLY DISCLAIM ANY WARRANTY, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. McGraw-Hill and its licensors do not warrant or guarantee that the functions contained in the work will meet your requirements or that its operation will be uninterrupted or error free. Neither McGraw-Hill nor its licensors shall be liable to you or anyone else for any inaccuracy, error or omission, regardless of cause, in the work or for any damages resulting therefrom. McGraw-Hill has no responsibility for the content of any information accessed through the work. Under no circumstances shall McGraw-Hill and/or its licensors be liable for any indirect, incidental, special, punitive, consequential or similar damages that result from the use of or inability to use the work, even if any of them has been advised of the possibility of such damages. This limitation of liability shall apply to any claim or cause whatsoever whether such claim or cause arises in contract, tort or otherwise. DOI: 10.1036/0071476989

PREFACE

Like other Schaum’s Outlines, this book is intended to be used primarily for self study. It is suitable as a study guide in a course on data structures using the Java programming language. In American universities, this is typically the second course in the computer science major. The book is also serves well as a reference on data structures and the Java Collections Framework. The book includes more than 200 detailed examples and over 260 solved problems. The author firmly believes that programming is learned best by practice, following a well-constructed collection of examples with complete explanations. This book is designed to provide that support. This second edition is a major improvement over the original 2001 edition. Most of the chapters have been completely rewritten. Three entirely new chapters have been added, on object-oriented programming, linked structures, and the Java Collections Framework. Java 6.0 is used throughout the book, with special attention to these new features of the language: • The Scanner class. • The StringBuilder class. • Formatted output, including the printf() method. • The enhanced for loop (also called the for-each loop). • Static imports. • enum types. • Variable length parameter lists. • Autoboxing. • Generic classes • The Deque , ArrayDeque , EnumSet , and EnumMap classes, and the Queue interface in the Java Collections Framework. Source code for all the examples, solved problems, and supplementary programming problems may be downloaded from the author’s Web site http://www.mathcs.richmond.edu/~hubbard/books/

I wish to thank all my friends, colleagues, students, and the McGraw-Hill staff who have helped me with the critical review of this manuscript, including Stephan Chipilov and Sheena Walker. Special thanks to my colleague Anita Huray Hubbard for her advice, encouragement, and supply of creative problems for this book. JOHN R. HUBBARD Richmond, Virginia

vii

For more information about this title, click here

CONTENTS

Chapter 1

Object-Oriented Programming

1

Software Design and Development 1 Object-Oriented Design 2 Abstract Data Types 3 Java Interfaces 4 Classes and Objects 5 Modifiers 8 Composition, Aggregation, and Inheritance 10 The Unified Modeling Language 13 Polymorphism 14 Javadoc 16 Chapter 2

Arrays

26

Properties of Arrays 26 Duplicating an Array 28 The java.util.Arrays Class 29 The Sequential Search Algorithm 30 The Binary Search Algorithm 31 Chapter 3

Linked Data Structures

46

Maintaining an Ordered Array 46 Indirect Reference 47 Linked Nodes 50 Inserting an Element into a Linked List 55 Inserting at the Front of the List 58 Deleting from a Sorted Linked List 59 Nested Classes 59 Chapter 4

The Java Collections Framework The Inheritance Hierarchy 69 The Collection Interface 70 ix

69

x

CONTENTS

The HashSet Class 72 Generic Collections 74 Generic Methods 76 Generic Wildcards 76 Iterators 77 The TreeSet Class 79 The LinkedHashSet Class 83 The EnumSet Class 83 The List Interface 85 The ArrayList and Vector Classes 86 The LinkedList Class 86 The ListIterator Interface 87 The Queue Interface 87 The PriorityQueue Class 90 The Deque Interface and ArrayDeque Class 91 The Map Interface and Its Implementing Classes 92 The Arrays Class 95 The Collections Class 96 Autoboxing 97 Chapter 5

Stacks

103

Stack Operations 103 The JCF Stack Class 103 A Stack Interface 104 An Indexed Implementation 104 A Linked Implementation 106 Abstracting the Common Code 108 Application: An RPN Calculator 109 Chapter 6

Queues

117

Queue Operations 117 The JCF Queue Interface 117 A Simple Queue Interface 118 An Indexed Implementation 119 An Indexed Implementation 120 Application: A Client-Server System Chapter 7

Lists

121

131

The JCF List Interface 131 The Range-View Operation sublist() List Iterators 133 Other List Types 136 Application: The Josephus Problem 140 Application: A Polynomial Class 141

132

CONTENTS

Chapter 8

Hash Tables

148

The Java Map Interface 148 The HashMap Class 149 Java Hash Codes 150 Hash Tables 151 Hash Table Performance 153 Collision Resolution Algorithms 154 Separate Chaining 156 Applications 157 The TreeMap Class 159 Chapter 9

Recursion

165

Simple Recursive Functions 165 Basis and Recursive Parts 166 Tracing A Recursive Call 167 The Recursive Binary Search 168 Binomial Coefficients 169 The Euclidean Algorithm 171 Inductive Proof of Correctness 171 Complexity Analysis 172 Dynamic Programming 173 The Towers of Hanoi 173 Mutual Recursion 175 Chapter 10

Trees

186

Tree Definitions 186 Decision Trees 188 Transition Diagrams 189 Ordered Trees 191 Traversal Algorithms 192 Chapter 11

Binary Trees

200

Definitions 200 Counting Binary Trees 201 Full Binary Trees 202 Identity, Equality, and Isomorphism 203 Complete Binary Trees 205 Binary Tree Traversal Algorithms 207 Expression Trees 209 A BinaryTree Class 211 Implementations of The Traversal Algorithms 216 Forests 219

xi

xii

Chapter 12

CONTENTS

Search Trees

230

Multiway Search Trees 230 B-trees 232 Binary Search Trees 234 Performance of Binary Search Trees 236 AVL Trees 237 Chapter 13

Heaps and Priority Queues Heaps 245 The Natural Mapping 245 Insertion Into A Heap 246 Removal From A Heap 247 Priority Queues 247 The JCF PriorityQueue Class

Chapter 14

Sorting

245

248

255

Code Preliminaries 255 The Java Arrays.sort() Method 256 The Bubble Sort 256 The Selection Sort 257 The Insertion Sort 258 The Shell Sort 259 The Merge Sort 260 The Quick Sort 263 The Heap Sort 265 The Speed Limit For Comparison Sorts 269 The Radix Sort 270 The Bucket Sort 271 Chapter 15

Graphs

285

Simple Graphs 285 Graph Terminology 285 Paths and Cycles 286 Isomorphic Graphs 288 The Adjacency Matrix for a Graph 290 The Incidence Matrix for a Graph 291 The Adjacency List for a Graph 291 Digraphs 292 Paths in a Digraph 294 Weighted Digraphs and Graphs 295 Euler Paths and Hamiltonian Cycles 295 Dijkstra’s Algorithm 297 Graph Traversal Algorithms 300

CONTENTS

APPENDIX

Essential Mathematics

xiii

319

The Floor and Ceiling Functions 319 Logarithms 319 Asymptotic Complexity Classes 320 The First Principle of Mathematical Induction 321 The Second Principle of Mathematical Induction 322 Geometric Series 323 Other Summation Formulas 323 Harmonic Numbers 324 Stirling’s Formula 325 Fibonacci Numbers 326 INDEX

329

SCHAUM’S OUTLINE OF

DATA STRUCTURES WITH JAVA

CHAPTER 1

Object-Oriented Programming

SOFTWARE DESIGN AND DEVELOPMENT Successful computer software is produced in a sequence of stages that are typically managed by separate teams of developers. These stages are illustrated in Figure 1.1. The first stage is a recognition of the problem to be solved. In a corporate setting, this determination could come from market research. The second stage, which might be omitted as a formal process, is a study of whether the project is feasible. For example, do the development tools exist to produce the software? In the third stage, a document is typically produced that specifies precisely what the software should do. This requirements document should have enough detail to be used as a standard when the completed software is tested. In the fourth stage, a thorough analysis is done before any effort or resources are spent designing and implementing the project. This could include a survey of comparable software already available and a cost-benefit analysis of the value of spending the anticipated resources. Once a decision has been made to proceed, the software design team works from the requirements document to design the software. This includes the specification of all the software components and their interrelationships. It may also require the specification of specialized algorithms that would be implemented in the software. The implementation consists of programmers coding the Figure 1.1 Software life cycle design to produce the software. The testing team attempts to ensure that the resulting software satisfies the requirements document. Failure at this point may require a redesign or even some fine-tuning of the requirements. Those eventualities are represented by the two feedback loops shown in Figure 1.1.

1

2

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

Testing occurs at several levels. Individual classes and methods have to be tested separately, and then their success at working together must be verified. Finally, the product as a whole is tested against the requirements document. One final aspect of software development that is not shown in the figure is the maintenance process. After the software has been delivered, its developers remain obliged to maintain it with corrected versions, service packages, and even major revisions. Any major revision itself would follow the same life cycle steps. OBJECT-ORIENTED DESIGN One common approach to software design is a top-down design strategy that gradually breaks the problem down into smaller parts. This is also called step-wise refinement. It focuses on the functional aspects of the problem and the implementation of algorithms. This procedure-oriented design is common in scientific programming. In contrast, object-oriented design focuses on the data components of the software, organizing the design around their representatives. For example, an air traffic control system might be designed in terms of airplanes, airports, pilots, controllers, and other “objects.” The Java programming language is particularly well-suited for implementing object-oriented designs. All executable code in Java is organized into classes that represent objects. For this reason, Java is regarded as an object-oriented programming language. An object is a software unit that is produced according to a unique class specification. It is called an instance of its class, and the process of creating it is called instantiating the class. For example, this code instantiates the java.util.Date class: java.util.Date today = new java.util.Date(); The variable today is a reference to the object, as shown in

Figure 1.2. Ignoring the distinction between a reference and the object to which it refers, we would also say today is the Figure 1.2 A Java object name of the java.util.Date object. A Java class consists of three kinds of members: fields, methods, and constructors. The fields hold the data for class objects, the methods hold the statements that are executed by the objects, and the constructors hold the code that initializes the objects’ fields. An object-oriented design specifies the classes that will be instantiated in the software. That design can be facilitated and illustrated by the Unified Modeling Language (UML). In UML, each class is represented by a rectangle with separate parts for listing the class’s name, its fields, and its methods and constructors. Figure 1.3 shows a UML diagram for a Person class with four fields (name, id, sex, and dob), a constructor, and three methods (isAnAdult(), setDob(), and toString()). Each of the eight class members is prefaced with a visibility symbol: Figure 1.3 A UML diagram + means public # for protected for private (Package visibility has no UML symbol.)

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

3

UML diagrams are independent of any implementing programming language. They are used in object-oriented design to specify objects. They should be easy to implement in Java, C++, or any other object-oriented programming language. They provide a kind of pseudo-code for classes. They specify the state (i.e., fields) and the behavior (i.e., methods) of an object without specifying how that behavior is accomplished. UML diagrams include no executable code. Specifying what an object can do without specifying how it does it is an abstraction. It allows the design stage to be separated from the implementation stage of the software development. It also facilitates modification of the software by allowing an implementation to be changed without affecting dependent modules. As long as a method’s behavior is unchanged, any invoking modules will be unaffected by a change in that method’s implementation. For example, suppose that an airline reservation system uses the Person class specified by the UML diagram in Figure 1.3. Presumably, that software will invoke that class’s isAnAdult() method in various modules of the system. The “contract” specified by the software design only requires that the method return the right answer: x.isAnAdult() should be true if and only if x is an adult. How it computes that result is irrelevant. The implementation probably computes the chronological difference between the value of the private field x.dob and the value of the current date. But there is nothing in the contract that specifies that. Moreover, if the implementation is changed, none of the other code in the reservation system would be affected by that change. Such a change might be warranted by the preference of a different algorithm for computing chronological differences, or possibly by a redefinition of the meaning of “adult.” Concealing the implementation of a method from the clients who use the method is called information hiding. It is the software designer’s version of the spy’s principle that says, “If you don’t need to know it, then you’re are not allowed to know it.” It makes software easier to design, implement, and modify. ABSTRACT DATA TYPES Abstractions are used to help understand complex systems. Even though they are different, rocks and tennis balls fall at the same rate. The physicist uses the abstraction of imagining a single imaginary point mass to understand the physics of falling bodies. By ignoring the irrelevancies (diameter, weight), the abstraction allows the analyst to focus on the relevancies (height). Abstractions are widely used in software development. UML diagrams provide abstractions by focusing on the fields (the state) and methods (the behavior) of a class. But at some levels, even the fields of a class may be irrelevant. An abstract data type (ADT) is a specification of only the behavior of instances of that type. Such a specification may be all that is needed to design a module that uses the type. Primitive types are like ADTs. We know what the int type can do (add, subtract, multiply, etc.). But we need not know how it does these operations. And we need not even know how an int is actually stored. As clients, we can use the int operations without having to know how they are implemented. In fact, if we had to think about how they are implemented, it would probably be a distraction from designing the software that will use them. Likewise, if you had to think about how your car manages to turn its front wheels when you turn the steering wheel, it would probably be more difficult to drive!

4

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

EXAMPLE 1.1 An ADT for Fractions Most programming languages have types for integers and real (decimal) numbers, but not for fractions. Such numbers can be implemented as objects. Here is a design for a fraction type: ADT: Fraction plus(Fraction): Fraction times(Integer): Fraction times(Fraction): Fraction reciprocal(): Fraction value(): Real

This ADT specifies five operations. Note that the times() operation is overloaded. Note that the ADT uses generic terms for types: Integer instead of int, and Real instead of double. That is because it is supposed to be independent of any specific programming language. In general, a complete ADT would also include documentation that explains exactly how each operation should behave. For example, x.plus(y) returns the Fraction that represents x + y x.times(n) returns the Fraction that represents n*x x.times(y) returns the Fraction that represents x*y x.reciprocal() returns the Fraction that represents 1/x x.value() returns the numerical value of x

UML diagrams can be used to specify ADTs simply by omitting the state information. The Fraction ADT defined in Example 1.1 is shown as a UML diagram in Figure 1.4. ADTs can be used in pseudocode to implement algorithms independently of any specific programming language. This is illustrated in Example 1.2. Figure 1.4 An ADT in UML

EXAMPLE 1.2 Using an ADT in an Algorithm The harmonic mean of two numbers x and y is the number h defined by the formula h = 2/(1/x + 1/y). In pseudocode for Fraction types, this could be expressed as: harmonicMean(x: Fraction, y: Fraction) returns Fraction return x.reciprocal().plus(y.reciprocal()).reciprocal().times(2);

JAVA INTERFACES In Java, an ADT can be represented by an interface. Recall that a Java interface is just like a Java class, except that it contains no executable code. EXAMPLE 1.3 A Fraction Interface 1 2 3 4 5 6 7

public interface Fraction { Fraction plus(Fraction x); Fraction times(int n); Fraction times(Fraction x); Fraction reciprocal(); double value(); }

This is a direct translation into Java of the ADT specified in Example 1.1.

If an ADT is translated into Java as an interface, then we can implement algorithms that use it as Java methods.

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

5

EXAMPLE 1.4 A harmonicMean() Method 1 2 3

public Fraction harmonicMean(Fraction x, Fraction y) { return x.reciprocal().plus(y.reciprocal()).reciprocal().times(2); }

Although the Java code in Example 1.4 cannot be executed, we can compile it.

In Java, an interface is a type. Reference variables may be declared to have an interface type, even if the interface has no implementation. For example, the parameters x and y at line 1 of Example 1.4 are declared to have type Fraction. An interface may represent an ADT, as in Example 1.3. More generally, a Java interface is meant to identify a capability. For example, the Comparable interface requires the implementation of this method: int compareTo(T type)

This means that any variable declared to have type Comparable can invoke this method, meaning that it is capable of being compared to other objects. CLASSES AND OBJECTS Java is a strongly typed language: Every variable must be declared to have a data type. The various Java types are shown in Figure 1.5. These are categorized as either primitive types or reference types. The eight built-in primitive types are for integers, characters, decimal numbers, and boolean values. Reference types are user-defined, and their variables must be instantiated to hold data. Arrays are reviewed in Chapter 2; interfaces are types that cannot be instantiated; enum types are defined by listing all the values that a variable of that type may have. Classes are concrete data types that specify how their state is stored (the class fields) and how their instances behave (the instance methods). A class is defined in a declaration statement with this syntax: modifers class class name associations { declarations } where modifers are keywords such as public and abstract, class name is an identifier such as Person that names the class, associations are clauses such as extends Object, and declarations are declarations of the class’s members.

A class can have six kinds of members: 1. Fields that specify the kind of data that the objects hold. 2. Constructors that specify how the objects are to be created. 3. Methods that specify the operations that the objects can perform. 4. Nested classes. 5. Interfaces. 6. Enum type definitions. Each member of a class must be specified in its own declaration statement. The purpose of a declaration is to introduce an identifier to the compiler. It provides all the information that the compiler needs in order to compile statements that use that identifier. A field is a variable that holds data for the object. The simplest kind of field declaration has this syntax: modifers type name = initializer;

6

OBJECT-ORIENTED PROGRAMMING

where modifers and the initializer are optional. For example, the Point class in Example 1.5 declares two fields at lines 2 3. Each has the modifier protected, which means that they are accessible only from within the class itself and from its extensions. A constructor is a subprogram that creates an object. It’s like a method with these distinctions: • Its name is the same as its class name. • It has no return type. • It is invoked by the new operator. The simplest kind of constructor declaration has this syntax: modifers name(param decls) { statements } Note that a class need not have a main()

method. If it does, it is then an executable program. Otherwise, it merely defines a new type that can be used elsewhere.

Java data types Primitive types Numeric types Integer types Integers byte short int long

Characters byte

Floating point types float double

Boolean type boolean

Reference types Arrays Interfaces Classes Enums

EXAMPLE 1.5 A Ratio Class 1 2 3 4

public class Ratio { protected int num; protected int den; public static final Ratio ZERO = new Ratio();

5 6 7 8

private Ratio() { this(0, 1); }

9 10 11 12 13

public Ratio(int num, int den) { this.num = num; this.den = den; }

14 15 16 17 18 19 20 21 22 23

public boolean equals(Object object) { if (object==this) { return true; } else if (!(object instanceof Ratio)) { return false; } Ratio that = (Ratio)object; return (this.num*that.den == that.num*this.den); }

24 25 26 27 28

public int getNum() { return num; }

[CHAP. 1

Figure 1.5 Java types

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

7

public int getDen() { return den; }

29 30 31 32

public String toString() { return String.format("%d/%d", num, den); }

33 34 35 36

public double value() { return (double)num/den; }

37 38 39 40

}

Instances of this class represent fractions, with numerator (num) and denominator (den). The static final field ZERO represents the fraction 0/1. It is defined to be static because it is unique to the class itself — there shouldn’t be more than one ZERO object. In addition to its three fields, this class has two constructors and four methods. The no-arg constructor (it has no arguments) defined at line 6 is declared private so that it cannot be invoked from outside of its class. It is invoked at line 4 to initialize the ZERO object. This constructor uses the this keyword at line 7 to invoke the two-arg constructor, passing 0 to num and 1 to den. The two-arg constructor at line 10 is provided to the public for constructing Ratio objects with specific num and den values. Note that, to prevent the ZERO object from being duplicated, we could have included this at line11: if (num == 0) { throw new IllegalArgumentException("Use Ratio.ZERO"); }

But then we would have to replace line 7 with explicit initializations: num = 0; den = 1;

instead of invoking the two-arg constructor there. The equals() method at line 15 overrides the default equals() method that is defined in the Object class (which all other classes extend). Its purpose is to return true if and only if its explicit argument (object) represents the same thing as its implicit argument (this). It returns true immediately (at line 17) if the two objects are merely different names for the same object. On the other hand, it returns false (at line 19) if the explicit argument is not even the right type. These tests for the two extremes are canonical and should be done first in every equals() method. If they both are passed, then we can recast the explicit argument as an object of the same type as the implicit argument (Ratio) so we can access its fields (num and den). The test for equality of two ratios a/b = c/d is whether a*d = b*c, which is done at line 22. The methods defined at lines 25 and 29 are accessor methods (also called “getter methods”) providing public access to the class’s private fields. The toString() method at line 33 also overrides the corresponding method that is defined in the Object class. Its purpose is to return a String representation of its implicit argument. It is invoked automatically whenever a reference to an instance of the class appears in an expression where a String object is expected. For example, at line 6 in the test program below, the expression "x = " + x concatenates the string "x = " with the reference x. That reference is replaced by the string "22/7" that is returned by an implicit invocation of the toString() method. Finally, the value() method at line 37 returns a decimal approximation of the numerical value of the ratio. For example, at line 7 in the test program below, x.value() returns the double value 3.142857142857143.

8

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

The program tests the Ratio class: 1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class TestRatio { public static void main(String[] args) { System.out.println("Ratio.ZERO = " + Ratio.ZERO); System.out.println("Ratio.ZERO.value() = " + Ratio.ZERO.value()); Ratio x = new Ratio(22, 7); System.out.println("x = " + x); System.out.println("x.value() = " + x.value()); System.out.println("x.equals(Ratio.ZERO): " + x.equals(Ratio.ZERO)); Ratio xx = new Ratio(44, 14); System.out.println("xx = " + xx); System.out.println("xx.value() = " + xx.value()); System.out.println("x.equals(xx): " + x.equals(xx)); } }

The output is: Ratio.ZERO = 0/1 Ratio.ZERO.value() = 0.0 x = 22/7 x.value() = 3.142857142857143 x.equals(Ratio.ZERO): false xx = 44/14 xx.value() = 3.142857142857143 x.equals(xx): true

The Ratio class in Example 1.5 is immutable: its fields cannot be changed. MODIFIERS Modifiers are used in the declaration of class members and local variables. These are summarized in the following tables. Modifier

Meaning

abstract

The class cannot be instantiated.

final

The class cannot be extended.

public

Its members can be accessed from any other class.

strictfp

Floating point results will be platform independent. Table 1.1 Modifiers for classes, interfaces, and enums

Modifier

Meaning

private

It is accessible only from within its own class.

protected

It is accessible only from within its own class and its extensions.

public

It is accessible from all classes. Table 1.2 Constructor modifiers

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

Modifier

9

Meaning

final

It must be initialized and cannot be changed.

private

It is accessible only from within its own class.

protected

It is accessible only from within its own class and its extensions.

public

It is accessible from all classes.

static

The same storage is used for all instances of the class.

transient

It is not part of the persistent state of an object.

volatile

It may be modified by asynchronous threads. Table 1.3 Field modifiers

Modifier

Meaning

abstract

Its body is absent; to be defined in a subclass.

final

It cannot be overridden in class extensions.

native

Its body is implemented in another programming language.

private

It is accessible only from within its own class.

protected

It is accessible only from within its own class and its extensions.

public

It is accessible from all classes.

static

It has no implicit argument.

strictfp

Its floating point results will be platform independent.

synchronized

It must be locked before it can be invoked by a thread.

volatile

It may be modified by asynchronous threads. Table 1.4 Method modifiers

Modifier final

Meaning It must be initialized and cannot be changed. Table 1.5 Local variable modifier

The three access modifiers, public, protected, and private, are used to specify where the declared member (class, field, constructor, or method) can be used. If none of these is specified, then the entity has package access, which means that it can be accessed from any class in the same package. The modifier final has three different meanings, depending upon which kind of entity it modifies. If it modifies a class, final means that the class cannot be extended to a subclass. (See Chapter 9.) If it modifies a field or a local variable, it means that the variable must be initialized and cannot be changed, that is, it is a constant. If it modifies a method, it means that the method cannot be overridden in any subclass. The modifier static means that the member can be accessed only as an agent of the class itself, as opposed to being bound to a specific object instantiated from the class. For example, the format() method, invoked at line 34 in the Line class in Example 1.5 on page 6 is a static method: return String.format("%d/%d", num, den);

10

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

It is bound to the String class itself, accessed as String.format(). On the other hand, the value() method, invoked at line 7 in the test program is a nonstatic method. It is bound to the object x, an instance of the Ratio class, and is accessed x.value(). A static method is also called a class method; a nonstatic method is also called an instance method. The object to which an instance method is bound in an invocation is called its implicit argument for that invocation. For example, the implicit argument in the invocation x.equals(xx) is the object x. (xx is the explicit argument.) Note that every program’s main() method is a static method. COMPOSITION, AGGREGATION, AND INHERITANCE There are several different ways to associate one class with another: composition, aggregation, and inheritance. When a class A contains references to instances of a class B and controls all access to those instances, we say that A is a composition of B. For example, a University class would be a composition of Department objects. Each Department object belongs to a unique University object, which controls access to its department. If A is a composition of B, we say that an A object “owns a” B object. For example, a university owns a department. When a class A contains references to a class B whose instances exist and are accessible outside of A, we say that A is an aggregation of B. For example, in a university software system, a Department class would contain references to Professor objects who are members of the department, but who also exist outside the department. In fact, a professor could be a member of two different departments. If A is an aggregation of B, we say that an A object “has a” B object. For example, a department has a professor. When a class A includes all the members of a class B, we say that A is an extension of B, and that it inherits all the properties of B. For example, a Professor class would be an extension of a Person objects. If A is an extension of B, we say that an A object “is a” B object. For example, a professor is a person. Figure 1.6 illustrates how these three class associations are represented in UML. Composition is indicated by a filled diamond head adjacent to the composing class, aggregation is indicated by an empty diamond head adjacent to the aggregating class, and inheritance is indicated by an empty arrow head adjacent to the extended class. EXAMPLE 1.6 Implementing Associations 1 2

public class Person { private final String name;

3 4 5 6

public Person(String name) { this.name = new String(name); }

Figure 1.6 Class associations

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

11

7

public String getName() { return new String(name); }

8 9 10 11

}

Instances of the Person class represent people. 1 2

public class Professor extends Person { public static enum Rank {INSTR, ASST, ASSOC, PROF}

3

private Rank rank;

4 5

public Professor(String name, Rank rank) { super(name); this.rank = rank; }

6 7 8 9 10

public Rank getRank() { return rank; }

11 12 13 14

public void setRank(Rank rank) { this.rank = rank; }

15 16 17 18

}

The Professor class extends the Person class, inheriting its name field and its getName method. It defines at line 2 an enum field named Rank that specifies the four values INSTR, ASST, ASSOC, and PROF. Its constructor at line 6 requires the professor’s name and rank. Note how the Professor constructor uses the super keyword to invoke the Person constructor at line 7. 1 2 3 4

public class University { private static class Department { final String name; Set members;

5

public Department(String name) { this.name = new String(name); this.members = new HashSet(); }

6 7 8 9 10

public void add(Professor professor) { members.add(professor); }

11 12 13 14

}

15 16 17

private final String name; private Map<String, Department> departments;

18 19 20 21 22

public University(String name) { this.name = new String(name); this.departments = new TreeMap<String, Department>(); }

23 24 25 26 27

public String getName() { return new String(name); }

12

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

public void addDepartment(String name, Set members) { Department dept = new Department(name); departments.put(name, dept); for (Professor prof : members) { dept.add(prof); } }

28 29 30 31 32 33 34 35

public void add(Professor prof, String deptName) { Department dept = departments.get(deptName); if (dept == null) { throw new RuntimeException(deptName + " does not exist."); } else { dept.add(prof); } }

36 37 38 39 40 41 42 43 44

public Set<String> departments() { return departments.keySet(); }

45 46 47 48

}

The University class is a composite of Department objects. The existence of a department is dependent upon the existence of its university. Therefore, the Department class should be completely controlled and insulated by the University class. This is done by defining it to be a nested private static class at line 2. The University.Department class has two fields: name (a String), and members (a Set of Professors). It includes an add() method at line 11 for adding professors to the department. The University class has two fields: name (a String), and departments (a Map of Department objects, indexed by their names). It includes two add() methods (at lines 28 and 36) and an accessor method that returns the Set of department names (at line 45). Note that the University.Department class is an aggregate of Professor objects. The existence of a professor is independent of his or her department’s existence. Therefore, the Professor class is defined separately from the University.Department class. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class TestUniversity { public static void main(String[] args) { University jsu = new University("JavaStateUniversity"); Professor adams = new Professor("Adams", Professor.Rank.ASSOC); Professor baker = new Professor("Baker", Professor.Rank.ASST); Professor cohen = new Professor("Cohen", Professor.Rank.PROF); Set profs = new HashSet(); Collections.addAll(profs, adams, baker, cohen); jsu.addDepartment("Computer Science", profs); Professor davis = new Professor("Davis", Professor.Rank.ASST); Professor evans = new Professor("Evans", Professor.Rank.INSTR); profs.clear(); Collections.addAll(profs, davis, evans, baker); jsu.addDepartment("Biology", profs); adams.setRank(Professor.Rank.PROF); } }

This test program creates the university with two departments, each containing three professors. Note that Prof. Baker is a member of both departments.

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

13

The departments’ aggregation of professors is evidenced by two features of this program: A professor may belong to more than one department, and a professor’s attributes may be changed independently of his or her department: Prof. Adams is promoted to Professor.Rank.PROF at line 15.

Example 1.6 uses several classes that are defined in the Java Collections Framework (JCF). This library is part of the java.util package. The JCF is outlined in Chapter 4. Example 1.6 also uses two new Java features, introduced with Java 5.0: enum types, and the for-each construct. THE UNIFIED MODELING LANGUAGE The Unified Modeling Language (UML) is illustrated in Figure 1.6 on page 10 and shows the symbols representing three kinds of association between classes. These are summarized in Table 1.6. Association

Symbol

Composition Aggregation Inheritance Implementation Table 1.6 UML symbols

The implementation symbol is used to show that a class implements an interface. EXAMPLE 1.7 Implementing the Comparable Interface Change line 1 of Example 1.5 on page 6 to: 1

public class Ratio implements Comparable {

and then add these two methods: 2 3 4 5 6 7 8 9 10 11 12

public int compareTo(Object object) { if (object==this) { return 0; } else if (!(object instanceof Ratio)) { throw new IllegalArgumentException("Ratio type expected"); } Ratio that = (Ratio)object; normalize(this); normalize(that); return (this.num*that.den - that.num*this.den); }

13 14 15 16 17 18 19 20 21

private static void normalize(Ratio x) { if (x.num == 0) { // x == Ratio.ZERO x.den = 1; } else if (x.den < 0) { // change sign of num and den: x.num *= -1; x.den *= -1; } }

14

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

The Comparable interface requires the compareTo() method, as specified at line 2. The purpose of the method is to indicate whether the implicit argument is less than, equal to, or greater than the explicit argument. The indicator is the sign of the returned integer: Negative indicates that this < object, zero indicates that this = object, and positive indicates that this > object. In the case of ratios a/b and c/d, we can tell whether a/b < c/d by cross-multiplying and checking whether ad < bc. Since that case should be indicated by returning a negative number, we can simply return ad – bc. Indeed, the value of that expression will be negative, zero, or positive, when a/b < c/d, a/b = c/d, or a/b > c/d, respectively. However, that arithmetic trick works only if b > 0 and d > 0. To ensure that the denominators are not negative, we employ the static utility method defined at line 14. It ensures that the denominator of its argument is not negative.

Figure 1.7 illustrates how the implementation of an interface is represented in UML. The association symbol is a dashed arrow pointing to the interface. The diagram for the interface marks its name with the stereotype «interface». Note that an interface rectangle has only two parts, while a class rectangle has three. This is because interfaces have no fields. Figure 1.7 also illustrates how to represent package membership. The Comparable interface is part of the java.lang package, as indicated by the tab above the interface symbol.

Figure 1.7 Interface implementation in UML

POLYMORPHISM Java is a strongly typed language, which means that every variable must be declared to have a type which determines how that variable can be used. A char cannot be used where a boolean is expected, and a Ratio object cannot be used where a Person object is expected. But there are some situations where a variable of one type can be used where another type is expected. This is called polymorphism (literally, “many forms”) because the object appears to have more than one type. There are several kinds of polymorphism. The simplest kind is called inclusion polymorphism. Illustrated in Example 1.8, it refers to the ability of an object to invoke a method that it inherits. EXAMPLE 1.8 Inclusion Polymorphism 1 2 3 4 5 6

public class TestRatio { public static void main(String[] args) { Ratio x = new Ratio(22, 7); System.out.println("x.hashCode(): " + x.hashCode()); } }

The output is: x.hashCode(): 1671711

At line 4, the Ratio object x invokes the hashCode() method that it inherits from the Object class.

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

15

Another kind of polymorphism occurs with generic methods, where an actual type is substituted in for a type parameter. This is illustrated in Example 1.9. EXAMPLE 1.9 Parametric Polymorphism 1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class TestSort { public static void main(String[] args) { String[] countries = {"CN", "IN", "US", "ID", "BR"}; print(countries); Arrays.sort(countries); print(countries); Ratio[] ratios = new Ratio[3]; ratios[0] = new Ratio(22, 7); ratios[1] = new Ratio(25, 8); ratios[2] = new Ratio(28, 9); print(ratios); Arrays.sort(ratios); print(ratios); }

15

static void print(T[] a) { // generic method for (T t : a) { System.out.printf("%s ", t); } System.out.println(); }

16 17 18 19 20 21 22

}

Here is the output: CN IN US ID BR BR CN ID IN US 22/7 25/8 28/9 28/9 25/8 22/7 The print() method defined at line 16 is a generic method. It uses the type parameter T as a place-

holder for an actual type, which will be determined at run time. When the generic method is invoked at lines 4 and 6, the type String is used in place of T. When it is invoked at lines 11 and 13, the type Ratio is used. This makes the method polymorphic, capable of printing arrays of String objects and arrays of Ratio objects. The program also uses the generic sort() method that is defined in the java.util.Arrays class. It requires the type parameter T to be an extension of the Comparable interface, which both the String class and our Ratio class are.

Inclusion polymorphism and parametric polymorphism are both special cases of universal polymorphism. The other general kind of polymorphism is called ad hoc polymorphism which also has two special kinds, named overloading polymorphism and coercion. These are best illustrated with primitive types. The plus operator (+) is polymorphically overloaded: It means integer addition when used in the form 22 + 33; it means floating point addition when used in the form 2.2 + 3.3; and it means string concatenation when used in the form name + ", Esq.". Coercion occurs when a value of one type is implicitly converted to a value of another type when the context requires that other type. For example, when the compiler evaluates the expression 22 + 3.3, it interprets the plus operator as floating point addition, requiring both operands

16

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

to be either type float or type double. So it “coerces” the 22 into being 22.0 and then performs the operation. JAVADOC A Java program is a main class together with the other classes that it uses. Most classes are part of the standard Java Class Libraries provided by Sun Microsystems, Inc. These libraries are orgainzed into several package hierarchies, known collectively as the Application Programming Interface (API). The two most common package hierarchies are the java and javax hierarchies, parts of which are shown in Figure 1.8.

Figure 1.8 Parts of the java and javax package hierarchies

Complete documentation is provided for all the classes in the Java API. Also called Java API Specification, these javadocs are located at: http://java.sun.com/javase/6/docs/api/

The Javadoc for the String class, in the java.lang package, is shown in Figure 1.9 on page 17. Review Questions 1.1

What is a requirements document?

1.2

What is the difference between the design stage and the implementation stage in the development of software?

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

Figure 1.9 Javadoc for the java.lang.String class

1.3

What is the difference between the state and the behavior of a class?

1.4

What is an abstract data type?

1.5

What constitutes a Java program?

1.6

What kinds of members can a class have?

1.7

What is an implicit argument?

1.8

What is the purpose of the toString() method?

1.9

What is the purpose of the equals() method?

1.10 What's the difference among public, protected, and private? 1.11 What is a package? 1.12 What is the difference between an abstract class and an abstract data type?

17

18

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

1.13 What is the difference between a constructor and a method? 1.14 What is the difference between a class method and an instance method? 1.15 What is the difference between equality of objects and equality of the references that refer to them? 1.16 Explain the difference between the output from String s; System.out.println("s = " + s);

and the output from String s = new String(); System.out.println("s = " + s);

1.17 What is the purpose of declaring a field private and declaring a mutator method that allows the public to change it. Wouldn’t it be just as good to just make it public? 1.18 What is an enum type? 1.19 What is the difference between composition and aggregation? 1.20 What is polymorphism?

Problems 1.1

Translate this ADT into a Java interface: ADT: Point amplitude(): Real distanceTo(Point): Real equals(Point): Boolean magnitude(): Real toString(): String xCoordinate(): Real yCoordinate(): Real

1.2

Translate this ADT into a Java interface: ADT: Line contains(Point): Boolean equals(Line): Boolean isHorizontal(): Boolean isVertical(): Boolean slope(): Real toString(): String xIntercept(): Real yIntercept(): Real

1.3

Translate this ADT into a Java interface: ADT: Circle area(): Real center(): Point circumference(): Real contains(Point): Boolean equals(Circle): Boolean radius(): Real toString(): String

CHAP. 1]

1.4

OBJECT-ORIENTED PROGRAMMING

19

Translate this ADT into a Java interface: ADT: Polynomial degree(): int derivative(): Polynomial equals(Point): Boolean sum(Polynomial): Polynomial toString(): String valueAt(Real): Real

1.5

Implement the ADT in Problem 1.1 with a Java class, and draw its UML diagram.

1.6

Implement the ADT in Problem 1.2 with a Java class, and draw its UML diagram.

1.7

Implement the ADT in Problem 1.3 with a Java class, and draw its UML diagram.

1.8

Implement the ADT in Problem 1.4 with a Java class, and draw its UML diagram.

Answers to Review Questions 1.1

The requirements document of a software development project is a precise specification of what the software should do.

1.2

In the development of software, the design stage identifies the components (classes) to be used and the relationships among them. The implementation stage is where the computer progam code is actually written.

1.3

The state of a class consists of the values of its fields. The behavior of a class is defined by its methods.

1.4

An abstract data type is a specification of the type’s operations: what an instance of that type can do.

1.5

A Java program is a Java class with a main() method? The main() method must have this header: public static void main(String[] args)

1.6

A class member may be a field, a constructor, a method, a nested class, a nested interface, or an enum type.

1.7

The implicit argument of a method is the object to which the method invocation is bound.

1.8

The toString() method returns a String object that represents the state of its implicit argument.

1.9

The equals() method returns true if and only if states (contents) of its implicit and explicit arguments are the same.

1.10

A class member that is declared public is accessible from any other class. A class member that is declared protected is accessible only from its own class and subclasses (extensions). A class member that is declared private is accessible only from its own class.

1.11

A package is a namespace, that is, a name for a group of classes, interfaces, and enum types that can be used to distinguish those from other classes, interfaces, and enum types with the same name.

1.12

An abstract class is a Java class with at least one abstract method—a method that has no body. An abstract data type is a specification of a type’s operations that could be implemented in any object-oriented programming language. A constructor is a member function of a class that is used to create objects of that class. It has the same name as the class itself, has no return type, and is invoked using the new operator. A method is an ordinary member function of a class. It has its own name, a return type (which may be void), and is invoked using the dot operator. A class method is declared static and is invoked using the class name. For example,

1.13

1.14

double y = Math.abs(x);

invokes the class method abs() that is defined in the Math class. An instance method is declared without the static modifier and is invoked using the name of the object to which it is bound. For example,

20

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

double x = random.nextDouble();

invokes the class method nextDouble() that is defined in the Random class and is bound to the object random which is an instance of that class. 1.15

Two objects should be equal if they have the same data values (i.e., the same state). Two references are equal if they refer to the same object. The condition (p == q) tests equality of the references p and q, not the equality of the objects to which they refer.

1.16

The output from the code String s; System.out.println("s = " + s);

is s = null

The output from the code String s = new String(); System.out.println("s = " + s);

is s =

In the first case, the reference s is initialized by default to be null; there is no String object. In the second case, s is initialized to refer to the empty String object. 1.17

The advantage of forcing the public to use a mutator method to change a field is that you can control how the field is changed.

1.18

An enum type is a type, defined with the enum keyword that lists by name each possible value for the type.

1.19

When a type is composed of another type, the complete existence of that component type’s objects is controlled by the composing type’s object; the components are uniquely bound to it and cannout be changed by any outside object. With aggregation, the component elements exits outside of the collection, can be changed by other classes, and may even be components of other aggregates.

1.20

Polymorphism describes the way an object or variable may be treated in different contexts as though it has a different type. For example, inheritance allows an argument of type B to be passed to a parameter of type A if B extends A.

Solutions to Problems 1.1

public interface Point { public double amplitude(); public double distanceTo(Point point); public boolean equals(Object object); public double magnitude(); public String toString(); public double xCoordinate(); public double yCoordinate(); }

1.2

public interface Line { public boolean contains(Point point); public boolean equals(Object object); public boolean isHorizontal(); public boolean isVertical(); public double slope(); public String toString(); public double xIntercept(); public double yIntercept(); }

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

1.3

public interface Circle { public double area(); public Point center(); public double circumference(); public boolean contains(Point point); public boolean equals(Object object); public double radius(); public String toString(); }

1.4

public interface Polynomial { public int degree(); public Polynomial derivative(); public boolean equals(Object object); public Polynomial sum(Polynomial polynomial); public String toString(); public double valueAt(double x); }

1.5

public class MyPoint implements Point { private double x, y; public static Point ORIGIN = new MyPoint(); private MyPoint() { } public MyPoint(double x, double y) { this.x = x; this.y = y; } public double amplitude() { return Math.atan(y/x); } public double distanceTo(Point point) { if (point.equals(this)) { return 0.0; } else if (!(point instanceof MyPoint)) { throw new IllegalArgumentException("use a MyPoint object"); } else { MyPoint that = (MyPoint)point; double dx = that.x - this.x; double dy = that.y - this.y; return Math.sqrt(dx*dx + dy*dy); } } public boolean equals(Object object) { if (object==this) { return true; } else if (!(object instanceof MyPoint)) { return false; } MyPoint that = (MyPoint)object; return (that.x == this.x && that.y == this.y); } public double magnitude() { return Math.sqrt(x*x + y*y); }

21

22

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

public String toString() { return String.format("(%.2f,%.2f)", x, y); } public double xCoordinate() { return x; } public double yCoordinate() { return y; } }

1.6

public class MyLine implements Line { private double m, b; // slope, intercept public static Line X_AXIS = new MyLine(); private MyLine() { } public MyLine (double m, double b) { this.m = m; this.b = b; } public boolean contains(Point point) { double x = point.xCoordinate(); double y = point.yCoordinate(); return y == m*x + b; } public boolean equals(Object object) { if (object==this) { return true; } else if (!(object instanceof MyLine)) { return false; } MyLine that = (MyLine)object; return (that.m == this.m && that.b == this.b); } public boolean isHorizontal() { return m == 0.0; } public boolean isVertical() { return m == Double.POSITIVE_INFINITY || m==Double.NEGATIVE_INFINITY; } public double slope() { return m; } public String toString() { return String.format("y = %.2fx + %.2f", m, b); }

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

public double xIntercept() { if (isHorizontal()) { throw new RuntimeException("this line is horizontal"); } return -b/m; } public double yIntercept() { if (isVertical()) { throw new RuntimeException("this line is vertical"); } return b; } }

1.7

public class MyCircle implements Circle { private Point c; // center private double r; // radius public MyCircle() { } public MyCircle(Point c, double r) { this.c = c; this.r = r; } public double area() { return Math.PI*r*r; } public Point center() { return c; } public double circumference() { return 2*Math.PI*r; } public boolean contains(Point point) { double x = point.xCoordinate(); double y = point.yCoordinate(); return x*x + y*y < r*r; } public boolean equals(Object object) { if (object==this) { return true; } else if (!(object instanceof MyCircle)) { return false; } MyCircle that = (MyCircle)object; return (that.c == this.c && that.r == this.r); } public double radius() { return r; }

23

24

OBJECT-ORIENTED PROGRAMMING

[CHAP. 1

public String toString() { return String.format("[Center: %.2fx; Radius: %.2f]", c, r); } }

1.8

public class MyPolynomial implements Polynomial { private double[] c; // coefficients public MyPolynomial(double[] a) { // a[i] = coeffficient of x^i int n = c.length; c = new double[n]; System.arraycopy(a, 0, c, 0, n); } public int degree() { return c.length - 1; } public Polynomial derivative() { double da[] = new double[c.length-1]; for (int i=0; i 1 && c[1] != 0.0) { buf.append(String.format(" + %.2f", c[1])); }

CHAP. 1]

OBJECT-ORIENTED PROGRAMMING

for (int i=2; i= 0, then a[i] == x; otherwise i == -1; int lo = 0; int hi = a.length; while (lo < hi) { // step 1 // INVARIANT: if a[j]==x then lo 1) { if (n%p==0) { primes += (primes.length()==0?"":"*") + p; n /= p; } else p = next(); if (p == -1) { primes += " OVERFLOW"; break; }

43

44

ARRAYS

} setLast(); return primes; }

2.24

public class TestGoldbach { public static void main(String[] args) { Primes.setSize(1000); System.out.println("4 = 2+2"); for (int n = 6; n < 100; n += 2) { System.out.print(n); for (int p = 3; p 9) { if (n/p10 != n%10) { return false; } n /= 10; // remove rightmost digit from n p10 /= 10; n %= p10; // remove leftmost digit from n } return true; // single digit integers are palindromic } }

45

CHAPTER 3

Linked Data Structures

Arrays work well for unordered sequences, and even for ordered sequences if they don’t change much. But if you want to maintain an ordered list that allows quick insertions and deletions, you should use a linked data structure. This chapter shows how to do that. MAINTAINING AN ORDERED ARRAY Chapter 2 outlines how the binary search can find elements very quickly in an array that is sorted. This suggests that we should keep our arrays in sorted order. But inserting new elements in an ordered array is difficult. The main problem is that we have to shift all the larger elements forward to make room for the new element to be placed in its correct ordered position. This can be done by the insert() method shown in Example 3.1. EXAMPLE 3.1 Inserting into an Ordered Array void insert(int[] a, int n, int x) { // preconditions: a[0] x) break; p = p.next; } p.next = new Node(x,p.next); return start; }

Using the two-argument constructor obviates the need for that extra temporary assignment: start = new Node(x,start);

Moreover, it also handles the first case, where the list was empty, because in that case, start is null, and passing null to the second parameter is equivalent to using the one-arg constructor:

CHAP. 3]

LINKED DATA STRUCTURES

start = new Node(x, null); start = new Node(x);

// //

59

equivalent equivalent

So once again, the two-argument constructor provides the best solution. Note that unlike the simpler version in Example 3.11, the complete insert() method in Example 3.12 has to return the start node reference, because that reference may be changed at line 5. DELETING FROM A SORTED LINKED LIST Implementing an ordered list with a linked structure makes insertion far more efficient because it eliminates the need to shift elements. The same is true for deletion. Like the insert() method, the delete() method has two main parts: (1) find the element; (2) delete it. It also handles the special case at the front of the list separately. Example 3.13 shows the delete() method. EXAMPLE 3.13 Linked List Deletion Node delete(Node start, int x) { // precondition: the list is in ascending order; 3 // postconditions: the list is in ascending order, and if it did 4 // contains x, then the first occurrence of x has been deleted; 5 if (start == null || start.data > x) { // x is not in the list 6 return start; 7 } else if (start.data == x) { // x is the first element in the list 8 return start.next; 9 } 10 for (Node p = start; p.next != null; p = p.next) { 11 if (p.next.data > x) { 12 break; // x is not in the list 13 } else if (p.next.data == x) { // x is in the p.next node 14 p.next = p.next.next; // delete it 15 break; 16 } 17 } 18 return start; 19 } If the list is empty, then start == null and nothing has to be done. Also, if the first element is greater than x, then since the list is sorted, all the elements must be greater than x, so x is not in the list. Both of 1 2

these cases are handled first at line 5. If the first element in the list equals x, then it is deleted at line 8. This is done by returning start.next to start, as shown in Figure 3.23. If no other reference is pointing to the original start node, then it will be deleted by the Java “garbage collector.” If the first element of the list is less than x, then the for loop at line 10 searches for the first element that is greater than or equal to x. If it finds one greater, then the method breaks at line 12 and returns without changing the list. If it finds an element equal to x, then it deletes it at line 14. This is illustrated in Figure 3.24.

NESTED CLASSES In Java, a class member may be a field, a constructor, a method, an interface, or another class. A class that is a member of another class is called a nested class.

60

LINKED DATA STRUCTURES

[CHAP. 3

Figure 3.23 Deleting the first element from a sorted linked list

Figure 3.24 Deleting any other element from a sorted linked list

If the only place where a class Y will be used is within another class X, then class Y should be nested within class X. This is an important example of the information hiding principle that we have applied in other contexts. If X is any type (class or interface) and Y is any other type nested within X, then every member of X is accessible from Y and every member of Y is accessible from X. This is illustrated in Example 3.14. The Main class in Example 3.14 has a private nested class named Nested. Both classes have a private int field. Main declares and initializes m at line 2; Nested declares and initializes n at line 15. The Nested class also defines a private method f() at line 17.

CHAP. 3]

LINKED DATA STRUCTURES

61

EXAMPLE 3.14 Accessibility from Nested Classes 1 2

public class Main { private int m = 22;

3

public Main() { Nested nested = new Nested(); System.out.println("Outside of Nested; nested.n = " + nested.n); nested.f(); }

4 5 6 7 8 9

public static void main(String[] args) { new Main(); }

10 11 12 13

private class Nested { private int n = 44;

14 15 16

private void f() { System.out.println("Inside of Nested; m = " + m); }

17 18 19

}

20 21

}

The output is: Outside of Nested; nested.n = 44 Inside of Nested; m = 22 The main() method invokes the Main() constructor at line 11. That instantiates the Nested class at line 5. The private field n of the Nested class is accessed at line 6, and the private method f() of the Nested class is accessed at line 7. This shows that private members of a nested class are accessible from its enclosing class. Symmetrically, the private members of the enclosing class are accessible from

within its nested class, as demonstrated by line 18.

The UML symbol for the nesting of one class inside another uses a circle with a plus sign inside in place of the arrowhead, as shown in Figure 3.25. Since all members of a Figure 3.25 UML diagram for a nested class private nested class are still accessible from anywhere else in the enclosing class, those members are usually declared without any access modifier (private, protected, or public), for simplicity. Normally, a nested class should be declared static unless its instances need to access nonstatic members of its enclosing class. (A nested class that is nonstatic is called an inner class.) The Node class defined in Example 3.10 on page 56 is used only within the context of the linked lists that are being implemented. So it should be nested inside its List class. Moreover, since nodes have no need to access List methods or fields, the Node class should be declared as a static nested class. This is done at line 12 in Example 3.15 and is illustrated in Figure 3.26.

62

LINKED DATA STRUCTURES

[CHAP. 3

EXAMPLE 3.15 Nesting the Node Class within a LinkedList Class 1 2

public class LinkedList { private Node start;

3

public void insert(int x) { // Insert lines 2-14 of Example 3.12 on page 58 }

4 5 6 7

public void delete(int x) { // Insert lines 2-18 of Example 3.13 on page 59 }

8 9 10 11

private static class Node { // Insert lines 2-12 of Example 3.10 on page 56 }

12 13 14 15

}

Hiding the Node class within the LinkedList class encapsulates the LinkedList class, making it selfcontained and concealing its implementation details. A developer could change the implementation without having to modify any code outside of that class.

Figure 3.26 A Node class nested within a LinkedList class

Review Questions 3.1

Why is an array such an inefficient data structure for a dynamic sorted list?

3.2

What is an index array?

3.3

If linked lists are so much better than arrays, why are arrays used at all?

3.4

Why does insertion at the front of a linked list have to be done differently from insertion elsewhere?

3.5

Why are the lists backwards in the BigInt class?

Problems 3.1

Write and test this method, similar to the insert() method in Example 3.1 on page 46: void delete(int[] a, int n, int x)

// precondition: 0 x: while (i < n && a[i] at line 1, then the method would only apply to collections whose element type is specified as Object. For example, it could not be used to print a HashSet<String> because that is not an extension of Collection.

CHAP. 4]

THE JAVA COLLECTIONS FRAMEWORK

77

The wildcard type can be used more selectively to limit the range of types that can be used in its place. For example, if you wanted to restrict the print() method in Example 4.5 to extensions of a Person class, then you would replace line 1 with: 1

static void print(Collection