Chapter 15

Linked Data
Structures

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. Copyright © 2010 Pearson Addison-Wesley.
All rights reserved.
 Introduction to Linked Data Structures

• A linked data structure consists of capsules of data known as

nodes that are connected via links
– Links can be viewed as arrows and thought of as one way passages
from one node to another
• In Java, nodes are realized as objects of a node class
• The data in a node is stored via instance variables
• The links are realized as references
– A reference is a memory address, and is stored in a variable of a class
type
– Therefore, a link is an instance variable of the node class type itself

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-2

 Java Linked Lists
• The simplest kind of linked data structure is a
linked list
• A linked list consists of a single chain of nodes,
each connected to the next by a link
– The first node is called the head node
– The last node serves as a kind of end marker

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-3

 Nodes and Links in a Linked List

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-4

 A Simple Linked List Class
• In a linked list, each node is an object of a node class
– Note that each node is typically illustrated as a box containing one or
more pieces of data
• Each node contains data and a link to another node
– A piece of data is stored as an instance variable of the node
– Data is represented as information contained within the node "box"
– Links are implemented as references to a node stored in an instance
variable of the node type
– Links are typically illustrated as arrows that point to the node to which
they "link"

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-5

 A Node Class (Part 1 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-6

 A Node Class (Part 2 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-7

 A Node Class (Part 3 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-8

 A Simple Linked List Class
• The first node, or start node in a linked list is called
the head node
– The entire linked list can be traversed by starting at the
head node and visiting each node exactly once
• There is typically a variable of the node type (e.g.,
head) that contains a reference to the first node in
the linked list
– However, it is not the head node, nor is it even a node
– It simply contains a reference to the head node

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-9

 A Simple Linked List Class
• A linked list object contains the variable head as an
instance variable of the class
• A linked list object does not contain all the nodes in
the linked list directly
– Rather, it uses the instance variable head to locate the
head node of the list
– The head node and every node of the list contain a link
instance variable that provides a reference to the next
node in the list
– Therefore, once the head node can be reached, then every
other node in the list can be reached

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-10

An Empty List Is Indicated by null
• The head instance variable contains a reference to
the first node in the linked list
– If the list is empty, this instance variable is set to null
– Note: This is tested using ==, not the equals method
• The linked list constructor sets the head instance
variable to null
– This indicates that the newly created linked list is empty

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-11

 A Linked List Class (Part 1 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-12

 A Linked List Class (Part 2 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-13

 A Linked List Class (Part 3 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-14

 A Linked List Class (Part 4 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-15

 A Linked List Class (Part 5 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-16

 A Linked List Class (Part 6 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-17

 Indicating the End of a Linked List
• The last node in a linked list should have its
link instance variable set to null
– That way the code can test whether or not a node
is the last node
– Note: This is tested using ==, not the equals
method

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-18

 Traversing a Linked List
• If a linked list already contains nodes, it can be
traversed as follows:
– Set a local variable equal to the value stored by the head
node (its reference)
– This will provides the location of the first node
– After accessing the first node, the accessor method for the
link instance variable will provide the location of the next
node
– Repeat this until the location of the next node is equal to
null

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-19

 Traversing a Linked List

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-20

 Adding a Node to a Linked List
• The method add adds a node to the start of the
linked list
– This makes the new node become the first node on the list
• The variable head gives the location of the current
first node of the list
– Therefore, when the new node is created, its link field is
set equal to head
– Then head is set equal to the new node

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-21

 Adding a Node at the Start

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-22

 Deleting the Head Node from a Linked
List
• The method deleteHeadNode removes the first
node from the linked list
– It leaves the head variable pointing to (i.e., containing a
reference to) the old second node in the linked list
• The deleted node will automatically be collected and
its memory recycled, along with any other nodes that
are no longer accessible
– In Java, this process is called automatic garbage collection

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-23

 A Linked List Demonstration
(Part 1 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-24

 A Linked List Demonstration
(Part 2 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-25

 A Linked List Demonstration
(Part 3 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-26

 Node Inner Classes
• Note that the linked list class discussed so far is dependent on
an external node class
• A linked list or similar data structure can be made self-
contained by making the node class an inner class
• A node inner class so defined should be made private, unless
used elsewhere
– This can simplify the definition of the node class by eliminating the
need for accessor and mutator methods
– Since the instance variables are private, they can be accessed directly
from methods of the outer class without causing a privacy leak

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-27

 Pitfall: Privacy Leaks
• The original node and linked list classes examined so
far have a dangerous flaw
– The node class accessor method returns a reference to a
node
– Recall that if a method returns a reference to an instance
variable of a mutable class type, then the private
restriction on the instance variables can be easily defeated
– The easiest way to fix this problem would be to make the
node class a private inner class in the linked list class

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-28

 A Linked List Class with a Node Inner Class (Part
1 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-29

 A Linked List Class with a Node Inner Class (Part
2 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-30

 A Linked List Class with a Node Inner Class (Part
3 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-31

 A Linked List Class with a Node Inner Class (Part
4 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-32

 A Linked List Class with a Node Inner Class (Part
5 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-33

 A Linked List Class with a Node Inner Class (Part
6 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-34

 A Generic Linked List
• A linked list can be created whose Node class has a type
parameter T for the type of data stored in the node
– Therefore, it can hold objects of any class type, including types that
contain multiple instance variable
– The type of the actual object is plugged in for the type parameter T
• For the most part, this class can have the same methods,
coded in basically the same way, as the previous linked list
example
– The only difference is that a type parameter is used instead of an
actual type for the data in the node
• Other useful methods can be added as well

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-35

 A Generic Linked List Class
(Part 1 of 9)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-36

 A Generic Linked List Class
(Part 2 of 9)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-37

 A Generic Linked List Class
(Part 3 of 9)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-38

 A Generic Linked List Class
(Part 4 of 9)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-39

 A Generic Linked List Class
(Part 5 of 9)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-40

 A Generic Linked List Class
(Part 6 of 9)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-41

 A Generic Linked List Class
(Part 7 of 9)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-42

 A Generic Linked List Class
(Part 8 of 9)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-43

 A Generic Linked List Class
(Part 9 of 9)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-44

 A Sample Class for the Data in a
Generic Linked List (Part 1 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-45

 A Sample Class for the Data in a
Generic Linked List (Part 2 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-46

 A Generic Linked List Demonstration
(Part 1 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-47

 A Generic Linked List Demonstration
(Part 2 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-48

 Pitfall: Using Node instead of Node<T>

• Note: This pitfall is explained by example – any names can

be substituted for the node Node and its parameter <T>
• When defining the LinkedList3<T> class, the type for a
node is Node<T>, not Node
– If the <T> is omitted, this is an error for which the compiler may or
may not issue an error message (depending on the details of the
code), and even if it does, the error message may be quite strange
– Look for a missing <T> when a program that uses nodes with type
parameters gets a strange error message or doesn't run correctly

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-49

 A Generic Linked List: the equals Method

• Like other classes, a linked list class should normally have an

equals method
• The equals method can be defined in a number of
reasonable ways
– Different definitions may be appropriate for different situations
• Two such possibilities are the following:
1. They contain the same data entries (possibly in different orders)
2. They contain the same data entries in the same order
• Of course, the type plugged in for T must also have redefined
the equals method

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-50

An equals Method for the Linked List
in Display 15.7 (Part 1 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-51

An equals Method for the Linked List
in Display 15.7 (Part 2 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-52

 Simple Copy Constructors and clone
Methods

• There is a simple way to define copy constructors and the

clone method for data structures such as linked lists
– Unfortunately, this approach produces only shallow copies
• The private helping method copyOf is used by both the copy
constructor and the clone method
• The copy constructor uses copyOf to create a copy of the list
of nodes
• The clone method first invokes its superclass clone
method, and then uses copyOf to create a clone of the list of
nodes

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-53

 A Generic Linked List: the private method
copyOf
• The private helping method copyOf takes an argument that
is a reference to a head node of a linked list, and returns a
reference to the head node of a copy of that list
– It goes down the argument list one node at a time and makes a copy
of each node
– The new nodes are added to the end of the linked list being built
• However, although this produces a new linked list with all new
nodes, the new list is not truly independent because the data
object is not cloned

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-54

 A Copy Constructor and clone Method
for a Generic Linked List (Part 1 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-55

 A Copy Constructor and clone Method for
a Generic Linked List (Part 2 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-56

 A Copy Constructor and clone Method for
a Generic Linked List (Part 3 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-57

 A Copy Constructor and clone Method for
a Generic Linked List (Part 4 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-58

 A Copy Constructor and clone Method for
a Generic Linked List (Part 5 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-59

 A Copy Constructor and clone Method for
a Generic Linked List (Part 6 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-60

 Pitfall: The clone Method Is Protected in
Object
• It would have been preferable to clone the data
belonging to the list being copied in the copyOf
method as follows:
nodeReference = new
Node((T)(position.data).clone(), null);
• However, this is not allowed, and this code will not
compile
– The error message generated will state that clone is protected
in Object
– Although the type used is T, not Object, any class can be
plugged in for T
– When the class is compiled, all that Java knows is that T is a
descendent class of Object

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-61

 Exceptions
• A generic data structure is likely to have methods that throw
exceptions
• Situations such as a null argument to the copy constructor
may be handled differently in different situations
– If this happens, it is best to throw a NullPointerException, and
let the programmer who is using the linked list handle the exception,
rather than take some arbitrary action
– A NullPointerException is an unchecked exception: it need
not be caught or declared in a throws clause

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-62

 Tip: Use a Type Parameter Bound for a Better
clone
• One solution to this problem is to place a
bound on the type parameter T so that it
must satisfy a suitable interface
– Although there is no standard interface that does
this, it is easy to define one
• For example, a PubliclyCloneable
interface could be defined

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-63

 Tip: Use a Type Parameter Bound for a Better
clone
• Any class that implements the
PubliclyCloneable interface would
have these three properties:
1. It would implement the Cloneable interface
because PubliclyCloneable extends
Cloneable
2. It would have to implement a public clone
method
3. Its clone method would have to make a deep
copy

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-64

The PubliclyCloneable Interface

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-65

A Generic Linked List with a Deep Copy
clone Method (Part 1 of 8)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-66

A Generic Linked List with a Deep Copy
clone Method (Part 2 of 8)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-67

A Generic Linked List with a Deep Copy
clone Method (Part 3 of 8)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-68

A Generic Linked List with a Deep Copy
clone Method (Part 4 of 8)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-69

A Generic Linked List with a Deep Copy
clone Method (Part 5 of 8)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-70

A Generic Linked List with a Deep Copy
clone Method (Part 6 of 8)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-71

A Generic Linked List with a Deep Copy
clone Method (Part 7 of 8)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-72

A Generic Linked List with a Deep Copy
clone Method (Part 8 of 8)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-73

A Linked List with a Deep Copy clone Method

• Some of the details of the clone method in the previous

linked list class may be puzzling, since the following code
would also return a deep copy:
public LinkedList<T> clone()
{
return new LInkedList<T>(this);
}
• However, because the class implements
PubliclyCloneable which, in turn, extends
Cloneable, it must implement the Cloneable
interface as specified in the Java documentation

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-74

 A PubliclyCloneable Class (Part 1 of 4)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-75

 A PubliclyCloneable Class (Part 2 of 4)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-76

 A PubliclyCloneable Class (Part 3 of 4)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-77

 A PubliclyCloneable Class (Part 4 of 4)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-78

 Demonstration of Deep Copy clone
(Part 1 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-79

 Demonstration of Deep Copy clone
(Part 2 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-80

Demonstration of Deep Copy clone
(Part 3 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-81

 Tip: Cloning is an "All or Nothing" Affair

• If a clone method is defined for a class, then

it should follow the official Java guidelines
– In particular, it should implement the
Cloneable interface

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-82

 Iterators
• A collection of objects, such as the nodes of a linked list,
must often be traversed in order to perform some action
on each object
– An iterator is any object that enables a list to be traversed in this
way
• A linked list class may be created that has an iterator inner
class
– If iterator variables are to be used outside the linked list class, then
the iterator class would be made public
– The linked list class would have an iterator method that
returns an iterator for its calling object
– Given a linked list named list, this can be done as follows:
LinkedList2.List2Iterator i = list.iterator();

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-83

 Iterators
• The basic methods used by an iterator are as
follows:
– restart: Resets the iterator to the beginning of
the list
– hasNext: Determines if there is another data item
on the list
– next: Produces the next data item on the list

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-84

 A Linked List with an Iterator
(Part 1 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-85

 A Linked List with an Iterator
(Part 2 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-86

 A Linked List with an Iterator
(Part 3 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-87

 A Linked List with an Iterator
(Part 4 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-88

 A Linked List with an Iterator
(Part 5 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-89

 A Linked List with an
Iterator (Part 6 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-90

 Using an Iterator (Part 1 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-91

 Using an Iterator (Part 2 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-92

 Using an Iterator (Part 3 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-93

 Using an Iterator (Part 4 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-94

 Using an Iterator (Part 5 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-95

 Using an Iterator (Part 6 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-96

 The Java Iterator Interface
• Java has an interface named Iterator that
specifies how Java would like an iterator to
behave
– Although the iterators examined so far do not
satisfy this interface, they could be easily
redefined to do so

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-97

 Adding and Deleting Nodes
• An iterator is normally used to add or delete a node
in a linked list
• Given iterator variables position and previous,
the following two lines of code will delete the node
at location position:
previous.link = position.link;
position = position.link;
– Note: previous points to the node before position

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-98

 Deleting a Node (Part 1 of 2)
1. Existing list with the iterator positioned at “shoes”
"coat" "orange juice" "shoes" "socks " null

head previous position

2. Bypass the node at position from previous

previous.link = position.link;

"coat" "orange juice" "shoes" "socks" null

head previous position

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-99

 Deleting a Node (Part 2 of 2)
3. Update position to reference the next node
position = position.link;
"coat" "orange juice" "shoes" "socks" null

head previous position

Since no variable references the node "shoes" Java will automatically

recycle the memory allocated for it .

4. Same picture with deleted node not shown

"coat" "orange juice" "socks" null

head previous position

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-100

 Adding and Deleting Nodes
• Note that Java has automatic garbage collection
– In many other languages the programmer has to keep track of deleted
nodes and explicitly return their memory for recycling
– This procedure is called explicit memory management
• The iterator variables position and previous can be
used to add a node as well
– previous will point to the node before the insertion point, and
position will point to the node after the insertion point
Node temp = new Node(newData,position);
previous.link = temp;

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-101

 Adding a Node between Two
Nodes (Part 1 of 2)
1. Existing list with the iterator positioned at “shoes”
"coat" "orange juice" "shoes" null

head previous position

2. Create new Node with "socks" linked to "shoes"

temp = new Node(newData, position); // newData is "socks"

"coat" "orange juice" "shoes" null

head previous position

temp "socks"

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-102

 Adding a Node between Two
Nodes (Part 2 of 2)
3. Make previous link to the Node temp
previous.link = temp;

"coat" "orange juice" "shoes" null

head previous position

"socks"
temp

4. Picture redrawn for clarity, but structurally identical to picture 3

"coat" "orange juice" "socks " "shoes" null

head previous temp position

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-103

 Variations on a Linked List
• An ordinary linked list allows movement in one direction only
• However, a doubly linked list has one link that references the next node,
and one that references the previous node
• The node class for a doubly linked list can begin as follows:
private class TwoWayNode
{
private String item;
private TwoWayNode previous;
private TwoWayNode next;
. . .
• In addition, the constructors and methods in the doubly linked list class
would be modified to accommodate the extra link

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-104

 A Doubly Linked List

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-105

 Adding a Node to the Front of a
Doubly Linked List

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-106

 Deleting a Node from a Doubly
Linked List (1 of 2)
1. Existing list with an iterator referencing "shoes"

null "coat" "shoes” "socks” null

head position

2. Bypass the "shoes" node from the next link of the previous node
position.previous.next = position.next;

null "coat" "shoes” "socks” null

head position

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-107

 Deleting a Node from a Doubly
Linked List (2 of 2)
3. Bypass the "shoes" node from the previous link of the next node
and move position off the deleted node
position.next.previous = position.previous;
position = position.next;

null "coat" "shoes” "socks” null

head position

4. Picture redrawn for clarity with the "shoes" node removed since
there are no longer references pointing to this node .
null "coat" "socks”

head position

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-108

 Inserting a Node Into a Doubly
Linked List (1 of 2)
1. Existing list with an iterator referencing "shoes"

null "coat" "shoes” "socks” null

head position

2. Create new TwoWayNode with previous linked to "coat" and next to "shoes"
TwoWayNode temp = new TwoWayNode(newData, position.previous, position);
// newData = "shirt"

null "coat" "shoes” "socks” null

head
"shirt"

temp position

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-109

 Inserting a Node Into a Doubly
Linked List (2 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-110

 The Stack Data Structure
• A stack data structure is not necessarily a
linked data structure, but can be implemented
as one
– A stack is a data structure that removes items in
the reverse order of which they were inserted
(LIFO: Last In First Out)
– A linked list that inserts and deletes only at the
head of the list is a stack

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-111

 The Queue Data Structure
• A queue is a data structure that handles data in a
first-in/first-out fashion (FIFO) like a line at a bank
– Customers add themselves to the end of the line and are
served from the front of the line
• A queue can be implemented with a linked list
– However, a queue needs a pointer at both the head and
tail (the end) of the linked list
– Nodes are removed from the front (head end), and are
added to the back ( tail end)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-112

 A Queue Class (Part 1 of 5)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-113

 A Queue Class (Part 2 of 5)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-114

 A Queue Class (Part 3 of 5)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-115

 A Queue Class (Part 4 of 5)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-116

 A Queue Class (Part 5 of 5)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-117

 Demonstration of the Queue Class
(Part 1 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-118

 Demonstration of the Queue Class
(Part 2 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-119

 Running Times
• How fast is program?
– "Seconds"?
– Consider: large input? .. small input?
• Produce "table"
– Based on input size
– Table called "function" in math
• With arguments and return values!
– Argument is input size:
T(10), T(10,000), …
• Function T is called "running time"

Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 19-120

 Table for Running Time Function:
Display 15.31 Some Values
of a Running Time Function

Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 19-121

 Consider Sorting Program
• Faster on smaller input set?
– Perhaps
– Might depend on "state" of set
• "Mostly" sorted already?
• Consider worst-case running time
– T(N) is time taken by "hardest" list
• List that takes longest to sort

Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 19-122

 Counting Operations
• T(N) given by formula, such as:
T(N) = 5N + 5
– "On inputs of size N program runs for
5N + 5 time units"
• Must be "computer-independent"
– Doesn’t matter how "fast" computers are
– Can’t count "time"
– Instead count "operations"

Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 19-123

 Counting Operations Example
• int i = 0;
Boolean found = false;
while (( i < N) && !found)
if (a[I] == target)
found = true;
else
i++;
• 5 operations per loop iteration:
<, &&, !, [ ], ==, ++
• After N iterations, final three: <, &&, !
• So: 6N+5 operations when target not found

Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 19-124

 Big-O Notation
• Recall: 6N+5 operations in "worst-case"
• Expressed in "Big-O" notation
– Some constant "c" factor where
c(6N+5) is actual running time
• c different on different systems
– We say code runs in time O(6N+5)
– But typically only consider "highest term"
• Term with highest exponent
– O(N) here

Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 19-125

 Big-O Terminology
• Linear running time:
– O(N)—directly proportional to input size N
• Quadratic running time:
– O(N2)
• Logarithmic running time:
– O(log N)
• Typically "log base 2"
• Very fast algorithms!

Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 19-126

 Display 15.32
Comparison of Running Times

Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 19-127

 Efficiency of Linked Lists
• Find method for linked list
– May have to search entire list
– On average would expect to search half of the list,
or n/2
– In big-O notation, this is O(n)
• Adding to a linked list
– When adding to the start we only reassign some
references
– Constant time or O(1)
Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-128
 Hash Tables
• A hash table or hash map is a data structure
that efficiently stores and retrieves data from
memory
• Here we discuss a hash table that uses an
array in combination with singly linked lists
• Uses a hash function
– Maps an object to a key
– In our example, a string to an integer

Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 17-129

 Simple Hash Function for Strings
• Sum the ASCII value of every character in the
string and then compute the modulus of the
sum using the size of the fixed array.
private int computeHash(String s)
{
int hash = 0;
for (int i = 0; i < s.length(); i++)
{
hash += s.charAt(i);
}
return hash % SIZE; // SIZE = 10 in example
}

Example: “dog” = ASCII 100, 111, 103

Hash = (100 + 111 + 103) % 10 = 4
Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 17-130
 Hash Table Idea
• Storage
– Make an array of fixed size, say 10
– In each array element store a linked list
– To add an item, map (i.e. hash) it to one of the 10
array elements, then add it to the linked list at
that location
• Retrieval
– To look up an item, determine its hash code then
search the linked list at the corresponding array
slot for the item
Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 17-131
 Constructing a Hash Table (1 of 2)
1. Existing hash table initialized with ten empty linked lists
hashArray = new LinkedList3[SIZE]; // SIZE = 10

0 1 2 3 4 5 6 7 8 9
hashArray empty empty empty empty empty empty empty empty empty empty

2. After adding "cat" with hash of 2

0 1 2 3 4 5 6 7 8 9
hashArray empty empty empty empty null empty empty empty empty

cat

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-132

 Constructing a Hash Table (2 of 2)
3. After adding "dog" with hash of 4 and "bird" with hash of 7
0 1 2 3 4 5 6 7 8 9
hashArray empty empty empty empty empty empty empty

cat dog bird

4. After adding "turtle" with hash of 2 – collision and chained to linked list with "cat"
0 1 2 3 4 5 6 7 8 9
hashArray empty empty empty empty empty empty empty

turtle dog bird

cat

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-133

 A Hash Table Class (1 of 3)
1 public class HashTable
2 {
3 // Uses the generic LinkedList2 class from Display 15.7
4 private LinkedList2[] hashArray;
5 private static final int SIZE = 10;

6 public HashTable()
7 {
8 hashArray = new LinkedList2[SIZE];
9 for (int i=0; i < SIZE; i++)
10 hashArray[i] = new LinkedList2();
11 }

12 private int computeHash(String s)

13 {
14 int hash = 0;
15 for (int i = 0; i < s.length(); i++)
16 {
17 hash += s.charAt(i);
18 }
19 return hash % SIZE;
20 }

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-134

 A Hash Table Class (2 of 3)
21 /**
22 Returns true if the target is in the hash table,
23 false if it is not.
24 */
25 public boolean containsString(String target)
26 {
27 int hash = computeHash(target);
28 LinkedList2 list = hashArray[hash];
29 if (list.contains(target))
30 return true;
31 return false;
32 }

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-135

 A Hash Table Class (3 of 3)
33 /**
34 Stores or puts string s into the hash table
35 */
36 public void put(String s)
37 {
38 int hash = computeHash(s); // Get hash value
39 LinkedList2 list = hashArray[hash];
40 if (!list.contains(s))
41 {
42 // Only add the target if it's not already
43 // on the list.
44 hashArray[hash].addToStart(s);
45 }
46 }
47 } // End HashTable class

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-136

 Hash Table Demonstration (1 of 2)
1 public class HashTableDemo
2 {
3 public static void main(String[] args)
4 {
5 HashTable h = new HashTable();

6 System.out.println("Adding dog, cat, turtle, bird");

7 h.put("dog");
8 h.put("cat");
9 h.put("turtle");
10 h.put("bird");
11 System.out.println("Contains dog? " +
12 h.containsString("dog"));
13 System.out.println("Contains cat? " +
14 h.containsString("cat"));
15 System.out.println("Contains turtle? " +
16 h.containsString("turtle"));
17 System.out.println("Contains bird? " +
18 h.containsString("bird"));

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-137

 Hash Table Demonstration (2 of 2)
19 System.out.println("Contains fish? " +
20 h.containsString("fish"));
21 System.out.println("Contains cow? " +
22 h.containsString("cow"));
23 }
24}

SAMPLE DIALOGUE

Adding dog, cat, turtle, bird

Contains dog? true
Contains cat? true
Contains turtle? true
Contains bird? true
Contains fish? false
Contains cow? false

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-138

 Hash Table Efficiency
• Worst Case
– Every item inserted into the table has the same hash key,
the find operation may have to search through all items
every time (same performance as a linked list, O(n) to find)
• Best Case
– Every item inserted into the table has a different hash key,
the find operation will only have to search a list of size 1,
very fast, O(1) to find.
• Can decrease the chance of collisions with a better
hash function
• Tradeoff: Lower chance of collision with bigger hash
table, but more wasted memory space
Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 17-139
 Set Template Class
• A set is a collection of elements in which no
element occurs more than once
• We can implement a simple set that uses a
linked list to store the items in the set
• Fundamental set operations we will support:
– Add
– Contains
– Union
– Intersection
Copyright © 2010 Pearson Addison-Wesley. All rights reserved.. 17-140
 Sets Using Linked Lists

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-141

 A Set Class (1 of 5)
1 // Uses a linked list as the internal data structure
2 // to store items in a set.
3 public class Set<T>
4 {
5 private class Node<T>
6 {
7 private T data;
8 private Node<T> link;

9 public Node( )
10 {
11 data = null;
12 link = null;
13 }
14 public Node(T newData, Node<T> linkValue)
15 {
16 data = newData;
17 link = linkValue;
18 }
19 }//End of Node<T> inner class

20 private Node<T> head;

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-142

 A Set Class (2 of 5)
21 public Set()
22 {
23 head = null;
24 }
25 /**
26 Add a new item to the set. If the item
27 is already in the set, false is returned,
28 otherwise true is returned.
29 */
30 public boolean add(T newItem)
31 {
32 if (!contains(newItem))
33 {
34 head = new Node<T>(newItem, head);
35 return true;
36 }
37 return false;
38 }

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-143

 A Set Class (3 of 5)
39 public boolean contains(T item)
40 {
41 Node<T> position = head;
42 T itemAtPosition;
43 while (position != null)
44 {
45 itemAtPosition = position.data;
46 if (itemAtPosition.equals(item))
47 return true;
48 position = position.link;
49 }
50 return false; //target was not found
51 }

52 public void output( )

53 {
54 Node position = head;
55 while (position != null)
56 {
57 System.out.print(position.data.toString() + " ");
58 position = position.link;
59 }
60 System.out.println();
61 }
Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-144
 A Set Class (4 of 5)
62 /**
63 Returns a new set that is the union
64 of this set and the input set.
65 */
66 public Set<T> union(Set<T> otherSet)
67 {
68 Set<T> unionSet = new Set<T>();
69 // Copy this set to unionSet
70 Node<T> position = head;
71 while (position != null)
72 {
73 unionSet.add(position.data);
74 position = position.link;
75 }
76 // Copy otherSet items to unionSet.
77 // The add method eliminates any duplicates.
78 position = otherSet.head;
79 while (position != null)
80 {
81 unionSet.add(position.data);
82 position = position.link;
83 }
84 return unionSet;
85 }
Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-145
 A Set Class (5 of 5)
86 /**
87 Returns a new that is the intersection
88 of this set and the input set.
89 */
90 public Set<T> intersection(Set<T> otherSet)
91 {
92 Set<T> interSet = new Set<T>();
93 // Copy only items in both sets
94 Node<T> position = head;
95 while (position != null)
96 {
97 if (otherSet.contains(position.data))
98 interSet.add(position.data);
99 position = position.link;
100 }
101 return interSet;
102 }
103 }

The clear, size, and isEmpty methods are identicalto those in Display 15.8
for the LinkedList3 class.

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-146

 A Set Class Demo (1 of 3)
1 class SetDemo
2 {
3 public static void main(String[] args)
4 {
5 // Round things
6 Set round = new Set<String>();
7 // Green things
8 Set green = new Set<String>();

9 // Add some data to both sets

10 round.add("peas");
11 round.add("ball");
12 round.add("pie");
13 round.add("grapes");

14 green.add("peas");
15 green.add("grapes");
16 green.add("garden hose");
17 green.add("grass");

18 System.out.println("Contents of set round: ");

19 round.output();
20 System.out.println("Contents of set green: ");
21 green.output();
22 System.out.println();
Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-147
 A Set Class Demo (2 of 3)
23 System.out.println("ball in set round? " +
24 round.contains("ball"));
25 System.out.println("ball in set green? " +
26 green.contains("ball"));

27 System.out.println("ball and peas in same set? " +

28 ((round.contains("ball") &&
29 (round.contains("peas"))) ||
30 (green.contains("ball") &&
31 (green.contains("peas")))));

32 System.out.println("pie and grass in same set? " +

33 ((round.contains("pie") &&
34 (round.contains("grass"))) ||
35 (green.contains("pie") &&
36 (green.contains("grass")))));

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-148

 A Set Class Demo (3 of 3)
37 System.out.print("Union of green and round: ");
38 round.union(green).output();
39 System.out.print("Intersection of green and round: ");
40 round.intersection(green).output();
41 }
42}

SAMPLE DIALOGUE

Contents of set round:

grapes pie ball peas
Contents of set green:
Grass garden hose grapes peas

ball in set round? true

ball in set green? false
ball and peas in same set? true
pie and grass in same set? false
Union of green and round: garden hose grass peas ball pie grapes
Intersection of green and round: peas grapes

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-149

 Trees
• Trees are a very important and widely used data
structure
• Like linked lists, they are a structure based on nodes
and links, but are more complicated than linked lists
– All trees have a node called the root
– Each node in a tree can be reached by following the links
from the root to the node
– There are no cycles in a tree: Following the links will
always lead to an "end"

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-150

 Trees
• A binary tree is the most common kind of tree
– Each node in a binary tree has exactly two link instance variables
– A binary tree must satisfy the Binary Search Tree Storage Rule
• The root of the tree serves a purpose similar to that of the
instance variable head in a linked list
– The node whose reference is in the root instance variable is called
the root node
• The nodes at the "end" of the tree are called leaf nodes
– Both of the link instance variables in a leaf node are null

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-151

 A Binary Tree (Part 1 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-152

 A Binary Tree (Part 2 of 2)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-153

 Binary Search Tree Storage Rule
1. All the values in the left subtree must be less than
the value in the root node
2. All the values in the right subtree must be greater
than or equal to the value in the root node
3. This rule is applied recursively to each of the two
subtrees
(The base case for the recursion is an empty tree)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-154

 Tree Properties
• Note that a tree has a recursive structure
– Each tree has two subtrees whose root nodes are the
nodes pointed to by the leftLink and rightLink of
the root node
– This makes it possible to process trees using recursive
algorithms
• If the values of a tree satisfying the Binary Search
Tree Storage Rule are output using Inorder
Processing, then the values will be output in order
from smallest to largest

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-155

 Preorder Processing
1. Process the data in the root node
2. Process the left subtree
3. Process the right subtree

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-156

 Inorder Processing
1. Process the left subtree
2. Process the data in the root node
3. Process the right subtree

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-157

 Postorder Processing
1. Process the left subtree
2. Process the right subtree
3. Process the data in the root node

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-158

A Binary Search Tree for Integers (Part
1 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-159

A Binary Search Tree for Integers (Part
2 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-160

A Binary Search Tree for Integers (Part
3 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-161

A Binary Search Tree for Integers (Part
4 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-162

A Binary Search Tree for Integers (Part
5 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-163

A Binary Search Tree for Integers (Part
6 of 6)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-164

Demonstration Program for the Binary
Search Tree (Part 1 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-165

Demonstration Program for the Binary
Search Tree (Part 2 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-166

Demonstration Program for the Binary
Search Tree (Part 3 of 3)

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-167

 Efficiency of Binary Search Trees
• A Binary search trees that is as short as possible can
be processed most efficiently
– A short tree is one where all paths from root to a leaf differ
by at most one node
• When this is so, the search method isInSubtree
is about as efficient as the binary search on a sorted
array
– Its worst-case running time is O(log n), where n is the
number of nodes in the tree

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-168

 Efficiency of Binary Search Trees
• As a tree becomes more tall and thin, this efficiency
falls off
– In the worst case, it is the same as that of searching a
linked list with the same number of nodes
• Maintaining a tree so that it remains short and fat, as
nodes are added, is known as balancing the tree
– A tree maintained in this manner is called a balanced tree

Copyright © 2010 Pearson Addison-Wesley. All rights reserved. 15-169