Introduction to Linked Lists and Doubly Linked Lists

1. Chapter 9: Linked Lists • Learn about linked lists. • Learn about doubly linked lists. • Get used to thinking about more than one possible implementation of a data structure. • Think about the advantages and disadvantages of different implementations.

2. Reading • Bailey Chapter 9 CS2007, Dr M. Collinson

3. Linked lists: the idea • A linked list is a set of items where each item is part of a node that may also contain asingle link to another node. • Allow one to insert, remove and rearrange lists very efficiently. CS2007, Dr M. Collinson

4. ant bat cat Linked lists: data structure • A linked list consists of a sequence of nodes connected by links, plus a header. • Each node (except the last) has a next node, and each node (except the first) has a predecessor. • Each node contains a single element (object or value), plus links to its next. header node element link null link CS2007, Dr M. Collinson

5. More about linked lists • The length of a linked list is the number of nodes. • An empty linked list has no nodes. • In a linked list: • We can manipulate the individual elements. • We can manipulate the links, • Thus we can change the structure of the linked list! • This is not possible in an array. CS2007, Dr M. Collinson

6. Points to Note • Last element may use a special link called the null link. • Different implementations of linked lists. • Different forms: • Circular lists: `last’ item linked to `first’. • Cyclic: `last’ item linked to one of its predecessors. • Acyclic: not cyclic. 14506 • Nodes sometimes drawn: ant CS2007, Dr M. Collinson

8. Linked Lists vs. Arrays • Size of linked list can be variable! • Arrays have fixed size. • Re-arrangement of items in a linked list is (usually) faster. • Access to elements is slower in a LL. CS2007, Dr M. Collinson

9. References • Many languages use references or pointers to implement linked lists. • This is the case in Java, where references are pointers to objects. See Malik, chapter 3. • A node consists of a variable for the data it carries (which may be done via a reference), and a variable which is a reference to its next. CS2007, Dr M. Collinson

10. Pitfalls with Pointers • You should be aware that programming with references is very powerful, but can be tricky. • Aliasing: `If two variables contain references to the same object, the state of the object can be modified using one variable’s reference to the object, and then the altered state can be observed through the reference in the other variable.’ (Gosling, Joy, Steele, The Java Language Specification). CS2007, Dr M. Collinson

11. Null • The last node of a linked list is a reference, but it is the null reference that refers to nothing! • If some operation tries to use the object that the null ref. points to then an exception is raised (in Java NullPointerException). • Not always easy to ensure all of these are caught. • `I call it my billion-dollar mistake. It was the invention of the null reference in 1965. … This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.’ (Prof. Sir C.A.R. Hoare) CS2007, Dr M. Collinson

12. A Java Class of Nodes • Nodes for a linked list (of strings). class SLLNode { String element; // data field SLLNode next; // next field // Constructor SLLNode (String elem, SLLNode nextNode) {this.element = elem;this.next= nextNode; } } CS2007, Dr M. Collinson

13. Java class: linked list with header • Implementing linked list of SLLNodes: class StrLinkedList {  SLLNode first; // Header refers to first node // Constructor for empty list StrLinkedList () { this.first = null; } } CS2007, Dr M. Collinson

14. ant bat cat Example of list creation list = new StrLinkedList(); SLLNode catNode = new SLLNode(“cat”,null); SLLNode batNode = new SLLNode(“bat”,catNode); SLLNode antNode = new SLLNode(“ant”,batNode); list.first = antNode; CS2007, Dr M. Collinson

15. What happens? • System.out.println(list.first.data); • System.out.println(list.first.next.data); • System.out.println(list.first.next.next.data); • System.out.println( list.first.next.next.next.data ); CS2007, Dr M. Collinson

16. Example of list traversal • Add method (to class StrLinkedList) to traverse list. Prints all elements in first-to-last order. • Note clever Boolean condition on while loop. Commonly used trick. Such methods may not always terminate -- for example on lists with cycles. voidprintFirstToLast () { SLLNode current = this.first; while (current != null) { System.out.println(current.data); current = current.next; } return; } CS2007, Dr M. Collinson

17. Array lists: retrieve/get • get(index): return the data at the specified index. • Speed does not depend on the size of the array or the index. Therefore get is O(1). CS2007, Dr M. Collinson

18. Linked lists: Retrieval • Get item at given position index. String get(int index) { SLLNode current = this.first; for (int count = 0; count++; count < index) current = current.next return current.data; } CS2007, Dr M. Collinson

19. Time complexity • Time complexity: takes index+1 steps. • O(1) to get first element • O(N) to get last element • O(N) to get randomly chosen element. • Same complexity class (= roughly the same speed) as ArrayList to get first element. Slower to get other elements CS2007, Dr M. Collinson

20. Array lists: remove (deletion) • remove(index): remove the element at the index. Shuffle everything to the right of the index (but not the index itself) back one position. Decrement size (N). • Best case: last element (1 assignment). • Worst case: first element (N+1 assignments). • In general: 1 + N – index assignments. • Average case: O(N). CS2007, Dr M. Collinson

21. Linked lists: deletion of node. • Idea: Re-wire the picture of linked list, cutting-out X, the node at given position index. • That is, find predecessor of X in the list; call this pred. Then change next of pred to be next of X. (To remove first node, change ref. to first field in header class). void remove(int index) { if (index == 0) first = first.next; else { SLLNode pred = first; for (int count = 0; count < index-1; count++) pred = pred.next; // for-loop ends here pred.next = pred.next.next; } } CS2007, Dr M. Collinson

22. How remove works • start pred at first node • advance pred index-1 times to get to node before deletion • assign pred.next = pred.next.next • to bypass the node to delete (44) • any node with no reference to it is garbage collected CS2007, Dr M. Collinson

23. Time Complexity: Linked List Removal • Same speed as retrieval (get) • O(N) on average, O(1) to remove first element • Most of the time is used to find the predecessor. • Same average speed as ArrayList • Faster to remove first element. CS2007, Dr M. Collinson

24. Arrays lists: Add • Add(index, element): add an element to a list at a given index. Add one to the length (size) of the array(N), shuffle everything from the index onward one position to the right. • Best case (index = last element): 2 assignments. • Worst case (first element): N + 2 assignments. • In general, 2+ (N-index) assignments. • Average O(N). CS2007, Dr M. Collinson

25. Adding to a Linked List • Adding at beginning: O(1) • special case in Add method • Adding at end: O(N) • general case in Add method • uses a pointer variable to traverse list

26. Adding to Beginning of a List • Adding 11 at index = 0 (the beginning): • BEFORE • AFTER: CS2007, Dr M. Collinson

27. Pseudocode for Adding to Beginning • if (index == 0) // add to beginning of list • Create newNode as a new SLLNode with data • Assign newNode.next = first • Assign first = newNode

28. Adding to Middle/End of List • Adding 55 at index = 2 • Before: • After

29. Psuedocode for Adding to Middle/End • if (index == 0) // add to beginning of list • ... // already shown • ... • else • assign pred to first node • advance pred through list index-1 times • so it now points to node before insertion point • Create newNode as a new SLLNode with data • Assign newNode.next = pred.next • Assign pred.next = newNode

30. Java code for Insertion/Add • Idea: re-wire picture so that predecessor of node N at given index points to the new node, and new node points to N. Very similar to remove. • Same speed as get(..) for LL: O(N) on average, O(1) to add first element. void add(int index, String s) { if (index == 0) first = new SLLNode(s, first); // Add to beginning else { // Add to middle or end SLLNode pred = first; for (int count = 0; count < index-1; count++) // advance pred to node prior pred = pred.next; SLLNode newNode = new SLLNode(s, pred.next); // create, link to rest of list pred.next = newNode; } } // link prior to newNode CS2007, Dr M. Collinson

31. List implementation: comparison

32. pig dog cat rat dog Doubly-linked lists • A doubly-linked list (DLL) consists of a sequence of nodes, connected by links in both directions. • Each DLL node contains a single element, plus links to the node’s next and predecessor (or null link(s)). • The DLL header contains links to the DLL’s first and last nodes (or null links if the DLL is empty). CS2007, Dr M. Collinson

33. Doubly-linked List • Advantages • Fast access to beginning and end of list • Can traverse forwards or backwards • See Malik for details on algorithms CS2007, Dr M. Collinson

34. A Java Class for DLL Nodes • Java class implementing DLL nodes: class DLLNode { String data; DLLNode predecessor, next; // Constructor DLLNode(String elem, DLLNode pred, DLLNode succ) { this.data = elem; this.next = succ; this.predecessor = pred; } } CS2007, Dr M. Collinson

35. A Java Class for Doubly-linked Lists class DLL { DLLNode first, last; // Constructor for an empty DLL. DLL () { this.first = null; this.last = null; } } CS2007, Dr M. Collinson

36. Example DLL construction // set-up doubly-linked list list = new DLL(); DLLNode catNode = new DLLNode("cat",null,null); DLLNode batNode = new DLLNode("bat",null,catNode); DLLNode antNode = new DLLNode("ant",null,batNode); catNode.predecessor = batNode; batNode.predecessor = antNode; list.first = antNode; list.last = catNode; CS2007, Dr M. Collinson

37. Speed of list implementation

38. Which to use? • Which implementation should we use? • Depends on how we are going to use the list • Frequency of get, add, remove. • Usually at beginning or end of list, or can be anywhere? CS2007, Dr M. Collinson

39. Efficiency of Stack implementations • Array or DLL better than SLL. • Array marginally faster than DLL.

40. Efficiency: Queue/Dequeue • DLL better for Dequeue • Note: there is a clever array-implementation which is fast: ArrayDeque in Java.

41. (Space) Memory Efficiency • Linked lists need a bit of extra space for the links. • Array lists waste space if array bigger than list. • Not a huge difference CS2007, Dr M. Collinson

42. Implementation Time • Easy to do using Java Collections Framework: • java.util.LinkedList. • If implementing directly: • Linked lists generally very easy, just add a “next” field to the objects that hold data. • Array lists more complex, have to deal with copying to bigger array. • Linked list widely used in languages without collection classes (core C, Pascal). CS2007, Dr M. Collinson

43. Summary • Linked lists are an alternative way of implementing lists to array lists • In most cases ArrayList (ArrayDeque) faster • Although LinkedList better in a few cases • Linked list easier to implement directly. CS2007, Dr M. Collinson

44. Java LinkedList • List Interface: • http://download.oracle.com/javase/1.4.2/docs/api/java/util/List.html • LinkedList class • http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html CS2007, Dr M. Collinson