Chapter 15
Linked Data SStructures
Introduction to Linked Data Structures Introduction to Linked Data Structures
A li k d d t t t i t f l f d t k
• 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
f d t th
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 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
type
– Therefore, a link is an instance variable of the node class type itself
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 15‐2
Java Linked Lists Java Linked Lists
h i l ki d f li k d d i
• 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 y
– The first node is called the head node
– The last node serves as a kind of end marker The last node serves as a kind of end marker
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 15‐3
Nodes and Links in a Linked List
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 15‐4
A Simple Linked List Class A Simple Linked List Class
I li k d li t h d i bj t f d l
• 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" p – 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 yp y p they "link"
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 15‐5
A Node Class (Part 1 of 3) A Node Class (Part 1 of 3)
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 15‐6
A Node Class (Part 2 of 3) A Node Class (Part 2 of 3)
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 15‐7
A Node Class (Part 3 of 3) A Node Class (Part 3 of 3)
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 15‐8
A Simple Linked List Class A Simple Linked List Class
Th fi t d t t d i li k d li t i ll d
• 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 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.,
) h f h f d
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 – However, it is not the head node, nor is it even a node – It simply contains a reference to the head node
Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 15‐9
A Simple Linked List Class A Simple Linked List Class
A li k d li t bj t t i th i bl h d
• 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
• 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 instance variable that provides a reference to the next node in the list
– Therefore, once the head node can be reached, then every
th d i th li t b h d
other node in the list can be reached
15‐10 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
An Empty List Is Indicated by null An Empty List Is Indicated by null
Th h d i i bl i f
• The head instance variable contains a reference to the first node in the linked list
If th li t i t thi i t i bl i t t ll – 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
• The linked list constructor sets the head instance variable to null
This indicates that the newly created linked list is empty – This indicates that the newly created linked list is empty
15‐11 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class (Part 1 of 6) A Linked List Class (Part 1 of 6)
15‐12 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class (Part 2 of 6) A Linked List Class (Part 2 of 6)
15‐13 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class (Part 3 of 6) A Linked List Class (Part 3 of 6)
15‐14 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class (Part 4 of 6) A Linked List Class (Part 4 of 6)
15‐15 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class (Part 5 of 6) A Linked List Class (Part 5 of 6)
15‐16 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class (Part 6 of 6) A Linked List Class (Part 6 of 6)
15‐17 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Indicating the End of a Linked List 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
is the last node
– Note: This is tested using == , not the equals method
method
15‐18 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Traversing a Linked List Traversing a Linked List
If li k d li l d i d i b
• If a linked list already contains nodes, it can be traversed as follows:
S t l l i bl l t th l t d b th h d
– Set a local variable equal to the value stored by the head node (its reference)
– This will provides the location of the first node 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
null
15‐19 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Traversing a Linked List g
15‐20 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Adding a Node to a Linked List 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
15‐21 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Adding a Node at the Start
15‐22 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Deleting the Head Node from a Linked Li
List
Th th d d l t H dN d th fi t
• The method deleteHeadNode removes the first node from the linked list
– It leaves the It leaves the head head variable pointing to (i e containing a 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
l d l h h d h
its memory recycled, along with any other nodes that are no longer accessible
In Java this process is called automatic garbage collection – In Java, this process is called automatic garbage collection
15‐23 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Demonstration
( f )
(Part 1 of 3)
15‐24 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Demonstration
( f )
(Part 2 of 3)
15‐25 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Demonstration
( f )
(Part 3 of 3)
15‐26 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Node Inner Classes Node Inner Classes
N h h li k d li l di d f i d d
• 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‐ 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
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
15‐27 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Pitfall: Privacy Leaks Pitfall: Privacy Leaks
Th i i l d d li k d li l i d
• The original node and linked list classes examined so far have a dangerous flaw
Th d l th d t f t
– The node class accessor method returns a reference to a node
– Recall that if a method returns a reference to an instance 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
15‐28 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class with a Node Inner Class (Part 1 f 6)
1 of 6)
15‐29 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class with a Node Inner Class (Part 2 f 6)
2 of 6)
15‐30 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class with a Node Inner Class (Part 3 f 6)
3 of 6)
15‐31 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class with a Node Inner Class (Part 4 f 6)
4 of 6)
15‐32 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class with a Node Inner Class (Part 5 f 6)
5 of 6)
15‐33 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List Class with a Node Inner Class (Part 6 f 6)
6 of 6)
15‐34 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List A Generic Linked List
A li k d li t b t d h N d l h t
• 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
t i lti l i t i bl
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, p 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 y yp p actual type for the data in the node
• Other useful methods can be added as well
15‐35 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Class
( f )
(Part 1 of 9)
15‐36 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Class
( f )
(Part 2 of 9)
15‐37 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Class
( f )
(Part 3 of 9)
15‐38 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Class
( f )
(Part 4 of 9)
15‐39 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Class
( f )
(Part 5 of 9)
15‐40 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Class
( f )
(Part 6 of 9)
15‐41 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Class
( f )
(Part 7 of 9)
15‐42 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Class
( f )
(Part 8 of 9)
15‐43 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Class
( f )
(Part 9 of 9)
15‐44 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Sample Class for the Data in a Generic Linked List (Part 1 of 2)
15‐45 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Sample Class for the Data in a Generic Linked List (Part 2 of 2)
15‐46 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Demonstration (Part 1 of 2)
15‐47 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List Demonstration (Part 2 of 2)
15‐48 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Pitfall: Using Node instead of Node<T>
Pitfall: Using Node instead of Node<T>
N Thi i f ll i l i d b l
• Note: This pitfall is explained by example – any names can be substituted for the node Node and its parameter <T>
• When defining the When defining the LinkedList3<T> LinkedList3<T> class the type for a 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
i (d di h d il f h
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
15‐49 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List: the equals Method A Generic Linked List: the equals Method
Lik th l li k d li t l h ld ll h
• Like other classes, a linked list class should normally have an equals method
• The equals q method can be defined in a number of reasonable ways
– Different definitions may be appropriate for different situations
• Two such possibilities are the following: 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 th t l d i f T t l h d fi d
• Of course, the type plugged in for T must also have redefined the equals method
15‐50 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
An equals Method for the Linked List in Display 15.7 (Part 1 of 2)
15‐51 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
An equals Method for the Linked List in Display 15.7 (Part 2 of 2)
15‐52 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Simple Copy Constructors and clone Methods
Methods
Th i i l d fi d h
• 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 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
• The clone method first invokes its superclass clone
method, and then uses copyOf to create a clone of the list of nodes
15‐53 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List: the private method copyOf
Th i t h l i th d Of t k t th t
• 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 py
– 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 – 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
15‐54 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Copy Constructor and clone Method for a Generic Linked List (Part 1 of 6)
15‐55 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Copy Constructor and clone Method for a Generic Linked List (Part 2 of 6)
15‐56 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Copy Constructor and clone Method for a Generic Linked List (Part 3 of 6)
15‐57 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Copy Constructor and clone Method for a Generic Linked List (Part 4 of 6)
15‐58 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Copy Constructor and clone Method for a Generic Linked List (Part 5 of 6)
15‐59 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Copy Constructor and clone Method for a Generic Linked List (Part 6 of 6)
15‐60 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
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:
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 – 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
plugged in for T
– When the class is compiled, all that Java knows is that T is a descendent class of Object
15‐61 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Exceptions Exceptions
A i d i lik l h h d h h
• A generic data structure is likely to have methods that throw exceptions
• Situations such as a Situations such as a null null argument to the copy constructor argument to the copy constructor may be handled differently in different situations
– If this happens, it is best to throw a NullPointerException, and
l h h i i h li k d li h dl h i
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
15‐62 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
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
15‐63 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Tip: Use a Type Parameter Bound for a Better clone
• Any class that implements the
PubliclyCloneable interface would
h h h i
have these three properties:
1. It would implement the Cloneable interface because PubliclyCloneable extends because PubliclyCloneable extends Cloneable
2. It would have to implement a public clone p p method
3. Its clone method would have to make a deep copy
15‐64 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
The PubliclyCloneable Interface The PubliclyCloneable Interface
15‐65 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List with a Deep Copy clone Method (Part 1 of 8)
15‐66 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List with a Deep Copy clone Method (Part 2 of 8)
15‐67 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List with a Deep Copy clone Method (Part 3 of 8)
15‐68 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List with a Deep Copy clone Method (Part 4 of 8)
15‐69 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List with a Deep Copy clone Method (Part 5 of 8)
15‐70 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List with a Deep Copy clone Method (Part 6 of 8)
15‐71 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List with a Deep Copy clone Method (Part 7 of 8)
15‐72 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Generic Linked List with a Deep Copy clone Method (Part 8 of 8)
15‐73 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List with a Deep Copy clone Method 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:
would also return a deep copy:
public LinkedList<T> clone() {
return new LInkedList<T>(this);
}
• However because the class implements
• However, because the class implements
PubliclyCloneable which, in turn, extends Cloneable, it must implement the Cloneable interface as specified in the Java documentation
15‐74 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A PubliclyCloneable Class (Part 1 of 4) A PubliclyCloneable Class (Part 1 of 4)
15‐75 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A PubliclyCloneable Class (Part 2 of 4) A PubliclyCloneable Class (Part 2 of 4)
15‐76 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A PubliclyCloneable Class (Part 3 of 4) A PubliclyCloneable Class (Part 3 of 4)
15‐77 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A PubliclyCloneable Class (Part 4 of 4) A PubliclyCloneable Class (Part 4 of 4)
15‐78 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Demonstration of Deep Copy clone (Part 1 of 3)
15‐79 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Demonstration of Deep Copy clone (Part 2 of 3)
15‐80 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Demonstration of Deep Copy clone (Part 3 of 3)
15‐81 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
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 g
– In particular, it should implement the Cloneable interface
Cloneable interface
15‐82 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Iterators 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 j
– 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 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 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 Given a linked list named list, this can be done as follows: list, this can be done as follows:
LinkedList2.List2Iterator i = list.iterator();
15‐83 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Iterators 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
15‐84 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List with an Iterator (Part 1 of 6)
15‐85 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List with an Iterator (Part 2 of 6)
15‐86 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List with an Iterator (Part 3 of 6)
15‐87 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List with an Iterator (Part 4 of 6)
15‐88 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List with an Iterator (Part 5 of 6)
15‐89 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Linked List with an Iterator (Part 6 of 6)
15‐90 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Using an Iterator (Part 1 of 6) Using an Iterator (Part 1 of 6)
15‐91 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Using an Iterator (Part 2 of 6) Using an Iterator (Part 2 of 6)
15‐92 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Using an Iterator (Part 3 of 6) Using an Iterator (Part 3 of 6)
15‐93 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Using an Iterator (Part 4 of 6) Using an Iterator (Part 4 of 6)
15‐94 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Using an Iterator (Part 5 of 6) Using an Iterator (Part 5 of 6)
15‐95 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Using an Iterator (Part 6 of 6) Using an Iterator (Part 6 of 6)
15‐96 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
The Java Iterator Interface The Java Iterator Interface
• Java has an interface named Iterator that specifies how Java would like an iterator to p behave
– Although the iterators examined so far do not – Although the iterators examined so far do not
satisfy this interface, they could be easily redefined to do so
redefined to do so
15‐97 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Adding and Deleting Nodes 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
15‐98 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Deleting a Node (Part 1 of 2) Deleting a Node (Part 1 of 2)
1. Existing list with the iterator positioned at “shoes”
"orange juice" "shoes" "socks " null
"coat"
head previous position
2. Bypass the node at position from previous
previous.link = position.link;"orange juice" "shoes" "socks" null
"coat"
head previous position
15‐99 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Deleting a Node (Part 2 of 2) Deleting a Node (Part 2 of 2)
3. Update position to reference the next node p pos t o
position = position.link;"orange juice" "shoes" "socks" null
"coat "
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
"orange juice" "socks" null
"coat"
head previous position
15‐100 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Adding and Deleting Nodes Adding and Deleting Nodes
N h J h i b ll i
• 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
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;
15‐101 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Adding a Node between Two Nodes (Part 1 of 2)
1. Existing list with the iterator positioned at “shoes”
"orange juice" "shoes" null
"coat"
head previous position
2 Create new Node with "socks" linked to "shoes"
2. Create new Node with "socks" linked to "shoes"
temp = new Node(newData, position); // newData is "socks"
"orange juice" "shoes" null
"coat"
head previous position
" k "
t "socks"
temp
15‐102 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Adding a Node between Two Nodes (Part 2 of 2)
3. Make previous link to the Node temp
previous.link = temp;"orange juice" "shoes" null
"coat"coat orange juice shoes null
head previous position
"socks"
temp
4. Picture redrawn for clarity, but structurally identical to picture 3
"orange juice" "socks "
"coat" "shoes" null
head previous temp position
15‐103 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Variations on a Linked List Variations on a Linked List
• An ordinary linked list allows movement in one direction only
• 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:
• 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
15‐104 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Doubly Linked List
15‐105 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Adding a Node to the Front of a Doubly Linked List
15‐106 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Deleting a Node from a Doubly Linked List (1 of 2)
null
1. Existing list with an iterator referencing "shoes"
"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
15‐107 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
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;
null "coat" "shoes” "socks” null
p p p p ;
position = position.next;
null "coat"
head
"shoes "socks null
position
4. Picture redrawn for clarity with the "shoes" node removed since there are no longer references pointing to this node .
null "coat"
head
"socks”
position
15‐108 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Inserting a Node Into a Doubly Linked List (1 of 2)
null
1. Existing list with an iterator referencing "shoes"
"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"
position temp
15‐109 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Inserting a Node Into a Doubly Linked List (2 of 2)
15‐110 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
The Stack Data Structure The Stack Data Structure
• A stack data structure is not necessarily a linked data structure, but can be implemented p as one
– A stack is a data structure that removes items in – A stack is a data structure that removes items in
the reverse order of which they were inserted (LIFO: Last In First Out)
(LIFO: Last In First Out)
– A linked list that inserts and deletes only at the h d f th li t i t k
head of the list is a stack
15‐111 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
The Queue Data Structure The Queue Data Structure
A i d t t t th t h dl d t i
• 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 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 – Nodes are removed from the front (head end), and are
added to the back ( tail end)
15‐112 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Queue Class (Part 1 of 5) A Queue Class (Part 1 of 5)
15‐113 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Queue Class (Part 2 of 5) A Queue Class (Part 2 of 5)
15‐114 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Queue Class (Part 3 of 5) A Queue Class (Part 3 of 5)
15‐115 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Queue Class (Part 4 of 5) A Queue Class (Part 4 of 5)
15‐116 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Queue Class (Part 5 of 5) A Queue Class (Part 5 of 5)
15‐117 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Demonstration of the Queue Class (Part 1 of 2)
15‐118 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Demonstration of the Queue Class (Part 2 of 2)
15‐119 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Running Times Running Times
H f i ?
• How fast is program?
– "Seconds"?
C id l i ? ll i ?
– Consider: large input? .. small input?
• Produce "table"
d i i
– Based on input size
– Table called "function" in math
• With arguments and return values!
• With arguments and return values!
– Argument is input size:
T(10), T(10,000), … ( ) ( )
• Function T is called "running time"
19‐120 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Table for Running Time Function:
Display 15 31 Some Values Display 15.31 Some Values of a Running Time Function
19‐121 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Consider Sorting Program Consider Sorting Program
• Faster on smaller input set?
– Perhaps p
– Might depend on "state" of set
• "Mostly" sorted already?
• Mostly sorted already?
• Consider worst‐case running time
– T(N) is time taken by "hardest" list
• List that takes longest to sort
19‐122 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Counting Operations 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"
5N + 5 time units
• Must be "computer‐independent"
– Doesn’t matter how "fast" computers are – Can’t count "time"
– Instead count "operations"
19‐123 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Counting Operations Example Counting Operations Example
i i 0
• int i = 0;
Boolean found = false;
while (( i < N) && !found) (( ) ) if (a[I] == target)
found = true;
else else
i++;
• 5 operations per loop iteration: p p p
<, &&, !, [ ], ==, ++
• After N iterations, final three: <, &&, !
• So: 6N+5 operations when target not found
19‐124 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Big O Notation 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
19‐125 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Big O Terminology Big‐O Terminology
i i i
• Linear running time:
– O(N)—directly proportional to input size N
• Quadratic running time:
– O(N O(N ) 2 )
• Logarithmic running time:
O(l N) – O(log N)
• Typically "log base 2"
V f t l ith !
• Very fast algorithms!
19‐126 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Display 15.32
Comparison of Running Times
19‐127 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Efficiency of Linked Lists Efficiency of Linked Lists
• Find method for linked list
– May have to search entire list y
– On average would expect to search half of the list, or n/2
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 g y g references
– Constant time or O(1) Constant time or O(1)
15‐128 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Hash Tables Hash Tables
• A hash table or hash map is a data structure that efficiently stores and retrieves data from y memory
• Here we discuss a hash table that uses an
• 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 Maps an object to a key
– In our example, a string to an integer
17‐129 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Simple Hash Function for Strings Simple Hash Function for Strings
S th ASCII l f h t i th
• 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) 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 return hash % SIZE; // SIZE = 10 in example }
Example: “dog” = ASCII 100, 111, 103
17‐130 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Hash = (100 + 111 + 103) % 10 = 4
Hash Table Idea Hash Table Idea
• Storage Storage
– Make an array of fixed size, say 10
h l l k d l
– 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 – To look up an item, determine its hash code then
search the linked list at the corresponding array slot for the item
slot for the item
17‐131 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Constructing a Hash Table (1 of 2) Constructing a Hash Table (1 of 2)
1. Existing hash table initialized with ten empty linked lists hashArray = new LinkedList3[SIZE]; // SIZE = 10
empty empty empty empty empty empty empty empty empty empty
0 1 2 3 4 5 6 7 8 9
hashArray
2. After adding "cat" with hash of 2
0 1 2 3 4 5 6 7 8 9
empty empty empty empty null empty empty empty empty
hashArray
t cat
15‐132 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Constructing a Hash Table (2 of 2) Constructing a Hash Table (2 of 2)
3 After adding "dog" with hash of 4 and "bird" with hash of 7 3. After adding dog with hash of 4 and bird with hash of 7
empty empty empty empty empty empty empty
0 1 2 3 4 5 6 7 8 9
hashArray
cat dog bird
4. After adding "turtle" with hash of 2 – collision and chained to linked list with "cat"
empty empty empty empty empty empty empty
0 1 2 3 4 5 6 7 8 9
hashArray empty empty empty empty empty empty empty
hashArray
turtle dog bird
cat
15‐133 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Hash Table Class (1 of 3) 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) p p ( g )
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 }
15‐134 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
}
A Hash Table Class (2 of 3) A Hash Table Class (2 of 3)
21 /**
22 Returns true if the target is in the hash table, g ,
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 }
15‐135 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Hash Table Class (3 of 3) A Hash Table Class (3 of 3)
33 /**
34 Stores or puts string s into the hash table p g
35 */
36 public void put(String s)
37 {
38 int hash = computeHash(s); p ( ); // Get hash value //
39 LinkedList2 list = hashArray[hash];
40 if (!list.contains(s))
41 {
42 // Only add the target if it's not already // y g y
43 // on the list.
44 hashArray[hash].addToStart(s);
45 }
46 } }
47 } // End HashTable class
15‐136 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Hash Table Demonstration (1 of 2) 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"); p ( );
10 h.put("bird");
11 System.out.println("Contains dog? " +
12 h.containsString("dog"));
13 System.out.println("Contains cat? " + y p (
14 h.containsString("cat"));
15 System.out.println("Contains turtle? " +
16 h.containsString("turtle"));
17 System.out.println("Contains bird? " + y p (
18 h.containsString("bird"));
15‐137 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Hash Table Demonstration (2 of 2) Hash Table Demonstration (2 of 2)
19 System.out.println("Contains fish? " + 20 h.containsString("fish")); g( ));
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
15‐138 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Hash Table Efficiency 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,
f t O(1) t fi d 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
17‐139 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Set Template Class 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
linked list to store the items in the set
• Fundamental set operations we will support:
– Add – Contains Contains – Union – Intersection
17‐140 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved..
Sets Using Linked Lists Sets Using Linked Lists
15‐141 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Set Class (1 of 5) 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( ) p ( )
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;
15‐142 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
p
A Set Class (2 of 5) 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) p ( )
31 {
32 if (!contains(newItem))
33 {
34 head = new Node<T>(newItem, head); ( , );
35 return true;
36 }
37 return false;
38 } }
15‐143 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Set Class (3 of 5) 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 }
15‐144 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
60 System.out.println();
61 }
A Set Class (4 of 5) 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 }
15‐145 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
84 return unionSet;
85 }
A Set Class (5 of 5) 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.
15‐146 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
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 d dd( b ll )
11 round.add("ball");
12 round.add("pie");
13 round.add("grapes");
14 dd( )
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 t t()
15‐147 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
21 green.output();
22 System.out.println();
A Set Class Demo (2 of 3) 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")))));
15‐148 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Set Class Demo (3 of 3) 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 Grass garden hose grapes peas
ball in set round? true ball in set green? false ball and peas in same set? true 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
15‐149 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Trees Trees
T i d id l d d
• Trees are a very important and widely used data structure
Lik li k d li h b d d
• Like linked lists, they are a structure based on nodes and links, but are more complicated than linked lists
All t h d ll d th t
– 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
from the root to the node
– There are no cycles in a tree: Following the links will always lead to an "end"
15‐150 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
Trees Trees
A bi t i th t ki d f t
• 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 The node whose reference is in the root root instance variable is called 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 – Both of the link instance variables in a leaf node are null
15‐151 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.
A Binary Tree (Part 1 of 2)
15‐152 Copyright © 2012 Pearson Addison‐Wesley. All rights reserved.