1. Lecture 4 Linked Lists King Fahd University of Petroleum & Minerals College of Computer Science & Engineering Information & Computer Science Department

2. Singly Linked List 2

3.  Representation  Space Analysis  Creation and Insertion  Traversal  Search  Deletion 3

4. Representation  We are using a representation in which a linked list has both head and tail references. listhead tail public class MyLinkedList{ protected Element head; protected Element tail; public final class Element{ Object data; Element next; Element(Object obj, Element element){ data = obj; next = element; } public Object getData(){return data;} public Element getNext(){return next;} } 4

5. Representation: Space Analysis  Now, we can take a look at the space requirements: S(n) = sizeof(MyLinkedList) + n sizeof(MyLinkedList.Element) = 2 sizeof(MyLinkedList.Element ref) + n [sizeof(Object ref) + sizeof(MyLinkedList.Element ref)] = (n + 2) sizeof(MyLinkedList.Element ref) + n sizeof(Object ref) ExplanationSpace Require The list reference has two fields: head (type: Element) and tail (type: Element) = 2 sizeof(MyLinkedList.Element ref) sizeof(MyLinkedList) The list has n elements of type Element. Each element has two fields-- data (type Object) and next (type Element). n sizeof(MyLinkedList.Element) 5

6. List Creation and Insertion  An empty list is created as follows:  Once created, elements can be inserted into the list using either the append or prepend methods  Also if we have reference to a node (an element), we can use insertAfter or InsertBefore of the Element class. head tail MyLinkedList list = new MyLinkedList(); for (int k = 0; k < 10; k++) list.append(new Integer(k)); 6

7. public void append(Object obj){ Element element = new Element(obj, null); if(head == null) head = element; else tail.next = element; tail = element; } Insertion at the end (Append) Complexity isO(1) 7

8. public void prepend(Object obj) { Element element = new Element(obj, head); if(head == null) tail = element; head = element; } Insertion at the beginning (Prepend) Complexity isO(1) 8

9. Insertion before and after an element public void insertBefore(Object obj) { Element element = new Element(obj, this); if(this == head) { head = element; return; } Element previous = head; while (previous.next != this) { previous = previous.next; } previous.next = element; } Complexity is public void insertAfter(Object obj) { next = new Element(obj, next); if(this == tail) tail = next; } Complexity isO(1) O(n) 9

10. Traversal To move a reference e from one node to the next: Example: Count the number of nodes in a linked list. public int countNodes(){ int count = 0; Element e = head; while(e != null){ count++; e = e.next; } return count; } e = e.next; Complexity isO(n) 10

11. Searching  To search for an element, we traverse from head until we locate the object. Example: Count the number of nodes with data field equal to a given object. public int countNodes(Object obj){ int count = 0; Element e = head; while(e != null){ if(e.data.equals(obj)) count++; e = e.next; } return count; } Complexity is …. 11 O(n)

12. public void extract(Object obj) { Element element = head; Element previous = null; while(element != null && ! element.data.equals(obj)) { previous = element; element = element.next; } if(element == null) throw new IllegalArgumentException("item not found"); if(element == head) head = element.next; else previous.next = element.next; if(element == tail) tail = previous; } Deletion  To delete an element, we use either the extract method of MyLinkedList or that of the Element inner class. Complexity is … 12 O(n)

13. Deletion - Difference between the MyLinkedList and the Element extracts  To delete an element, we use either the extract method of MyLinkedList or that of the Element inner class. try{ list.extract(obj1); } catch(IllegalArgumentException e){ System.out.println("Element not found"); } MyLinkedList.Element e = list.find(obj1); if(e != null) e.extract(); else System.out.println("Element not found"); 13

14. Deletion – Deleting First and Last Element public void extractFirst() { if(head == null) throw new IllegalArgumentException("item not found"); head = head.next; if(head == null) tail = null; } public void extractLast() { if(tail == null) throw new IllegalArgumentException("item not found"); if (head == tail) head = tail = null; else { Element previous = head; while (previous.next != tail) previous = previous.next; previous.next = null; tail = previous; } Complexity is … 14 O(1) O(n)

15. Exercises  For the MyLinkedList class, Implement each of the following methods:  String toString()  Element find(Object obj)  void insertAt(int n) //counting the nodes from 1. State the complexity of each method.  Which methods are affected if we do not use the tail reference in MyLinkedList class. 15

16. Doubly Linked List 16

17. Doubly Linked Lists  Representation  Space Analysis  Creation and Insertion  Traversal  Deletion 17

18. Representation public class DoublyLinkedList{ protected Element head, tail; //... public class Element { Object data; Element next, previous; Element(Object obj, Element next, Element previous){ data = obj; this.next = next; this.previous = previous; } public Object getData(){return data;} public Element getNext(){return next;} public Element getPrevious(){return previous;} //... } list head tail 18

19. Doubly Linked Lists : Space Analysis  The space requirements of our representation of the doubly linked lists is as follows: S(n) = sizeof(DoublyLinkedList) + n sizeof(DoublyLinkedList.Element) = 2 sizeof(DoublyLinkedList.Element ref) + n [sizeof(Object ref) + 2 sizeof(DoublyLinkedList.Element ref)] = (2n + 2) sizeof(DoublyLinkedList.Element ref) + n sizeof(Object ref) ExplanationRequired space The list reference has two fields: head (type: Element) and tail (type: Element) = 2 sizeof(DoublyLinkedList.Element ref) sizeof(DoublyLinkedList) The list has n elements of type Element. Each element has three fields-- previous (type Element), data (type Object), and next (type Element) n sizeof(DoublyLinkedList. Element) 19

20. List Creation and Insertion  An empty doubly linked list is created as follows: DoublyLinkedList list = new DoublyLinkedList();  Like singly link list, once created, elements can be inserted into the list using either the append or prepend methods for (int k = 0; k < 10; k++) list.append(new Int(k));  Also if we have reference to a node (an element), we can use insertAfter or InsertBefore of the Element class.. b) head tail 20

21. Insertion at the end (append) public void append(Object obj){ Element element = new Element(obj, null, tail); if(head == null) head = tail = element; else { tail.next = element; tail = element; } Complexity is … 21 O(1)

22. Insertion at the beginning (prepend) public void prepend(Object obj){ Element element = new Element(obj, head, null); if(head == null) head = tail = element; else { head.previous = element; head = element; } Complexity is … 22 O(1)

23. Insertion before an element  Inserting before the current node (this) that is neither the first nor the last node: Complexity is … Element element = new Element(obj, this, this.previous); this.previous.next = element; this.previous = element; 23 O(1)

24. Traversal For DoublyLinked list, traversal can be done in either direction. Forward, starting from head, or backward starting from tail. Example: Count the number of nodes in a linked list. Element e = head; while (e != null) { //do something e = e.next; } Element e = tail; while (e != null) { //do something e = e.previous; } public int countNodes(){ int count = 0; Element e = head; while(e != null){ count++; e = e.next; } return count; } Complexity is … 24 O(n)

25. public int sumLastNnodes(int n){ if(n <= 0) throw new IllegalArgumentException("Wrong: " + n); if(head == null) throw new ListEmptyException(); int count = 0, sum = 0; Element e = tail; while(e != null && count < n){ sum += ((Integer)e.data).intValue(); count++; e = e.previous; } if(count < n) throw new IllegalArgumentException(“No. of nodes < "+n); return sum; } Traversal Example: The following computes the sum of the last n nodes: Complexity is … 25 O(n)

26. Deletion  To delete an element, we use either the extract method of DoublyLinkedList or that of the Element inner class. public void extract(Object obj){ Element element = head; while((element != null) && (!element.data.equals(obj))) element = element.next; if(element == null) throw new IllegalArgumentException("item not found"); if(element == head) { head = element.next; if(element.next != null) element.next.previous = null; }else{ element.previous.next = element.next; if(element.next != null) element.next.previous = element.previous; } if(element == tail) tail = element.previous; } Complexity is … 26 O(n)

27. Exercises  For the DoublyLinkedList class, Implement each of the following methods and state its complexity.  String toString()  Element find(Object obj)  void ExtractLast()  void ExtractFirst()  void ExtractLastN(int n)  For the DoublyLinkedList.Element inner class, implement each of the following methods and state its complexity.  void insertBefore()  void insertAfter()  void extract()  What are the methods of DoublyLinkedList and its Element inner class are more efficient than those of MyLinkedList class? 27