Download Linked Lists

Chapter 6
Data Structures: Linked Lists
CSC 113
King Saud University
College of Computer and Information Sciences
Department of Computer Science
Ahmad Al-Rjoub
1. Objectives
After you have read and studied this chapter, you should be able to:
• Understand the concept of a dynamic data structure.
• Be able to create and use dynamic data structures such as linked
lists.
• Understand the stack and queue ADTs.
• Various important applications of linked data structures.
• Know how to use inheritance to define extensible data
structures.
• Create reusable data structures with classes, inheritance and
composition.
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
2. Self-Referential Classes: Definition
•Self-referential class
Contains an instance variable that refers to another
object of the same class type
That instance variable is called a link
A null reference indicates that the link does not
refer to another object
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
2. Self-Referential Classes (cont)
A link to another
Node object.
T
Node<T>
T
Node<T>
Node (in o: T)
setData(in o: T)
getData(): T
setNext(in link: Node<T>)
getNext(): Node<T>
1
1
next
data
Node<T>
Node (in o: T)
setData(in o: T)
getData(): T
setNext(in link:
Node<T>)
getNext():
Node<T>
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Basic Node: The Generic Node Class
•
A node in a linked list contains data elements and link elements.
Student
- name: String
- id: int
- grade: double
Node<T>
T
Node<T>
+ student()
+ set(…)
Node (in o: T)
setData(in o: T)
getData(): T
setNext(in link: Node<T>)
getNext(): Node<T>
+ get()…
Ali
Dr. SalahAl-Rjoub
Hammami
Ahmad
Jamel
Kamal
KSU-CCIS-CS
Generic Node Class: Implementation
public class Node<T> {
private T data; // Stores any kind of data
private Node<T> next;
public Node<T>(T obj) {
data = obj;
next = null;
}
public void setNext( Node<T> nextPtr ) {
next = nextPtr;
}
public Node<T> getNext() {
return next;
}
public void setData(T obj) {
data = obj;
}
public T getData() {
return data;
}
public String toString() {
return data.toString();
}
}
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Connecting two nodes
The statements
Student S1 = new Student(“Ali”, 42700000, 3.5)
Student S2 = new Student(“Ahmed”, 4271000, 3.9)
Node <Student> p = new Node <Student>(S1);
Node <Student> q = new Node(S2);
allocate storage for two objects of type Node referenced by p and q.
The node referenced by p stores the object S1, and the node referenced
by q stores the object S2. The next fields of both nodes are null.
Nodes referenced by p and q
S1
Dr. SalahAl-Rjoub
Hammami
Ahmad
S2
KSU-CCIS-CS
Connecting two nodes (Cont)
The statement
p.setNext (q);
stores the address of node q in the link field of node p, thereby
connecting node p to node q, and forming a linked list with 2 nodes.
The diagonal line in the next field of the second list node indicates the
value null.
Linked list with two nodes
S1
Dr. SalahAl-Rjoub
Hammami
Ahmad
S2
KSU-CCIS-CS
Linked Lists: Definition
• Linked list
– Linear collection of nodes
• A linked list is based on the concept of a self-referential object -an object that refers to an object of the same class.
– A program typically accesses a linked list via a reference to the first
node in the list
• A program accesses each subsequent node via the link reference
stored in the previous node
– Are dynamic
• The length of a list can increase or decrease as necessary
• Become full only when the system has insufficient memory to
satisfy dynamic storage allocation requests
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Generic Linked Lists
List<T>
T
name: String
List ()
1
data
1
next
List(n: String)
insertAtFront(o: T)
Node<T>
insertAtBack(o: T)
Node (in o: T)
setData(in o: T)
getData(): T
setNext(in link:
Node<T>)
getNext():
Node<T>
1
first
removeFromFront():T
removeFromBack():T
isEmpty(): Boolean
size(): int
insertAfter(int, T)
insertBefore(int, T)
remove(int):T
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Implementation of the Generic Linked Lists
public class List<T>
{
private Node<T> first;
private String name;
public List()
{ name=“ “;
first=null;
}
public List(String listName )
{ name = listName;
first = null;
}
……
……
Dr. SalahAl-Rjoub
Hammami
Ahmad
}
KSU-CCIS-CS
Linked List: insertAtFront
•
Method insertAtFront’s steps
– Call isEmpty to determine whether the list is empty
– If the list is empty, assign firstNode and lastNode to the new ListNode that was
initialized with insertItem
• The ListNode constructor call sets data to refer to the insertItem passed as
an argument and sets reference nextNode to null
– If the list is not empty, set firstNode to a new ListNode object and initialize that
object with insertItem and firstNode
• The ListNode constructor call sets data to refer to the insertItem passed as
an argument and sets reference nextNode to the ListNode passed as
argument, which previously was the first node
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: insertAtFront (Cont)
Graphical representation of operation insertAtFront
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: insertAtFront (Cont)
Code of insertAtFront
public void insertAtFront(T obj) {
Node N =
new Node(obj);
N.setNext(first);
first = N;
} // insertAtFront()
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: insertAtBack
•
Method insertAtBack’s steps
– Call isEmpty to determine whether the list is empty
– If the list is empty, assign firstNode and lastNode to the new ListNode that
was initialized with insertItem
• The ListNode constructor call sets data to refer to the insertItem passed
as an argument and sets reference nextNode to null
– If the list is not empty, assign to lastNode and lastNode.nextNode the
reference to the new ListNode that was initialized with insertItem
• The ListNode constructor sets data to refer to the insertItem passed as an
argument and sets reference nextNode to null
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: insertAtBack (Cont)
Graphical representation of operation insertAtBack.
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: insertAtBack (Cont)
public void insertAtBack(T obj) {
if (isEmpty())
Solution 1
first = new Node(obj);
else {
Node current = first;
// Start at head of list
while (current.getNext() != null)
// Find the end of the list
current = current.getNext();
current.setNext(new Node(obj));
// Insert the newObj
}
} // insertAtRear
public void insertAtBack(T obj) {
Node N =new Node(obj);
Solution 2
if (isEmpty())
first = N;
else {
Node current = first;
// Start at head of list
while (current.getNext() != null)
// Find the end of the list
current = current.getNext();
current.setNext(N));
// Insert the newObj
}
} // insertAtRear
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: removeFromFront
•
Method removeFromFront’s steps
– Throw an EmptyListException if the list is empty
– Assign firstNode.data to reference removedItem
– If firstNode and lastNode refer to the same object, set firstNode and
lastNode to null
– If the list has more than one node, assign the value of firstNode.nextNode to
firstNode
– Return the removedItem reference
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: removeFromFront
Graphical representation of operation removeFromFront.
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: removeFromFront
Code of removeFromFront
public T removeFromFrontt() {
if (isEmpty())
return null;
Node N = first; // T d = first.getdata();
first = first.getNext();
return N.getData(); // return d;
}
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: removeFromBack
•
Method removeFromBack’s steps
– Throws an EmptyListException if the list is empty
– Assign lastNode.data to removedItem
– If the firstNode and lastNode refer to the same object, set firstNode and
lastNode to null
– If the list has more than one node, create the ListNode reference current and
assign it firstNode
– “Walk the list” with current until it references the node before the last node
– The while loop assigns current.nextNode to current as long as
current.nextNode is not lastNode
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: removeFromBack
Graphical representation of operation removeFromBack.
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Linked List: removeFromBack
Code of removeFromBack
public T removeFromBack() {
if (isEmpty())
// Empty list
return null;
Node current = first;
if (current.getNext() == null) { // Singleton list
first = null;
return current.getData();
}
Node previous = null;
// All other cases
while (current.getNext() != null) {
previous = current;
current = current.getNext();
}
previous.setNext(null);
return current.getData();
} // removeLast()
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Generic Linked Lists and Interface
List<T>
T
name: String
1
next
1
List ()
data
List(n: String)
Node<T>
Node (in o: T)
setData(in o: T)
getData(): T
setNext(in link:
Node<T>)
getNext():
Node<T>
Dr. SalahAl-Rjoub
Hammami
Ahmad
displayAll()
1
first
countSimilar(T): int
search(T): int
remove(int): T
remove(T):T
Intersection(List<T>): List<T>
KSU-CCIS-CS
Generic Linked Lists and Interface
Code of displayAll()
public void displayAll() {
if (!(isEmpty()))
<Interface>
{
AAAA
Node current = first;
while (current!= null)
display()
{
current.getData().display();
current=current.getNext();
}
}
}
This method must be implemented by each substitute class of the generic type.
We add an Interface to our package containing this method “display” and each substitution’s class of the
generic type must implement the Interface.
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Generic Linked Lists and Interface
Code of countSimilar(T):int
public int count(T t) {
Node current = first;
<Interface>
int x=0;
AAAA
while (current!= null)
{
display()
if (current.getData().compare(t))
compare(Object): Boolean
x++;
current=current.getNext();
}
return x;
}
This method must be implemented by each substitute class of the generic type.
We add an Interface to our package containing this method “compare” and each substitution’s class of the
generic type must implement the Interface.
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Generic Linked Lists and Interface
Code of search(T):int
public int search(T t) {
Node current = first;
<Interface>
int x=0;
AAAA
while (current!= null)
{
display()
x++;
compare(Object): Boolean
if (current.getData().compare(t))
return x;
current=current.getNext();
}
return -1;
}
This method must be implemented by each substitute class of the generic type.
We add an Interface to our package containing this method “compare” and each substitution’s class of the
generic type must implement the Interface.
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Generic Linked Lists and Interface
Code of remove(int):T
public T remove (int x) {
if ((isEmpty()) || (x<0) || (x>size())
return null;
if (x==1) return removeFromFront();
if (x==size()) return removeFromBack();
Node current = first;
for(int i=1, i<x-1 ; i++)
current = current.getNext();
T d=current.getNext().getdata();
current.setNext(current.getNext().getNext());
return d;
}
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS
Generic Linked Lists and Interface
Code of remove(T):T
public int remove(T t) {
int x = search(t);
return remove(x);
}
Dr. SalahAl-Rjoub
Hammami
Ahmad
KSU-CCIS-CS