Data Structures and Problem Solving Using Java 4th Edition by Mark Weiss 0321541405 9780321541406
Data Structures and Problem Solving Using Java 4th Edition by Mark Weiss 0321541405 9780321541406
_____ Follow the link below to get your download now _____
https://ebookball.com/product/data-structures-and-problem-
solving-using-java-4th-edition-by-mark-
weiss-0321541405-9780321541406-17186/
https://ebookball.com/product/data-structures-and-problem-solving-
using-java-4th-edition-by-mark-allen-weiss-
isbn-0321541405-978-0321541406-16342/
https://ebookball.com/product/data-structures-and-problem-solving-
using-c-2nd-edition-by-malik-isbn-0324782012-978-0324782011-16350/
https://ebookball.com/product/data-structures-and-algorithm-analysis-
in-c-4th-edition-by-mark-weiss-013284737x-9780132847377-15292/
https://ebookball.com/product/problem-solving-in-data-structures-and-
algorithms-using-c-1st-edition-by-hemant-jain-
isbn-9352655915-9789352655915-15768/
Problem Solving in Data Structures and Algorithms Using C
1st Edition by Hemant Jain ISBN 1540407306 9781540407306
https://ebookball.com/product/problem-solving-in-data-structures-and-
algorithms-using-c-1st-edition-by-hemant-jain-
isbn-1540407306-9781540407306-15866/
https://ebookball.com/product/data-structures-and-algorithm-analysis-
in-javatm-3rd-edition-by-mark-weiss-9780133465013-0133465012-18710/
https://ebookball.com/product/data-structures-abstraction-and-design-
using-java-2rd-edition-by-elliot-koffman-paul-
wolfgang-9781119239147-15300/
Data Structures &
Problem Solving
Using Java
fourth edition
This page intentionally left blank
Data Structures &
Problem Solving
Using Java
fourth edition
ISBN-13: 9780321541406
ISBN-10: 0321541405
1 2 3 4 5 6 7 8 9 10⎯CRS⎯12 11 10 09
To David and David.
This page intentionally left blank
preface
preface
T his book is designed for a two-semester sequence in computer science,
beginning with what is typically known as Data Structures and continuing
with advanced data structures and algorithm analysis. It is appropriate for the
courses from both the two-course and three-course sequences in “B.1 Intro-
ductory Tracks,” as outlined in the final report of the Computing Curricula
2001 project (CC2001)—a joint undertaking of the ACM and the IEEE.
The content of the Data Structures course has been evolving for some
time. Although there is some general consensus concerning topic coverage,
considerable disagreement still exists over the details. One uniformly
accepted topic is principles of software development, most notably the con-
cepts of encapsulation and information hiding. Algorithmically, all Data
Structures courses tend to include an introduction to running-time analysis,
recursion, basic sorting algorithms, and elementary data structures. Many uni-
versities offer an advanced course that covers topics in data structures, algo-
rithms, and running-time analysis at a higher level. The material in this text
has been designed for use in both levels of courses, thus eliminating the need
to purchase a second textbook.
Although the most passionate debates in Data Structures revolve around
the choice of a programming language, other fundamental choices need to be
made:
summary of changes
in the fourth edition
1. This edition provides additional discussion on using classes (Chapter 2),
writing classes (Chapter 3), and interfaces (Chapter 4).
2. Chapter 6 contains additional material discussing the running time of
lists, the use of maps, and the use of views in the Java Collections API.
3. The Scanner class is described, and code throughout the text makes use
of the Scanner class.
4. Chapter 9 describes and implements the 48-bit linear congruential gener-
ator that is part of both the Java and many C++ libraries.
5. Chapter 20 has new material on separate chaining hash tables and the
String hashCode method.
6. There are numerous revisions to the text that improve on the prose in the
previous edition.
7. Many new exercises are provided in Parts I, II, and IV.
a unique approach
My basic premise is that software development tools in all languages come with
large libraries, and many data structures are part of these libraries. I envision an
eventual shift in emphasis of data structures courses from implementation to
preface ix
use. In this book I take a unique approach by separating the data structures into
their specification and subsequent implementation and taking advantage of an
already existing data structures library, the Java Collections API.
A subset of the Collections API suitable for most applications is discussed
in a single chapter (Chapter 6) in Part Two. Part Two also covers basic analy-
sis techniques, recursion, and sorting. Part Three contains a host of applica-
tions that use the Collections API’s data structures. Implementation of the
Collections API is not shown until Part Four, once the data structures have
already been used. Because the Collections API is part of Java, students can
design large projects early on, using existing software components.
Despite the central use of the Collections API in this text, it is neither a book
on the Collections API nor a primer on implementing the Collections API spe-
cifically; it remains a book that emphasizes data structures and basic problem-
solving techniques. Of course, the general techniques used in the design of data
structures are applicable to the implementation of the Collections API, so sev-
eral chapters in Part Four include Collections API implementations. However,
instructors can choose the simpler implementations in Part Four that do not dis-
cuss the Collections API protocol. Chapter 6, which presents the Collections
API, is essential to understanding the code in Part Three. I attempted to use only
the basic parts of the Collections API.
Many instructors will prefer a more traditional approach in which each
data structure is defined, implemented, and then used. Because there is no
dependency between material in Parts Three and Four, a traditional course can
easily be taught from this book.
prerequisites
Students using this book should have knowledge of either an object-oriented
or procedural programming language. Knowledge of basic features, including
primitive data types, operators, control structures, functions (methods), and
input and output (but not necessarily arrays and classes) is assumed.
Students who have taken a first course using C++ or Java may find the first
four chapters “light” reading in some places. However, other parts are definitely
“heavy” with Java details that may not have been covered in introductory courses.
Students who have had a first course in another language should begin at
Chapter 1 and proceed slowly. If a student would like to use a Java reference
book as well, some recommendations are given in Chapter 1.
Knowledge of discrete math is helpful but is not an absolute prerequi-
site. Several mathematical proofs are presented, but the more complex
proofs are preceded by a brief math review. Chapters 7 and 19–24 require
x preface
java
This textbook presents material using the Java programming language. Java
is a language that is often examined in comparison with C++. Java offers
many benefits, and programmers often view Java as a safer, more portable,
and easier-to-use language than C++.
The use of Java requires that some decisions be made when writing a text-
book. Some of the decisions made are as follows:
1. The minimum required compiler is Java 5. Please make sure you are
using a compiler that is Java 5-compatible.
2. GUIs are not emphasized. Although GUIs are a nice feature in Java,
they seem to be an implementation detail rather than a core Data
Structures topic. We do not use Swing in the text, but because many
instructors may prefer to do so, a brief introduction to Swing is pro-
vided in Appendix B.
3. Applets are not emphasized. Applets use GUIs. Further, the focus of
the course is on data structures, rather than language features. Instruc-
tors who would like to discuss applets will need to supplement this
text with a Java reference.
4. Inner classes are used. Inner classes are used primarily in the imple-
mentation of the Collections API, and can be avoided by instructors
who prefer to do so.
5. The concept of a pointer is discussed when reference variables are
introduced. Java does not have a pointer type. Instead, it has a refer-
ence type. However, pointers have traditionally been an important
Data Structures topic that needs to be introduced. I illustrate the
concept of pointers in other languages when discussing reference
variables.
6. Threads are not discussed. Some members of the CS community
argue that multithreaded computing should become a core topic in the
introductory programming sequence. Although it is possible that this
will happen in the future, few introductory programming courses dis-
cuss this difficult topic.
preface xi
text organization
In this text I introduce Java and object-oriented programming (particularly
abstraction) in Part One. I discuss primitive types, reference types, and some
of the predefined classes and exceptions before proceeding to the design of
classes and inheritance.
In Part Two, I discuss Big-Oh and algorithmic paradigms, including
recursion and randomization. An entire chapter is devoted to sorting, and a
separate chapter contains a description of basic data structures. I use the Col-
lections API to present the interfaces and running times of the data structures.
At this point in the text, the instructor may take several approaches to present
the remaining material, including the following two.
1. Discuss the corresponding implementations (either the Collections
API versions or the simpler versions) in Part Four as each data struc-
ture is described. The instructor can ask students to extend the classes
in various ways, as suggested in the exercises.
2. Show how each Collections API class is used and cover implementa-
tion at a later point in the course. The case studies in Part Three can
be used to support this approach. As complete implementations are
available on every modern Java compiler, the instructor can use the
Collections API in programming projects. Details on using this
approach are given shortly.
Part Five describes advanced data structures such as splay trees, pairing
heaps, and the disjoint set data structure, which can be covered if time permits
or, more likely, in a follow-up course.
the general concept of a pointer—even though Java does not have pointers—so
that students learn this important Data Structures topic. Several of the basic
reference types (strings, arrays, files, and Scanners) are illustrated, and the use
of exceptions is discussed. Chapter 3 continues this discussion by describing
how a class is implemented. Chapter 4 illustrates the use of inheritance in
designing hierarchies (including exception classes and I/O) and generic com-
ponents. Material on design patterns, including the wrapper, adapter, and dec-
orator patterns can be found in Part One.
Part Two focuses on the basic algorithms and building blocks. In
Chapter 5 a complete discussion of time complexity and Big-Oh notation
is provided. Binary search is also discussed and analyzed. Chapter 6 is
crucial because it covers the Collections API and argues intuitively what
the running time of the supported operations should be for each data struc-
ture. (The implementation of these data structures, in both Collections
API-style and a simplified version, is not provided until Part Four). This
chapter also introduces the iterator pattern as well as nested, local, and
anonymous classes. Inner classes are deferred until Part Four, where they
are discussed as an implementation technique. Chapter 7 describes recur-
sion by first introducing the notion of proof by induction. It also discusses
divide-and-conquer, dynamic programming, and backtracking. A section
describes several recursive numerical algorithms that are used to imple-
ment the RSA cryptosystem. For many students, the material in the second
half of Chapter 7 is more suitable for a follow-up course. Chapter 8
describes, codes, and analyzes several basic sorting algorithms, including
the insertion sort, Shellsort, mergesort, and quicksort, as well as indirect
sorting. It also proves the classic lower bound for sorting and discusses the
related problems of selection. Finally, Chapter 9 is a short chapter that dis-
cusses random numbers, including their generation and use in randomized
algorithms.
Part Three provides several case studies, and each chapter is organized
around a general theme. Chapter 10 illustrates several important techniques
by examining games. Chapter 11 discusses the use of stacks in computer lan-
guages by examining an algorithm to check for balanced symbols and the
classic operator precedence parsing algorithm. Complete implementations
with code are provided for both algorithms. Chapter 12 discusses the basic
utilities of file compression and cross-reference generation, and provides a
complete implementation of both. Chapter 13 broadly examines simulation by
looking at one problem that can be viewed as a simulation and then at the
more classic event-driven simulation. Finally, Chapter 14 illustrates how data
preface xiii
chapter dependencies
Generally speaking, most chapters are independent of each other. However,
the following are some of the notable dependencies.
n Part One (Tour of Java): The first four chapters should be covered in their
entirety in sequence first, prior to continuing on to the rest of the text.
n Chapter 5 (Algorithm Analysis): This chapter should be covered prior
to Chapters 6 and 8. Recursion (Chapter 7) can be covered prior to
this chapter, but the instructor will have to gloss over some details
about avoiding inefficient recursion.
n Chapter 6 (The Collections API): This chapter can be covered prior to
or in conjunction with material in Part Three or Four.
n Chapter 7 (Recursion): The material in Sections 7.1–7.3 should be
covered prior to discussing recursive sorting algorithms, trees, the
Tic-Tac-Toe case study, and shortest-path algorithms. Material such
as the RSA cryptosystem, dynamic programming, and backtracking
(unless Tic-Tac-Toe is discussed) is otherwise optional.
n Chapter 8 (Sorting Algorithms): This chapter should follow Chapters
5 and 7. However, it is possible to cover Shellsort without Chapters 5
and 7. Shellsort is not recursive (hence there is no need for Chapter 7),
and a rigorous analysis of its running time is too complex and is not
covered in the book (hence there is little need for Chapter 5).
n Chapter 15 (Inner Classes and Implementations of ArrayLists):
This material should precede the discussion of the Collections API
implementations.
n Chapters 16 and 17 (Stacks and Queues/Linked Lists): These chapters
may be covered in either order. However, I prefer to cover Chapter 16
first because I believe that it presents a simpler example of linked lists.
n Chapters 18 and 19 (Trees/ Binary Search Trees): These chapters can
be covered in either order or simultaneously.
separate entities
The other chapters have little or no dependencies:
[4]
The relative rather than the absolute age of the rocks can be
determined from a study of their fossil content. These fossils are
compared with collections from various places in the world where
the standard geologic time scale assigns them a place (see Fig.
4). The Park rocks were deposited during the Ordovician Period.
How is a standard geologic time scale put together? Several
geologists first worked out the sequences of rocks according to
the Law of Superposition in Great Britain and neighboring parts of
Europe. When systematic collections of fossils were made from
these layers and arranged according to age it was found that
certain fossils occurring in rocks in distant areas were identical
and occupied the same relative age position. These fossils were
considered to be of the same relative age. Fossils found in the
Park can be compared with these reference fossils and a relative
geologic age can be assigned to them. Absolute ages can be
determined in some cases by the use of rates of decay of
radioactive elements and in general these ages agree with the
relative ages derived through the use of fossils.
[5]
The capitalized syllable is the accented syllable.
[6]
An index fossil is used to date the rocks in which it occurs. A good
index fossil must be abundant, widespread and easily recognized.
Its vertical range is restricted to a small number of rock layers,
therefore the geological span of life of a good index fossil is
usually short.
[7]
Chitin is a colorless horny substance similar to the material which
makes up fingernails.
[8]
The black color is due to an abundance of finely divided organic
(plant and animal) material within the rock.
[9]
A quartzite is either a metamorphic or sedimentary rock consisting
of fragments of the mineral quartz (SiO₂) which are cemented
together by silica (quartz). The combination of quartz fragments
held together by quartz cement creates a very hard rock which
oftentimes will break across the fragments rather than around
them. The quartzites of the Park area are primarily of a
sedimentary origin. For a description of the three major rock
groups, of which the sedimentary and metamorphic groups are
two, see footnote, D.A.R. State Park, page 6. A dolostone is a
sedimentary rock composed of fragmental, concretionary, or
precipitated dolomite (a mineral of chemical composition,
CaMg(CO₃)₂) of organic or inorganic origin.
[10]
The black color is due to the inclusion of finely disseminated
carbonaceous material (animal and plant remains) within the rock.
[11]
This splitting or cleavage was produced after the layers had
hardened into rock. The cleavage planes were produced when the
rocks were subjected to pressures too great to withstand. In some
places these cleavage planes do not parallel the layers.
[12]
According to the basic geologic law, the Law of Superposition,
younger rocks (those deposited last) are always found resting on
older rocks (those deposited before the younger). The only time
that this is not true is when either breaks (faults) or folds in the
earth’s crust place the layers in an inverted order, as in the case
here cited.
[13]
The fault plane of a high-angle fault forms a large angle (generally
from 30 to 90 degrees) at its intersection with an imaginary
horizontal plane. The plane of a thrust fault, or low-angle fault,
forms a small angle (generally less than 30 degrees) at its
intersection with an imaginary horizontal plane.
[14]
This is the Burlington till (Stewart, 1961) and was deposited from
the Burlington Ice Lobe during its period of wasting. The till is a
hodge-podge mixture of clay, sand and pebbles and is usually
brown in color.
[15]
A kame is a mound or ridge of poorly sorted (sometimes well-
sorted, that is, made up of all the same sized particles) water
deposited materials. Most kames are ice-contact features; that is
to say, the materials which make up the kame were deposited in
contact with a glacial ice surface. The Mt. Philo kame may be the
filling of an ice-free area during the final melting of the glacial ice.
[16]
Delta is the name of the fourth letter of the Greek alphabet, the
capital form of which is an equilateral triangle. The triangular-
shaped tract of land formed by the deposit of river sediment at
river mouths is named for the triangular shape of the capital
Greek letter delta.
Transcriber’s Notes
Silently corrected a few typos.
Retained publication information from the printed edition: this
eBook is public-domain in the country of publication.
In the text versions only, text in italics is delimited by
_underscores_.
*** END OF THE PROJECT GUTENBERG EBOOK THE GEOLOGY OF
D.A.R. STATE PARK, MT. PHILO STATE FOREST PARK, SAND BAR
STATE PARK ***
Updated editions will replace the previous one—the old editions will
be renamed.
1.D. The copyright laws of the place where you are located also
govern what you can do with this work. Copyright laws in most
countries are in a constant state of change. If you are outside the
United States, check the laws of your country in addition to the
terms of this agreement before downloading, copying, displaying,
performing, distributing or creating derivative works based on this
work or any other Project Gutenberg™ work. The Foundation makes
no representations concerning the copyright status of any work in
any country other than the United States.
1.E.6. You may convert to and distribute this work in any binary,
compressed, marked up, nonproprietary or proprietary form,
including any word processing or hypertext form. However, if you
provide access to or distribute copies of a Project Gutenberg™ work
in a format other than “Plain Vanilla ASCII” or other format used in
the official version posted on the official Project Gutenberg™ website
(www.gutenberg.org), you must, at no additional cost, fee or
expense to the user, provide a copy, a means of exporting a copy, or
a means of obtaining a copy upon request, of the work in its original
“Plain Vanilla ASCII” or other form. Any alternate format must
include the full Project Gutenberg™ License as specified in
paragraph 1.E.1.
• You pay a royalty fee of 20% of the gross profits you derive
from the use of Project Gutenberg™ works calculated using the
method you already use to calculate your applicable taxes. The
fee is owed to the owner of the Project Gutenberg™ trademark,
but he has agreed to donate royalties under this paragraph to
the Project Gutenberg Literary Archive Foundation. Royalty
payments must be paid within 60 days following each date on
which you prepare (or are legally required to prepare) your
periodic tax returns. Royalty payments should be clearly marked
as such and sent to the Project Gutenberg Literary Archive
Foundation at the address specified in Section 4, “Information
about donations to the Project Gutenberg Literary Archive
Foundation.”
• You comply with all other terms of this agreement for free
distribution of Project Gutenberg™ works.
1.F.
1.F.4. Except for the limited right of replacement or refund set forth
in paragraph 1.F.3, this work is provided to you ‘AS-IS’, WITH NO
OTHER WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR ANY PURPOSE.
Please check the Project Gutenberg web pages for current donation
methods and addresses. Donations are accepted in a number of
other ways including checks, online payments and credit card
donations. To donate, please visit: www.gutenberg.org/donate.
Most people start at our website which has the main PG search
facility: www.gutenberg.org.
Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.
ebookball.com