CSE 501NFall ‘0910: Introduction to Collections and Linked Lists
29 September 2009Nick Leidenfrost
2
Lecture Outline
Data Structures Linked List Iterators
3
ArraysThe shortcomings
Fixed size Insertion into the middle of a contiguous
array Removal from the middle of a contiguous
array
4
Data Structures
Objects whose purpose is to organize data (primitives or other objects)
Allow us to store large amounts of information when it is not desirable to do so with an array
Can grow and shrink as needed Can be more efficient to search than arrays in
certain cases
5
Data StructuresJava Libraries
Java provides several data structures in its librariesContained in the java.util package
[ To the JavaDoc, Batman! ] In the next few weeks we will be exploring
some of these Data Structures and learning their strengths and weaknessesWhen it is appropriate to use a particular
structure
6
Linked Lists One of the most basic data structures is the
linked list A linked list is a data structure which consists of
a number of nodes, each of which has some contents and a reference to the next node
(storage) (storage) (storage) (storage)
List
Node Node Node Node
7
Linked ListsCode View
A linked list is a data structure which consists of a number of nodes (instances of a Node class), each of which has some contents (instance variable) a reference to the next node (instance variable)
Object storage;Node next;
class Node
Object storage;Node next;
Object storage;Node next;
class SinglyLinkedList
Node head;
8
Linked Lists vs. Arrays 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
Lists can grow arbitrarily large (Resizing is efficient)
9
Linked ListsImplementation
To keep it simple, we will look at implementing a singly-linked list Called “Singly Linked” because Nodes only
know about the Node after them (References, or links only go in one direction)
You will be asked to implement a Doubly Linked List in Lab 4
10
Linked ListsImplementation Node class
Holds a reference to the next Node Holds a reference to the Object it is storing
SinglyLinkedList class Holds a reference head to the first node
(storage) (storage) (storage) (storage)
List
Node Node Node Node
11
ListsIn Code
public class Node {
Object contents; Node nextNode;
public Node (Object contents) { this.contents = contents; }
}public class SinglyLinkedList {
Node head;
public SinglyLinkedList () { this.head = null; }
}
12
Adding a New First Element When a new Node is added to the list
It becomes the head of the list The old list head becomes its next Node
public class SinglyLinkedList {
// . . .
public void addFirst (Object add) { Node newNode = new Node(add); newNode.next = this.head; this.head = newNode; }
}
13
Removing the First Element
When the first element is removed The data of the first node are saved and later
returned as the method result The successor of the list head becomes the
list headThe old node will be garbage collected when
there are no further references to it
14
Removing the First Element The removeFirst method
public class SinglyLinkedList {
// . . .
public Object removeFirst() {
if (head == null)
return null;
Object obj = this.head.contents;
this.head = this.head.next;
return obj; } }
15
Getting an Element by Index The getNth method
public Object getNth (int index) {
Node search = this.head;
for (int i=0; i<index; i++) {
if (search == null)
return null;
search = search.next;
}
return search.contents;
}
16
Iterating Over Data Structures Iterating over a Linked List
We could just use a regular for loop:
But what is this doing internally?[ Example on Board ]
Very inefficient
for (int i=0; i<list.getSize(); i++) {
Object nth = list.getNth(i);
... // Do something with ‘nth’
}
17
IteratorsHelpers for Stepping through Data Structures
Let’s define a way for users to iterate through our data structure (SinglyLinkedList), one element at a time Internal Iterator
[ Example on Board ] But what if multiple different entities want
to iterate over the Data Structure?Position is invalidated for other users
18
IteratorsSafely Exporting State
What we need is a way to encapsulate (package up) and export a position in the Data Structure…Allow multiple different simultaneous iterators
over the Data StructureWe need to have a trusted way of providing a
reference to our internal representation Exporting our internal representation
How is this done?
19
Levels of EncapsulationExporting State Safely
We want the internal structure (Nodes) of the linked list to be as protected as possible
We want to be able to export some notion of a position within the list The easiest way to do this would be a reference to a Node
But we don’t want to expose the Node object itself Write an encapsulation for the behavior we want to
export
20
Packages and Access ModifiersClasses that Work Together Closely
Put our SinglyLinkedList, our Node, and our ListIterator classes inside of package
Declare Node head in SinglyLinkedList with the protected access modifier
ListIterator can access protected fields of the List, because List and ListIterator are in the same package
Make the constructor of ListIterator protected so that it must be created via the SinglyLinkedList
22
Iterators
ListIterator type Gives access to elements inside a linked list Encapsulates the concept of a ‘position’
anywhere inside the linked list Protects the internal structure of the linked list
while giving access
23
A List Iterator
24
List Iterator Think of an iterator as pointing between two elements
in a data structure Analogy: like the cursor in a word processor points
between two characters
The iterator method of the SinglyLinkedList class gets a new ListIterator Points to the beginning of the list
SinglyLinkedList employeeNames = new SinglyLinkedList();
ListIterator iterator = employeeNames.iterator();
25
A Conceptual View of a List Iterator
26
List Iterator
Initially, the iterator points before the first element
hasNext returns true if there is a next element
The next method moves the iterator and returns the current item
Object next = iterator.next();
if (iterator.hasNext()) iterator.next();
27
List Iterator
The next method returns the element that the iterator is passing
while (iterator.hasNext()) { Object obj = iterator.next(); // Do something with obj}
28
LinkedListIterator The LinkListIterator class
package listutil;
public class LinkedListIterator {
Node previous, position;
List list;
public LinkedListIterator(List list) {
this.list = list; this.position = null; this.previous = null; }
}
}
29
Linked List Iterator hasNext Method
The next method should only be called when the iterator is not at the end of the list If hasNext returns true
The iterator is at the end if… the list is empty (list.head == null) there is no element after the current position
(position.next == null)
30
The Linked List IteratorhasNext Method
private class LinkedListIterator { //. . .
public boolean hasNext() { if (position == null) return (list.head != null); else return (position.next != null); }
//. . .}
31
The Linked List Iteratornext Method
position: reference to the last visited Node previous: reference to the Node before position
next method: position reference is advanced to position.next
Last position is remembered in previous If the iterator points before the first element
of the list, then the previous is null and position must be set to list.head
32
The Linked List Iteratornext Method
public Object next() { if (!hasNext()) return null; previous = position; // Remember for remove
if (position == null) position = list.head; else position = position.next;
return position.contents;}
33
The Linked List Iteratorremove Method
If the element to be removed is the first element, call list.removeFirst
Otherwise, the node preceding the element to be removed needs to have its next reference updated to skip the removed element
34
The Linked List Iteratorremove Method
public void remove() {
if (previous == position) return; // Invalid state!
if (position == list.head) { list.removeFirst(); }
else {
previous.next = position.next;
}
position = previous; }
35
Removing a Node From the Middle of a Linked List
36
The Linked List Iteratorremove Method: Caveats
If the previous equals position: Then the call to remove does not immediately follow a call to next Method cannot execute properly
(throw an IllegalArgumentException) It is illegal to call remove twice in a row remove sets the previous reference to position
37
The Linked List Iteratorset Method
Changes the data stored in the previously visited element
The set method
public Object set (Object obj) {
Object contents = null; if (position != null) {
contents = position.contents; position.contents = obj;
}
return contents;}
38
The Linked List Iteratoradd Method
add inserts the new node after the current position
The most complex operation is the addition of a node
Sets the successor of the new node to the successor of the current position
39
The Linked List Iterator's add Method
public void add(Object obj) { if (position == null) { list.addFirst(obj); position = list.head;
previous = null; } else { Node newNode = new Node(obj); newNode.next = position.next; position.next = newNode;
previous = position; position = newNode; }
}
40
Adding a Node to the Middle of a Linked List
41
Conclusion
Lab 3 assigned todayArrays & IterationLab 2 due by midnight I will be in lab now
Top Related