Linked List

1. LinkedList • 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

2. linked list

3. Java's LinkedList class http://java.sun.com/j2se/1.4.2/docs/api/index.html Some of the simpler methods: • void addFirst(Object obj) • void addLast(Object obj) • Object getFirst() • Object getSecond() • Object removeFirst() • Object removeLast()

4. listIterator provides a way to access all links: ListIterator listIterator(int index) • listIterator method provides an object of type ListIterator ListIterator is an interface, so the return object from this method provides all the methods in this interface ListIterator Interface: void add(Object o) boolean hasNext(), boolean hasPrev() Object next(), int nextIndex() Object previous(), int prevIndex() void remove(), void set(Object) * provide a way to move forward thru list elements

5. A ListIterator object

6. hasNext() method .. • hasNextreturns true if there is a next element LinkedList list = new LinkedList(); // other calls ListIterator iterator = list.listIterator(0); if (iterator.hasNext()) ………

7. next() method .. • Thenextmethodmoves the iterator ListIterator iterator = list.listIterator(0); if (iterator.hasNext()) iterator.next(); • nextthrowsa NoSuchElementException if you are already past the end of the list • The next method returns the object of the link that it is passing while (iterator.hasNext()) { Object obj = iterator.next(); Dog mydog = (Dog)obj; mydog.draw(); }

8. other iterator methods.. • To move the list position backwards, use: • hasPrevious • Previous • The add method: • Adds an object after the iterator • Moves the iterator position past the new element iterator.add("Juliet"); • The remove method: • Removes and • Returns the object that was returned by the last call to next or previous

9. Adding and Removing from a LinkedList • This loop removes all objects that fulfill a certain condition while (iterator.hasNext()) { Object obj = iterator.next(); if (obj fulfills condition) iterator.remove(); }

10. File ListTest.java • ListTest is a sample program that • inserts elements into a list • iterates through the list, adding and removing elements • prints the list

11. File ListTest.java 01: 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

12. 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())

13. 38: System.out.println(iterator.next()); 39: } 40: }

14. Implementing Linked Lists • LinkedListclass has a private inner class Link class LinkedList { private class Link { public Object data; public Link next; } }

15. Implementing Linked Lists • LinkedList class • Holds a reference first to the first link • Has a method to get the first element

16. Implementing Linked Lists class LinkedList { public LinkedList() { first = null; } public Object getFirst() { if (first == null) throw new NoSuchElementException(); return first.data; } . . . private Link first; }

17. Adding a New First Element • When a new link is added to the list • It becomes the head of the list • The old first link becomes the next link

18. 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; } ... }

19. Adding a Link to the Head of a Linked List

20. Removing the First Element • When the first element is removed • The data of the first link are saved and later returned as the method result • The successor of the first link becomes the first link of the shorter list • The link will be garbage collected when there are no further references to it

21. Removing the First Element • TheremoveFirstmethod class LinkedList { . . . public Object removeFirst() { if (first == null) throw new NoSuchElementException(); Object obj = first.data; first = first.next; return obj; } . . . }

22. Removing the First Link from a Linked List

23. LinkedListIterator • Private inner class of LinkedList • Implements a simplified ListIterator interface • Has access to the first field and private Link class

24. LinkedListIterator The 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; } . . . }

25. LinkListIterator's next Method • positionreference is advances toposition.next • Old position is remembered asprevious • If the iterator points before the first element of the list, then the oldpositionisnullandpositionmust be set tofirst

26. 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; } . . . }

27. 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 • if the list is empty (first == null) • if there is no element after the current position (position.next == null)

28. LinkListIterator's hasnext Method private class LinkedListIterator implements ListIterator { . . . public boolean hasNext() { if (position == null) return first != null; else return position.next != null; } }

29. 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: • this call does not immediately follow a call to next • throw an IllegalArgumentException • Set previous reference to null

30. 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; } . . . }

31. Removing a Link From the Middle of a Linked List

32. 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; } . . . }

33. 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

34. 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; } . . . }

35. Adding a Link to the Middle of a Linked List