Download the full version of the ebook now at ebooksecure.

com

(eBook PDF) Data Structures and Problem

Solving Using Java 4th Edition

https://ebooksecure.com/product/ebook-pdf-data-
structures-and-problem-solving-using-java-4th-
edition/

Explore and download more ebook at https://ebooksecure.com

 Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

(eBook PDF) Data Structures and Other Objects Using Java

4th Edition

https://ebooksecure.com/product/ebook-pdf-data-structures-and-other-
objects-using-java-4th-edition/

ebooksecure.com

(eBook PDF) Data Structures and Abstractions with Java 4th

Edition

https://ebooksecure.com/product/ebook-pdf-data-structures-and-
abstractions-with-java-4th-edition/

ebooksecure.com

(eBook PDF) Data Structures and Abstractions with Java 4th

Global Edition

https://ebooksecure.com/product/ebook-pdf-data-structures-and-
abstractions-with-java-4th-global-edition/

ebooksecure.com

(eBook PDF) Starting Out With Visual Basic 7th Edition by

Tony Gaddis

https://ebooksecure.com/product/ebook-pdf-starting-out-with-visual-
basic-7th-edition-by-tony-gaddis/

ebooksecure.com
(eBook PDF) Introductory Econometrics: A Modern Approach
7th Edition by Jeffrey

https://ebooksecure.com/product/ebook-pdf-introductory-econometrics-a-
modern-approach-7th-edition-by-jeffrey/

ebooksecure.com

(eBook PDF) Strategic Management Awareness and Change 8th

Edition

https://ebooksecure.com/product/ebook-pdf-strategic-management-
awareness-and-change-8th-edition/

ebooksecure.com

(eBook PDF) Educational Research: Planning, Conducting,

and Evaluating Quantitative and Qualitative Research 6th
Edition
https://ebooksecure.com/product/ebook-pdf-educational-research-
planning-conducting-and-evaluating-quantitative-and-qualitative-
research-6th-edition/
ebooksecure.com

(eBook PDF) Chemistry 11th Edition by Raymond Chang

https://ebooksecure.com/product/ebook-pdf-chemistry-11th-edition-by-
raymond-chang/

ebooksecure.com

Immunology & Serology in Laboratory Medicine 7th Edition-

eBook PDF

https://ebooksecure.com/download/immunology-serology-in-laboratory-
medicine-ebook-pdf/

ebooksecure.com
500 AP Physics 1 questions to know by test day 2nd Edition
Anaxos Inc. - eBook PDF

https://ebooksecure.com/download/500-ap-physics-1-questions-to-know-
by-test-day-ebook-pdf/

ebooksecure.com
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 generator 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 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 analysis techniques,
recursion, and sorting. Part Three contains a host of applications 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 specifically; 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 several chapters in Part Four include
Collections API implementations. However, instructors can choose the simpler
implementations in Part Four that do not discuss 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 prerequisite. Several
mathematical proofs are presented, but the more complex proofs are preceded by a
brief math review. Chapters 7 and 19–24 require some degree of mathematical
sophistication. The instructor may easily elect to skip mathematical aspects of the
proofs by presenting only the results. All proofs in the text are clearly marked and are
separate from the body of the text.

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 textbook. 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 provided 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. Instructors 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 implementation
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 reference 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 discuss this difficult topic.
7. Some Java 5 features are not used. Including:
Static imports, not used because in my opinion it actually makes the code harder
to read.
Enumerated types, not used because there were few places to declare public
enumerated types that would be usable by clients. In the few possible places, it
did not seem to help the code’s readability.

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 Collections 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 structure 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 implementation 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.

chapter-by-chapter text organization

Part One consists of four chapters that describe the basics of Java used throughout the
text. Chapter 1 describes primitive types and illustrates how to write basic programs in
Java. Chapter 2 discusses reference types and illustrates 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 components. Material on design patterns, including the wrapper, adapter, and
decorator 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 structure. (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 recursion 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 implement 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 discusses 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 languages 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 structures are
used to implement several shortest path algorithms efficiently for graphs.
Part Four presents the data structure implementations. Chapter 15 discusses inner
classes as an implementation technique and illustrates their use in the ArrayList
implementation. In the remaining chapters of Part Four, implementations that use simple
protocols (insert, find, remove variations) are provided. In some cases, Collections
API implementations that tend to use more complicated Java syntax (in addition to
being complex because of their large set of required operations) are presented. Some
mathematics is used in this part, especially in Chapters 19–21, and can be skipped at
the discretion of the instructor. Chapter 16 provides implementations for both stacks
and queues. First these data structures are implemented using an expanding array, then
they are implemented using linked lists. The Collections API versions are discussed at
the end of the chapter. General linked lists are described in Chapter 17. Singly linked
lists are illustrated with a simple protocol, and the more complex Collections API
version that uses doubly linked lists is provided at the end of the chapter. Chapter 18
describes trees and illustrates the basic traversal schemes. Chapter 19 is a detailed
chapter that provides several implementations of binary search trees. Initially, the basic
binary search tree is shown, and then a binary search tree that supports order statistics
is derived. AVL trees are discussed but not implemented, but the more practical red–
black trees and AA-trees are implemented. Then the Collections API TreeSet and
TreeMap are implemented. Finally, the B-tree is examined. Chapter 20 discusses hash
tables and implements the quadratic probing scheme as part of HashSet and HashMap,
after examination of a simpler alternative. Chapter 21 describes the binary heap and
examines heapsort and external sorting.
Part Five contains material suitable for use in a more advanced course or for general
reference. The algorithms are accessible even at the first-year level. However, for
completeness, sophisticated mathematical analyses that are almost certainly beyond the
reach of a first-year student were included. Chapter 22 describes the splay tree, which
is a binary search tree that seems to perform extremely well in practice and is
competitive with the binary heap in some applications that require priority queues.
Chapter 23 describes priority queues that support merging operations and provides an
implementation of the pairing heap. Finally, Chapter 24 examines the classic disjoint
set data structure.
The appendices contain additional Java reference material. Appendix A lists the
operators and their precedence. Appendix B has material on Swing, and Appendix C
describes the bitwise operators used in Chapter 12.

chapter dependencies

Generally speaking, most chapters are independent of each other. However, the
following are some of the notable dependencies.
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.
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.
Chapter 6 (The Collections API): This chapter can be covered prior to or in
conjunction with material in Part Three or Four.
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.
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).
Chapter 15 (Inner Classes and Implementations of ArrayLists): This material
should precede the discussion of the Collections API implementations.
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.
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:

 Chapter 9 (Randomization): The material on random numbers can be covered
at any point as needed.
Part Three (Applications): Chapters 10–14 can be covered in conjunction with
or after the Collections API (in Chapter 6) and in roughly any order. There are a
few references to earlier chapters. These include Section 10.2 (Tic-Tac-Toe),
which refers to a discussion in Section 7.7, and Section 12.2 (cross-reference
generation), which refers to similar lexical analysis code in Section 11.1
(balanced symbol checking).
Chapters 20 and 21 (Hash Tables/A Priority Queue): These chapters can be
covered at any point.
Part Five (Advanced Data Structures): The material in Chapters 22–24 is self-
contained and is typically covered in a follow-up course.

mathematics

I have attempted to provide mathematical rigor for use in Data Structures courses that
emphasize theory and for follow-up courses that require more analysis. However, this
material stands out from the main text in the form of separate theorems and, in some
cases, separate sections or subsections. Thus it can be skipped by instructors in courses
that deemphasize theory.
In all cases, the proof of a theorem is not necessary to the understanding of the
theorem’s meaning. This is another illustration of the separation of an interface (the
theorem statement) from its implementation (the proof). Some inherently mathematical
material, such as Sections 7.4 (Numerical Applications of Recursion), can be skipped
without affecting comprehension of the rest of the chapter.

course organization

A crucial issue in teaching the course is deciding how the materials in Parts Two–Four
are to be used. The material in Part One should be covered in depth, and the student
should write one or two programs that illustrate the design, implementation, testing of
classes and generic classes, and perhaps object-oriented design, using inheritance.
Chapter 5 discusses Big-Oh notation. An exercise in which the student writes a short
program and compares the running time with an analysis can be given to test
comprehension.
In the separation approach, the key concept of Chapter 6 is that different data
structures support different access schemes with different efficiency. Any case study
(except the Tic-Tac-Toe example that uses recursion) can be used to illustrate the
applications of the data structures. In this way, the student can see the data structure and
how it is used but not how it is efficiently implemented. This is truly a separation.
Viewing things this way will greatly enhance the ability of students to think abstractly.
Students can also provide simple implementations of some of the Collections API
components (some suggestions are given in the exercises in Chapter 6) and see the
difference between efficient data structure implementations in the existing Collections
API and inefficient data structure implementations that they will write. Students can
also be asked to extend the case study, but again, they are not required to know any of
the details of the data structures.
Efficient implementation of the data structures can be discussed afterward, and
recursion can be introduced whenever the instructor feels it is appropriate, provided it
is prior to binary search trees. The details of sorting can be discussed at any time after
recursion. At this point, the course can continue by using the same case studies and
experimenting with modifications to the implementations of the data structures. For
instance, the student can experiment with various forms of balanced binary search trees.
Instructors who opt for a more traditional approach can simply discuss a case study
in Part Three after discussing a data structure implementation in Part Four. Again, the
book’s chapters are designed to be as independent of each other as possible.

exercises

Exercises come in various flavors; I have provided four varieties. The basic In Short
exercise asks a simple question or requires hand-drawn simulations of an algorithm
described in the text. The In Theory section asks questions that either require
mathematical analysis or asks for theoretically interesting solutions to problems. The In
Practice section contains simple programming questions, including questions about
syntax or particularly tricky lines of code. Finally, the Programming Projects section
contains ideas for extended assignments.

pedagogical features

Margin notes are used to highlight important topics.

The Key Concepts section lists important terms along with definitions and page
references.
 The Common Errors section at the end of each chapter provides a list of
commonly made errors.

References for further reading are provided at the end of most chapters.

supplements

A variety of supplemental materials are available for this text. The following resources
are available at http://www.aw.com/cssupport for all readers of this textbook:

Source code files from the book. (The On the Internet section at the end of each
chapter lists the filenames for the chapter’s code.)
In addition, the following supplements are available to qualified instructors. To access
them, visit http://www.pearsonhighered.com/cs and search our catalog by title for Data
Structures and Problem Solving Using Java. Once on the catalog page for this book,
select the link to Instructor Resources.
PowerPoint slides of all figures in the book.
Instructor’s Guide that illustrates several approaches to the material. It includes
samples of test questions, assignments, and syllabi. Answers to select exercises
are also provided.

acknowledgments

Many, many people have helped me in the preparation of this book. Many have already
been acknowledged in the prior edition and the related C++ version. Others, too
numerous to list, have sent e-mail messages and pointed out errors or inconsistencies in
explanations that I have tried to fix in this edition.
For this edition I would like to thank my editor Michael Hirsch, editorial assistant
Stephanie Sellinger, senior production supervisor Marilyn Lloyd, and project manager
Rebecca Lazure and her team at Laserwords. Thanks also go to Allison Michael and
Erin Davis in marketing and Elena Sidorova and Suzanne Heiser of Night & Day
Design for a terrific cover.
Some of the material in this text is adapted from my textbook Efficient C
Visit https://testbankfan.com
now to explore a rich
collection of testbank or
solution manual and enjoy
exciting offers!
Programming: A Practical Approach (Prentice Hall, 1995) and is used with
permission of the publisher. I have included end-of-chapter references where
appropriate.
My World Wide Web page, , will contain
updated source code, an errata list, and a link for receiving bug reports.

M. A. W.
Miami, Florida
contents

part one Tour of Java

chapter 1 primitive java

1.1 the general environment

1.2 the first program

1.2.1 comments

1.2.2

1.2.3 terminal output

1.3 primitive types

1.3.1 the primitive types

1.3.2 constants

1.3.3 declaration and initialization of primitive types

1.3.4 terminal input and output

1.4 basic operators

1.4.1 assignment operators

1.4.2 binary arithmetic operators

1.4.3 unary operators

1.4.4 type conversions

1.5 conditional statements

 1.5.1 relational and equality operators

1.5.2 logical operators

1.5.3 the statement

1.5.4 the statement

1.5.5 the statement

1.5.6 the statement

1.5.7 and

1.5.8 the statement

1.5.9 the conditional operator

1.6 methods
1.6.1 overloading of method names

1.6.2 storage classes

summary

key concepts

common errors

on the internet

exercises

references

chapter 2 reference types

2.1 what is a reference?

2.2 basics of objects and references

2.2.1 the dot operator (.)

2.2.2 declaration of objects

2.2.3 garbage collection

2.2.4 the meaning of =

2.2.5 parameter passing

2.2.6 the meaning of ==

2.2.7 no operator overloading for objects

2.3 strings
2.3.1 basics of string manipulation

2.3.2 string concatenation

2.3.3 comparing strings

2.3.4 other methods

2.3.5 converting other types to strings

2.4 arrays
2.4.1 declaration, assignment, and methods

2.4.2 dynamic array expansion

2.4.3

2.4.4 multidimensional arrays

2.4.5 command-line arguments

2.4.6 enhanced loop

2.5 exception handling

2.5.1 processing exceptions
 2.5.2 the clause

2.5.3 common exceptions

2.5.4 the and clauses

2.6 input and output

2.6.1 basic stream operations

2.6.2 the type

2.6.3 sequential files

summary

key concepts

common errors

on the internet

exercises

references

chapter 3 objects and classes

3.1 what is object-oriented programming?

3.2 a simple example

3.3 javadoc

3.4 basic methods

3.4.1 constructors

3.4.2 mutators and accessors

3.4.3 output and

Exploring the Variety of Random
Documents with Different Content
 SWEET CARROTS. (ENTREMETS.)

Boil quite tender some fine highly-flavoured carrots, press the

water from them, and rub them through the back of a fine hair-sieve;
put them into a clean saucepan or stewpan, and dry them thoroughly
over a gentle fire; then add a slice of fresh butter, and when this is
dissolved and well mixed with them, strew in a dessertspoonful or
more of powdered sugar, and a little salt; next, stir in by degrees
some good cream, and when this is quite absorbed, and the carrots
again appear dry, dish and serve them quickly with small sippets à la
Reine (see page 5), placed round them.
Carrots, 3 lbs., boiled quite tender: stirred over a gentle fire 5 to 10
minutes. Butter, 2 oz.; salt, 1/2 teaspoonful; pounded sugar, 1
dessertspoonful; cream, 1/2 pint, stewed gently together until quite
dry.
Obs.—For excellent mashed carrots omit the sugar, add a good
seasoning of salt and white pepper, and half a pint of rich brown
gravy; or for a plain dinner rather less than this of milk.
 MASHED (OR BUTTERED) CARROTS.

(A Dutch Receipt.)
Prepare some finely flavoured carrots as above, and dry them
over a gentle fire like mashed turnips; then for a dish of moderate
size mix well with them from two to three ounces of good butter, cut
into small bits, keeping them well stirred. Add a seasoning of salt
and cayenne, and serve them very hot, garnished or not at pleasure
with small sippets (croutons) of fried bread.
 CARROTS AU BEURRE, OR BUTTERED CARROTS.

(French.)
Either boil sufficient carrots for a dish quite tender, and then cut
them into slices a quarter of an inch thick, or first slice, and then boil
them: the latter method is the most expeditious, but the other best
preserves the flavour of the vegetable. Drain them well, and while
this is being done just dissolve from two to three ounces of butter in
a saucepan, and strew in some minced parsley, some salt, and white
pepper or cayenne; then add the carrots, and toss them very gently
until they are equally covered with the sauce, which should not be
allowed to boil: the parsley may be omitted at pleasure. Cold carrots
may be re-warmed in this way.
 CARROTS IN THEIR OWN JUICE.

(A simple but excellent Receipt.)

By the following mode of dressing carrots, whether young or old,
their full flavour and all the nutriment they contain are entirely
preserved; and they are at the same time rendered so palatable by it
that they furnish at once an admirable dish to eat without meat, as
well as with it. Wash the roots very clean, and scrape or lightly pare
them, cutting out any discoloured parts. Have ready boiling and
salted, as much water as will cover them; slice them rather thick,
throw them into it, and should there be more than sufficient to just
float them (and barely that), pour it away. Boil them gently until they
are tolerably tender, and then very quickly, to evaporate the water, of
which only a spoonful or so should be left in the saucepan. Dust a
seasoning of pepper on them, throw in a morsel of butter rolled in
flour, and turn and toss them gently until their juice is thickened by
them and adheres to the roots. Send them immediately to table.
They are excellent without any addition but the pepper; though they
may be in many ways improved. A dessertspoonful of minced
parsley may be strewed over them when the butter is added, and a
little thick cream mixed with a small proportion of flour to prevent its
curdling, may be strewed amongst them, or a spoonful or two of
good gravy.
 TO BOIL PARSNEPS.

These are dressed in precisely the same manner as carrots, but

require much less boiling. According to their quality and the time of
year, they will take from twenty minutes to nearly an hour. Every
speck or blemish should be cut from them after they are scraped,
and the water in which they are boiled should be well skimmed. They
are a favourite accompaniment to salt fish and boiled pork, and may
be served either mashed or plain.
20 to 25 minutes.
 FRIED PARSNEPS.

Boil them until they are about half done, lift them out, and let them
cool; slice them rather thickly, sprinkle them with fine salt and white
pepper, and fry them a pale brown in good butter. Serve them with
roast meat, or dish them under it.
 JERUSALEM ARTICHOKES.

Wash the artichokes, pare them quickly, and throw them as they
are done into a saucepan of cold water, or of equal parts of milk and
water; and when they are about half boiled add a little salt to them.
Take them up the instant they are perfectly tender: this will be in from
fifteen to twenty-five minutes, so much do they vary in size and as to
the time necessary to dress them. If allowed to remain in the water
after they are done, they become black and flavourless. Melted
butter should always be sent to table with them.
15 to 25 minutes.
 TO FRY JERUSALEM ARTICHOKES. (ENTREMETS.)

Boil them from eight to twelve minutes; lift them out, drain them on
a sieve, and let them cool; dip them into beaten eggs, and cover
them with fine bread-crumbs. Fry them a light brown, drain, pile them
in a hot dish, and serve them quickly.
 JERUSALEM ARTICHOKES, À LA REINE.

Wash and wipe the

artichokes, cut off one end of
each quite flat, and trim the
other into a point; boil them in
milk and water, lift them out the
instant they are done, place Artichokes à la Reine.
them upright in the dish in which
they are to be served, and
sauce them with a good béchamel, or with nearly half a pint of cream
thickened with a rice-crustspoonful of flour, mixed with an ounce and
a half of butter, and seasoned with a little mace and some salt. When
cream cannot be procured use new milk, and increase the proportion
of flour and butter.
 MASHED JERUSALEM ARTICHOKES.

Boil them tender, press the water well from them, and then
proceed exactly as for mashed turnips, taking care to dry the
artichokes well, both before and after the milk or cream is added to
them; they will be excellent if good white sauce be substituted for
either of these.
 HARICOTS BLANCS.

The haricot blanc is the seed of a particular kind of French bean,

of which we find some difficulty in ascertaining the English name, for
though we have tried several which resembled it in appearance, we
have found their flavour, after they were dressed, very different, and
far from agreeable. The large white Dutch runner, is, we believe, the
proper variety for cooking; at least we have obtained a small quantity
under that name, which approached much more nearly than any
others we had tried to those which we had eaten abroad. The
haricots, when fresh may be thrown into plenty of boiling water, with
some salt and a small bit of butter; if dry, they must be previously
soaked for an hour or two, put into cold water, brought to boil gently,
and simmered until they are tender, for if boiled fast the skins will
burst before the beans are done. Drain them thoroughly from the
water when they are ready, and lay them into a clean saucepan over
two or three ounces of fresh butter, a small dessertspoonful of
chopped parsley, and sufficient salt and pepper to season the whole;
then gently shake or toss the beans until they are quite hot and
equally covered with the sauce; add the strained juice of half a
lemon, and serve them quickly. The vegetable thus dressed, is
excellent; and it affords a convenient resource in the season when
the supply of other kinds is scantiest. In some countries the dried
beans are placed in water, over-night, upon a stove, and by a very
gentle degree of warmth are sufficiently softened by the following
day to be served as follows:—they are drained from the water,
spread on a clean cloth and wiped quite dry, then lightly floured and
fried in oil or butter, with a seasoning of pepper and salt, lifted into a
hot dish, and served under roast beef, or mutton.
 TO BOIL BEET ROOT.

Wash the roots delicately clean, but neither scrape nor cut them,
for should even the small fibres be taken off before they are cooked,
their beautiful colour would be much injured. Throw them into boiling
water, and, according to their size, which varies greatly, as they are
sometimes of enormous growth, boil them from one hour and a half
to two and a half, or longer if requisite. Pare and serve them whole,
or cut into thick slices and neatly dished in a close circle: send
melted butter to table with them. Cold red beet root is often
intermingled with other vegetables for winter salads; and it makes a
pickle of remarkably brilliant hue. A common mode of serving it at
the present day is in the last course of a dinner with the cheese: it is
merely pared and sliced after having been baked or boiled tender.
1-1/2 to 2-1/2 hours, or longer.
 TO BAKE BEET ROOT.

Beet root if slowly and carefully baked until it is tender quite

through, is very rich and sweet in flavour, although less bright in
colour than when it is boiled: it is also, we believe, remarkably
nutritious and wholesome. Wash and wipe it very dry, but neither cut
nor break any part of it; then lay it into a coarse earthen dish, and
bake it in a gentle oven for four or five hours: it will sometimes
require even a longer time than this. Pare it quickly if it be served
hot; but leave it to cool first, when it is to be sent to table cold.
In slow oven from 4 to 6 hours.
 STEWED BEET ROOT.

Bake or boil it tolerably tender, and let it remain until it is cold, then
pare and cut it into slices; heat and stew it for a short time in some
good pale veal gravy (or in strong veal broth for ordinary occasions),
thicken this with a teaspoonful of arrow-root, and half a cupful or
more of good cream, and stir in, as it is taken from the fire, from a
tea to a tablespoonful of chili vinegar. The beet root may be served
likewise in thick white sauce, to which, just before it is dished, the
mild eschalots of page 128 may be added.
 TO STEW RED CABBAGE.

(Flemish Receipt.)
Strip the outer leaves from a fine and fresh red cabbage; wash it
well, and cut it into the thinnest possible slices, beginning at the top;
put it into a thick saucepan in which two or three ounces of good
butter have been just dissolved; add some pepper and salt, and stew
it very slowly indeed for three or four hours in its own juice, keeping it
often stirred, and well pressed down. When it is perfectly tender add
a tablespoonful of vinegar; mix the whole up thoroughly, heap the
cabbage in a hot dish, and serve broiled sausages round it; or omit
these last, and substitute lemon-juice, cayenne pepper, and a half-
cupful of good gravy.
The stalk of the cabbage should be split in quarters and taken
entirely out in the first instance.
3 to 4 hours.
 BRUSSELS SPROUTS.

These delicate little sprouts, or miniature cabbages, which at their

fullest growth scarcely exceed a large walnut in size, should be quite
freshly gathered. Free them from all discoloured leaves, cut the
stems even, and wash the sprouts thoroughly. Throw them into a
pan of water properly salted, and boil them quickly from eight to ten
minutes; drain them well, and serve them upon a rather thick round
of toasted bread buttered on both sides. Send good melted butter to
table with them. This is the Belgian mode of dressing this excellent
vegetable, which is served in France with the sauce poured over it,
or it is tossed in a stewpan with a slice of butter and some pepper
and salt: a spoonful or two of veal gravy (and sometimes a little
lemon-juice) is added when these are perfectly mixed.
8 to 10 minutes.
 SALSIFY.

We are surprised that a vegetable so excellent as this should be

so little cared for in England. Delicately fried in batter—which is a
common mode of serving it abroad—it forms a delicious second
course dish: it is also good when plain-boiled, drained, and served in
gravy, or even with melted butter. Wash the roots, scrape gently off
the dark outside skin, and throw them into cold water as they are
done, to prevent their turning black; cut them into lengths of three or
four inches, and when all are ready put them into plenty of boiling
water with a little salt, a small bit of butter, and a couple of spoonsful
of white vinegar or the juice of a lemon: they will be done in from
three quarters of an hour to an hour. Try them with a fork, and when
perfectly tender, drain, and serve them with white sauce, rich brown
gravy, or melted butter.
3/4 to 1 hour.
 FRIED SALSIFY. (ENTREMETS.)

Boil the salsify tender, as directed above, drain, and then press it
lightly in a soft cloth. Make some French batter (see Chapter V.),
throw the bits of salsify into it, take them out separately, and fry them
a light brown, drain them well from the fat, sprinkle a little fine salt
over them after they are dished, and serve them quickly. At English
tables, salsify occasionally makes its appearance fried with egg and
bread-crumbs instead of batter. Scorgonera is dressed in precisely
the same manner as the salsify.
 BOILED CELERY.

This vegetable is extremely good dressed like sea-kale, and

served on a toast with rich melted butter. Let it be freshly dug, wash
it with great nicety, trim the ends, take off the coarse outer-leaves,
cut the roots of equal length, tie them in bunches, and boil them in
plenty of water, with the usual proportion of salt, from twenty to thirty
minutes.
20 to 30 minutes.
 STEWED CELERY.

Cut five or six fine roots of celery to the length of the inside of the
dish in which they are to be served; free them from all the coarser
leaves, and from the green tops, trim the root ends neatly, and wash
the vegetable in several waters until it is as clean as possible; then,
either boil it tender with a little salt, and a bit of fresh butter the size
of a walnut, in just sufficient water to cover it quite, drain it well,
arrange it on a very hot dish, and pour a thick béchamel, or white
sauce over it; or stew it in broth or common stock, and serve it with
very rich, thickened, Espagnole or brown gravy. It has a higher
flavour when partially stewed in the sauce, after being drained
thoroughly from the broth. Unless very large and old, it will be done
in from twenty-five to thirty minutes, but if not quite tender, longer
time must be allowed for it. A cheap and expeditious method of
preparing this dish is to slice the celery, to simmer it until soft in as
much good broth as will only just cover it, and to add a thickening of
flour and butter, or arrow-root, with some salt, pepper, and a small
cupful of cream.
25 to 30 minutes, or more.