1. M180: Data Structures & Algorithms in Java Linked Lists Arab Open University 1

2. Outline Linked list nodes Linked list operations –Insertion –Append –Deletion Other types of linked lists –Doubly-linked –Circular

3. Limitation of Arrays An array has a limited number of elements –routines inserting a new value have to check that there is room Can partially solve this problem by reallocating the array as needed (how much memory to add?) –adding one element at a time could be costly –one approach - double the current size of the array A better approach: use a Linked List

4. Dynamically Allocating Elements Allocate elements one at a time as needed, have each element keep track of the next element Result is referred to as linked list of elements, track next element with a pointer

5. 5 Anatomy of a linked list A linked list consists of: –A sequence of nodes abcd Each node contains a value and a link (reference) to some other node The last node contains a null link The list may have a header myList

6. 6 More terminology A node’s successor is the next node in the sequence –The last node has no successor A node’s predecessor is the previous node in the sequence –The first node has no predecessor A list’s length is the number of elements in it –A list may be empty (contain no elements)

7. ListNode Linked Lists Stores a collection of items non-contiguously. Each item in the list is stored with an indication of where the next item is. Must know where first item is. The list will be a chain of objects, called nodes, of type ListNode that contain the data and a reference to the next ListNode in the list. Allows addition or deletion of items in the middle of collection with only a constant amount of data movement. Contrast this with array. A0A1A2A3 first ListNode

8. ListNode: Definition public class ListNode { DataType data; ListNode next; // constructors ListNode(DataType d, ListNode n) { data = d; next = n; } ListNode(DataType d) { this (d, null); } ListNode() { this (null); } }

9. a Linked List: Insertion Insert X immediately after current position a current b c d b c d x

10. Implementing Insertion: Step By Step Insertion immediately after current position // create a new node tmp = new ListNode (); a current b tmp

11. Implementing Insertion: Step By Step Insertion immediately after current position // create a new node tmp = new ListNode (); // place x in the element field tmp.data = x; a current b tmp

12. Implementing Insertion: Step By Step Insertion immediately after current position // create a new node tmp = new ListNode (); // place x in the element field tmp.data = x; a current b tmp x

13. Implementing Insertion: Step By Step Insertion immediately after current position // create a new node tmp = new ListNode (); // place x in the element field tmp.data = x; // x ’ s next node is b tmp.next = current.next; // a ’ s next node is x current.next = tmp; a current b tmp x

14. Implementing Insertion: Shorter Version A shorter version: // create a new node tmp = new ListNode (x,current.next); // a ’ s next node is x current.next = tmp; a current b tmp x

15. Implementing Insertion: Shorter Version A shorter version: // create a new node tmp = new ListNode (x,current.next); // a ’ s next node is x current.next = tmp; a current b tmp x

16. Insert X immediately at the end of the list // last refers to the last node in the linked list last.next = new ListNode (); last = last.next;// adjust last last.data = x;// place x in the node last.next = null;// adjust next Most efficient approach last = last.next = new ListNode (x, null); Implementing Append a b c d last a b c X d

17. Implementing Basic Deletion Delete an item immediately after current position Basic deletion is a bypass in the linked list. a b x a b current

18. current.next = current.next.next; Implementing Basic Deletion Need a reference to node prior to the one to be deleted. a b x a b x a b current

19. Iterate Through The Linked List If items are stored in contiguous array: //step through array, outputting each item for (int index = 0; index < a.length; index++) System.out.println (a[index]); If items are stored in a linked list: // step through list, outputting each item for(ListNode p=l.first; p!=null; p=p.next) System.out.println (p.data); A0A1A2A3 first

20. Implementing a Linked List So what would a Linked List implementation look like? What happens if we want to –Delete the first item? –Insert an item before the first item? class MyLinkedList { // Field ListNode first; // Methods void insert(DataType x, ???); void delete(DataType x, ???); void append(DataType x);... }

21. Header Nodes Deletion of first item and insertion of new first item are special cases. Can be avoided by using header node; –contains no data, but serves to ensure that first "real" node in linked has a predecessor. –To go to the first element, set current to header.next; –List is empty if header.next == null; Searching routines will skip header. A1A2A3 header

22. Linked Lists: List Implementation (partial) public class LinkedList implements List { ListNode header; // Constructor public LinkedList() { header = new ListNode (null); } // Test if the list is logically empty. public boolean isEmpty( ) { return header.next == null; } // Make the list logically empty public void makeEmpty( ) { header.next = null; } }

23. Representing the “current” position How do we specify where an operation should occur? –Index position (int?) –ListNode // Methods void insert(DataType x, ???); void delete(DataType x, ???); void insert(DataType x, int current); void delete(DataType x, int current); void insert(DataType x, ListNode current); void delete(DataType x, ListNode current); a x current

24. List Iterator Class Maintains a notion of the current position The List class provides methods that do not depend on any position (such as isEmpty, and makeEmpty ). A List iterator ( ListItr ) provides other methods such which act on the current position stored in the iterator: –next() / advance() –hasNext() / isValid() –retrieve()

25. Linked List Iterator: Implementation public class ListItr { ListNode current; // Current position ListItr(ListNode node) { } public boolean hasNext() { } public void next() { } public DataType retrieve() { } }

26. Example Usage A method that computes the number of elements in any list: public static int listSize (List theList) { int size = 0; ListItr itr; for(itr=theList.first();itr.hasNext();itr.next()) size++; return size; }

27. Linked Lists: Implementation public class List { // Header node private ListNode header; // Check if list is empty boolean isEmpty() {???} // Make the list empty void makeEmpty () {???} // Cursor to header node public ListItr zeroth() {???} // Cursor to first node public ListItr first() {???} // Cursor to (first) node containing x public ListItr find(T x) {???} // Cursor to node before node containing x public ListItr findPrevious(T x) {???} // Insert x after current cursor position public void insert(T x, ListItr current) {???} // Remove (first) node containing x public void remove(T x) {???} }

28. Print all elements of Linked List Method 1: Without Iterator, Simple Looping public class LinkedList { public void print() { // step through list, outputting each item ListNode p = header.next; while (p != null) { System.out.println (p.data); p = p.next; }

29. Print all elements of Linked List Method 4: Using Iterator class LinkedList { public void print() { ListItr > itr = first(); while(itr.hasNext()) { itr.next(); System.out.println(itr.retrieve()); }

30. Doubly-linked lists: Each list node stores both the previous and next nodes in the list. Useful for traversing linked lists in both directions. Circular-linked lists: Last node's next references the first node. Works with or without headers. Other Linked Lists A headtail prev next A B C first prev next

31. Doubly-linked lists: Wrong InsertNext newNode = new DoublyLinkedListNode ( x ); 1newNode.prev = current; 2 newNode.prev.next = newNode; … x b a 1 2

32. Doubly-linked lists: insertNext 1 newNode = new DoublyLinkedListNode (x); 2 newNode.prev = current; 3 newNode.next = current.next; 4 newNode.prev.next = newNode; 5 newNode.next.prev = newNode; 6 current = newNode; A B current X prev next newNode 1 3 25 4 6

33. Doubly-linked lists: DeleteCurrent 1.current.prev.next = current.next; 2.current.next.prev = current.prev; 3.current = current.prev; x b a current 1 2 3

34. 34 DLLs compared to SLLs Advantages: –Can be traversed in either direction (may be essential for some programs) –Some operations, such as deletion and inserting before a node, become easier Disadvantages: –Requires more space –List manipulations are slower (because more links must be changed) –Greater chance of having bugs (because more links must be manipulated)