Singly Linked Lists Representation Space Analysis Creation and Insertion Traversal Search Deletion

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

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)

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));

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 is O(1)

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

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 O(n) public void insertAfter(Object obj) { next = new Element(obj, next); if(this == tail) tail = next; } Complexity is O(1)

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 is O(n)

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

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 …

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");

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 …

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.

Doubly Linked Lists Representation Space Analysis Creation and Insertion Traversal Deletion

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

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)

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

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 …

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 …

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;

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 …

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 …

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 …

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?