singly linked lists
Download
Skip this Video
Download Presentation
Singly Linked Lists

Loading in 2 Seconds...

play fullscreen
1 / 24

Singly Linked Lists - PowerPoint PPT Presentation


  • 84 Views
  • Uploaded on

Singly Linked Lists. Representation Space Analysis Creation and Insertion Traversal Search Deletion. list. head. tail. Representation. We are using a representation in which a linked list has both head and tail references. public class MyLinkedList{ protected Element head;

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Singly Linked Lists' - kevina


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
singly linked lists
Singly Linked Lists
  • Representation
  • Space Analysis
  • Creation and Insertion
  • Traversal
  • Search
  • Deletion
representation

list

head

tail

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

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

list creation and insertion
List Creation and Insertion

head

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

MyLinkedList list = new MyLinkedList();

tail

  • for (int k = 0; k < 10; k++)
  • list.append(new Integer(k));
insertion at the end append
Insertion at the end (Append)

public void append(Object obj){

Element element = new Element(obj, null);

if(head == null)

head = element;

else

tail.next = element;

tail = element;

}

Complexity is

O(1)

insertion at the beginning prepend
Insertion at the beginning (Prepend)

public void prepend(Object obj) {

Element element = new Element(obj, head);

if(head == null)

tail = element;

head = element;

}

Complexity is

O(1)

insertion before and after an element
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
Traversal

To move a reference e from one node to the next:

Example: Count the number of nodes in a linked list.

e = e.next;

  • public int countNodes(){
  • int count = 0;
  • Element e = head;
  • while(e != null){
  • count++;
  • e = e.next;
  • }
  • return count;
  • }

Complexity is

O(n)

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

deletion
Deletion
  • To delete an element, we use either the extract method of MyLinkedList or that of the Element inner class.

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;

}

Complexity is …

deletion difference between the mylinkedlist and the element extracts
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
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;

}

Complexity is …

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
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
Doubly Linked Lists
  • Representation
  • Space Analysis
  • Creation and Insertion
  • Traversal
  • Deletion
representation1

head

list

tail

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

// . . .

}

}

doubly linked lists space analysis
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)

list creation and insertion1

head

b)

tail

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..
insertion at the end append1
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 prepend1
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
Insertion before an element
  • Inserting before the current node (this) that is neither the first nor the last node:

Element element = new Element(obj, this, this.previous);

this.previous.next = element;

this.previous = element;

Complexity is …

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

traversal2
Traversal

Example: The following computes the sum of the last n nodes:

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

Complexity is …

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

exercises1
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?
ad