Lecture 4

Linked Lists

King Fahd University of Petroleum & MineralsCollege of Computer Science & Engineering

Information & Computer Science Department

Singly Linked List

2

Singly Linked List

Representation

Space Analysis

Creation and Insertion

Traversal

Search

Deletion

3

Representation

We are using a representation in which a linked list has both head and tail references .

list head

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

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)

Space RequireExplanation

sizeof(MyLinkedList)

The list reference has two fields:

head (type: Element) and tail (type: Element)

= 2 sizeof(MyLinkedList.Element ref)

n

sizeof(MyLinkedList.Element)

The list has n elements of type Element. Each element has two fields-- data (type Object) and next (type Element).

5

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

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)

7

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)

8

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

O(n)

9

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)

10

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)

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)

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

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…

Complexity is…

14

O(1)

O(n)

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

Doubly Linked List

16

Doubly Linked Lists

Representation

Space Analysis

Creation and Insertion

Traversal

Deletion

17

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

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)

Required spaceExplanation

sizeof(DoublyLinkedList)The list reference has two fields:

head (type: Element) and tail (type: Element)

= 2 sizeof(DoublyLinkedList.Element ref)

n sizeof(DoublyLinkedList.

Element)

The list has n elements of type Element. Each element has three fields-- previous (type Element), data (type Object), and next (type Element)

19

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

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)

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)

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)

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)

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)

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)

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