Post on 30-Mar-2015
CHAPTER 19
An Introduction to Data Structures
CHAPTER GOALS
• To learn how to use linked lists provided in the standard library
• To be able to use iterators to transverse linked lists
• To understand the implementation of linked lists
• To distinguish between abstract and concrete data types
• To know the efficiency of fundamental operations of lists and arrays
• To become familiar with the stack and queue types
Linked List
• A linked list consists of a number of links, each of which has a reference to the next link.
• Adding and removing elements in the middle of a linked list is efficient.
• Visiting the elements of a linked list in sequential order is efficient
• Random access is not efficient
Inserting an Element into a Linked List
Java's LinkedList class • Easy access to first and last elements
with methods
o void addFirst(Object obj) o void addLast(Object obj)o Object getFirst() o Object getSecond() o Object removeFirst() o Object removeLast()
ListIterator • List iterator gives access to elements inside
a linked list
• ListIterator protects the linked list while giving access
• ListIterator encapsulates a position anywhere in the linked list
A List Iterator
Conceptual View of the ListIterator
List Iterator
• Think of an iterator as pointing between two links
List Iterator
• The listIterator method of the LinkedList class gets a list iterator
LinkedList list = . . . ListIterator iterator = list.listIterator();
List Iterator
• The next method moves the iterator iterator.next();
• next throws a NoSuchElementException if
you are already past the end of the list
List Iterator
• hasNext returns true if there is a next element
if (iterator.hasNext())iterator.next();
List Iterator
• The next method returns the object of the link that it is passing
while iterator.hasNext() {
Object obj = iterator.next(); //do something with the object
}
List Iterator
• To move the list position backwards, use: o hasPrevious o previous
Adding and Removing from a LinkedList
• The add method:
o Adds an object after the iterator
o Moves the iterator position past the new element
iterator.add("Juliet");
Adding and Removing from a LinkedList
• The remove method:
o Removes ando Returns the object that was
returned by the last call to next or previous
Adding and Removing from a LinkedList
• This loop removes all objects that fulfill a certain conditionwhile (iterator.hasNext()) {
Object obj = iterator.next(); if (obj fulfills condition) iterator.remove();
}
File ListTest.java
• ListTest is a sample program that
o inserts elements into a list
o iterates through the list, adding and removing elements
o prints the list
File ListTest.java01: import java.util.LinkedList;
02: import java.util.ListIterator;
03:
04: /**
05: A program that demonstrates the LinkedList class
06: */
07: public class ListTest
08: {
09: public static void main(String[] args)
10: {
11: LinkedList staff = new LinkedList();
12: staff.addLast("Dick");
13: staff.addLast("Harry");
14: staff.addLast("Romeo");
15: staff.addLast("Tom");
16:
17: // | in the comments indicates the iterator position
18:
19: ListIterator iterator = staff.listIterator(); // |DHRT
20: iterator.next(); // D|HRT
21: iterator.next(); // DH|RT
22:
23: // add more elements after second element
24:
25: iterator.add("Juliet"); // DHJ|RT
26: iterator.add("Nina"); // DHJN|RT
27:
28: iterator.next(); // DHJNR|T
29:
30: // remove last traversed element
31:
32: iterator.remove(); // DHJN|T
33:
34: // print all elements
35:
36: iterator = staff.listIterator();
37: while (iterator.hasNext())
38: System.out.println(iterator.next());
39: }
40: }
Implementing Linked Lists • LinkedList class has a private inner class Link
class LinkedList {
private class Link {
public Object data; public Link next;
} }
Implementing Linked Lists • LinkedList class
o Holds a reference first to the first link
o Has a method to get the first element
Implementing Linked Lists class LinkedList {
public LinkedList() {
first = null; }
public Object getFirst() {
if (first == null) throw new
NoSuchElementException(); return first.data;
} . . . private Link first;
}
Adding a New First Element
• When a new link is added to the list o It becomes the head of the list o The old first link becomes the next
link
Adding a New First Element • The addFirst method
class LinkedList {
. . . public void addFirst(Object obj) {
Link newLink = new Link(); newLink.data = obj;
newLink.next = first; first = newLink;
} ...
}
Adding a Link to the Head of a Linked List
Removing the First Element
• When the first element is removed o The data of the first link are saved and later
returned as the method result
o The successor of the first link becomes the first link of the shorter list
o The link will be garbage collected when there are no further references to it
Removing the First Element • The removeFirst method
class LinkedList { . . .
public Object removeFirst() {
if (first == null) throw new NoSuchElementException(); Object obj = first.data; first = first.next; return obj;
} . . .
}
Removing the First Link from a Linked List
LinkedListIterator
• Private inner class of LinkedList
• Implements a simplified ListIterator interface
• Has access to the first field and private Link class
LinkedListIteratorThe LinkListIterator class
class LinkedList { . . .
public ListIterator listIterator() { return new LinkedListIterator(); } private class LinkedListIterator implements ListIterator { public LinkedListIterator() {
position = null; previous = null;
} . . . private Link position; private Link previous;
} . . .
}
LinkListIterator's next Method • position reference is advances to position.next
• Old position is remembered as previous
• If the iterator points before the first element of the list, then the old position is
null and position must be set to first
LinkListIterator's next Method private class LinkedListIterator implements ListIterator { . . .
public Object next() { if (!hasNext())
throw new NoSuchElementException(); previous = position; // remember for remove if (position == null)
position = first; else
position = position.next; return position.data; } . . .
}
LinkListIterator's hasnext Method
• The next method should only be called when the iterator is not at the end of the list
• The iterator is at the end
o if the list is empty (first == null)
o if there is no element after the current position (position.next == null)
LinkListIterator's hasnext Method
private class LinkedListIterator implements ListIterator {
. . . public boolean hasNext() {
if (position == null) return first != null;
else return position.next != null;
} . . .
}
LinkListIterator's remove Method
• If the element to be removed is the first element, call removeFirst
• Otherwise, the link proceeding the element to be removed needs to have its next reference updated to skip the removed element
• If the previous reference is null:
o this call does not immediately follow a call to next
o throw an IllegalArgumentException
• Set previous reference to null
LinkListIterator's remove Method private class LinkedListIterator implements ListIterator { . . .
public void remove() { if (position == first)
{ removeFirst(); position = first; }
else {
if (previous == null) throw new IllegalStateException();
previous.next = position.next; position = previous;
} previous = null; }
. . . }
Removing a Link From the Middle of a Linked List
LinkListIterator's set Method • Changes the data stored in the previously visited
element • The set method
private class LinkedListIterator implements ListIterator{ . . .
public void set(Object obj) { if (position == null) throw new NoSuchElementException(); position.data = obj; } . . .
}
LinkListIterator's add Method
• Inserts the new link after the current position
• Sets the successor of the new link to the successor of the current position
LinkListIterator's add Method private class LinkedListIterator implements ListIterator{ . . . public void add(Object obj) { if (position == null) { addFirst(obj); position = first; } else { Link newLink = new Link(); newLink.data = obj; newLink.next = position.next; position.next = newLink; position = newLink; } previous = null; } . . .}
Adding a Link to the Middle of a Linked List
File LinkedList.java 001: import java.util.NoSuchElementException;
002:
003: /**
004: A linked list is a sequence of links with efficient
005: element insertion and removal. This class
006: contains a subset of the methods of the standard
007: java.util.LinkedList class.
008: */
009: public class LinkedList
010: {
011: /**
012: Constructs an empty linked list.
013: */
014: public LinkedList()
015: {
016: first = null;
017: }
018:
019: /**
020: Returns the first element in the linked list.
021: @return the first element in the linked list
022: */
023: public Object getFirst()
024: {
025: if (first == null)
026: throw new NoSuchElementException();
027: return first.data;
028: }
029:
030: /**
031: Removes the first element in the linked list.
032: @return the removed element
033: */
034: public Object removeFirst()
035: {
036: if (first == null)
037: throw new NoSuchElementException();
038: Object obj = first.data;
039: first = first.next;
040: return obj;
041: }
042:
043: /**
044: Adds an element to the front of the linked list.
045: @param obj the object to add
046: */
047: public void addFirst(Object obj)
048: {
049: Link newLink = new Link();
050: newLink.data = obj;
051: newLink.next = first;
052: first = newLink;
053: }
054:
055: /**
056: Returns an iterator for iterating through this list.
057: @return an iterator for iterating through this list
058: */
059: public ListIterator listIterator()
060: {
061: return new LinkedListIterator();
062: }
063:
064: private Link first;
065:
066: private class Link
067: {
068: public Object data;
069: public Link next;
070: }
071:
072: private class LinkedListIterator implements ListIterator
073: {
074: /**
075: Constructs an iterator that points to the front
076: of the linked list.
077: */
078: public LinkedListIterator()
079: {
080: position = null;
081: previous = null;
082: }
083:
084: /**
085: Moves the iterator past the next element.
086: @return the traversed element
087: */
088: public Object next()
089: {
090: if (!hasNext())
091: throw new NoSuchElementException();
092: previous = position; // remember for remove
093:
094: if (position == null)
095: position = first;
096: else
097: position = position.next;
098:
099: return position.data;
100: }
101:
102: /**
103: Tests if there is an element after the iterator
104: position.
105: @return true if there is an element after the iterator
106: position
107: */
108: public boolean hasNext()
109: {
110: if (position == null)
111: return first != null;
112: else
113: return position.next != null;
114: }
115:
116: /**
117: Adds an element before the iterator position
118: and moves the iterator past the inserted element.
119: @param obj the object to add
120: */
121: public void add(Object obj)
122: {
123: if (position == null)
124: {
125: addFirst(obj);
126: position = first;
127: }
128: else
129: {
130: Link newLink = new Link();
131: newLink.data = obj;
132: newLink.next = position.next;
133: position.next = newLink;
134: position = newLink;
135: }
136: previous = null;
137: }
138:
139: /**
140: Removes the last traversed element. This method may
141: only be called after a call to the next() method.
142: */
143: public void remove()
144: {
145: if (position == first)
146: {
147: removeFirst();
148: position = first;
149: }
150: else
151: {
152: if (previous == null)
153: throw new IllegalStateException();
154: previous.next = position.next;
155: position = previous;
156: }
157: previous = null;
158: }
159:
160: /**
161: Sets the last traversed element to a different
162: value.
163: @param obj the object to set
164: */
165: public void set(Object obj)
166: {
167: if (position == null)
168: throw new NoSuchElementException();
169: position.data = obj;
170: }
171:
172: private Link position;
173: private Link previous;
174: }
175: }
File ListIterator.java 01: import java.util.NoSuchElementException;
02:
03: /**
04: A list iterator allows access of a position in a linked list. This interface contains a subset of the methods of the
05: standard java.util.ListIterator interface. The methods for
06: backward traversal are not included.
07: */
08: public interface ListIterator
09: {
10: /**
11: Moves the iterator past the next element.
12: @return the traversed element
13: */
14: Object next();
15:
16: /**
17: Tests if there is an element after the iterator
18: position.
19: @return true if there is an element after the iterator
20: position
21: */
22: boolean hasNext();
23:
24: /**
25: Adds an element before the iterator position
26: and moves the iterator past the inserted element.
27: @param obj the object to add
28: */
29: void add(Object obj);
30:
31: /**
32: Removes the last traversed element. This method may
33: only be called after a call to the next() method.
34: */
35: void remove();
36:
37: /**
38: Sets the last traversed element to a different
39: value.
40: @param obj the object to set
41: */
42: void set(Object obj);
43: }
Abstract Data Types
• Abstract data type defines the fundamental operations on the data
• Abstract data type does not specify an implementation
Abstract Data Types• Abstract list
o An ordered sequence of items that can be traversed sequentially
o Allows for insertion and removal of elements at any position
• Abstract array
o An ordered sequence of items
o Allows for random access by specifying an integer index
An Abstract View of a Linked List
A Concrete View of a Linked List
An Abstract View of an Array List
A Concrete View of an Array List
Fundamental Operations on Array List
public class ArrayList { public Object get(int index) {. . . } public void set(int index, Object value) {. . . }
}
Fundamental Operations on Linked List
public class LinkedList {
public ListIteratior listIterator() {. . . } . . .
} public interface ListIteratior {
Object next(); boolean hasNext(); void add(Object value); void remove(); void set(Object value); . . .
}
Efficiency of Linked List
• Adding or removing an element o A fixed number of link references need to be
modifiedto add or remove a link, regardless of the size of the list
o Thus, an element can be added or moved in constant time
o In big-Oh notations: O(1)
Efficiency of Linked List
• Random access o On average n/2 elements need to be
skipped o In big-Oh notation: O(n)
Efficiency of Array List
• Adding or moving an element o On average n/2 elements need to be moved
o In big-Oh notations: O(n)
• Random access o In big-Oh notation: O(1)
Efficiency of Operations for Arrays and List
Abstract Data Type Stack
• Allows insertion and removal of elements only at one end
o Traditionally called the top of the stack
• New items are added to the top of the stack
• Items are removed at the top of the stack
• Called last in, first out or LIFO order
• Think of a stack of books
A Stack of Books
• A stack can be visualized as a stack of books.
• You place books on top and remove from the top.
A Stack of Books
Abstract Data Type Stack
• The Stack class is a concrete implementation of a stack in the Java library
• The Stack class uses an Object[] to implement a stack
Abstract Data Type Stack • Sample code to use the Stack classStack s = new Stack(); s.push("A"); s.push("B"); s.push("C"); //the following loop prints C, B, A int i = s.size(); while (i > 0) {
System.out.println(s.pop()); i--;
}
Abstract Data Type Queue
• Items added to one end of the queue (the tail)
• Items removed from the other end (the head)
• Called first in, first out or FIFO order • Think of a queue of people
A Queue
• A Queue can be visualized as a queue of people.
• People join the tail of the queue and wait until they reach the head.
A Queue
Abstract Data Type Queue
• No implementing class in the Java library
• Can be implemented using a linked list
A Queue Implementation public class Queue
{
/**
Constructs an empty queue
*/
public Queue()
{
list = new LinkedList();
}
/**
Adds an item to the tail of the queue
@param x the item to add
*/
public void add(Object x)
{
list.addLast(x);
}
/**
Removes an item from the head of the queue
@return the removed item
*/
public Object remove()
{
return list.removeFirst();
}
/**
Gets the number of items in the queue
@return the size
*/
public int size()
{
return list.size()
}
private LinkedList list;
}