1. Chapter Lists
Dr Zeinab Eid

2. 3.3 Doubly-Linked Lists
It is a way of going both directions in a linked list, forward and reverse.
Many applications require a quick access to the predecessor node of some node in list.
Dr Zeinab Eid

3. Advantages over Singly-linked Lists
Quick update operations:
such as: insertions, deletions at both ends (head and tail), and also at the middle of the list.
A node in a doubly-linked list store two references:
A next link; that points to the next node in the list, and
A prev link; that points to the previous node in the list.
Dr Zeinab Eid

4. Doubly Linked List
A doubly linked list provides a natural implementation of the List ADT
Nodes implement Position and store:
element
link to the previous node
link to the next node
Special trailer and header nodes
prev
next
elem
node
trailer
header
nodes/positions
elements
Dr Zeinab Eid

5. Sentinel Nodes
To simplify programming, two special nodes have been added at both ends of the doubly-linked list.
Head and tail are dummy nodes, also called sentinels, do not store any data elements.
Head: header sentinel has a null-prev reference (link).
Tail: trailer sentinel has a null-next reference (link).
Dr Zeinab Eid

6. What we see from a Douby-linked List?
A doubly-linked list object would need to store the following:
Reference to sentinel head-node;
Reference to sentinel tail-node; and
Size-counter that keeps track of the number of nodes in the list (excluding the two sentinels).
Dr Zeinab Eid

7. Empty Doubly-Linked List:
Using sentinels, we have no null-links; instead, we have:
head.next = tail
tail.prev = head
Singl Node List:
Size = 1
This single node is the first node, and also is the last node:
first node is head.next
last node is tail.prev
header
trailer
first
last
header
trailer
Dr Zeinab Eid

8. Insertion into a Doubly-Linked List
AddFirst Algorithm
To add a new node as the first of a list:
Algorithm addFirst()
new(T)
T.data ← y
T.next ← head.next
T.prev ← head
head.next.prev ← T {Order is important}
head.next ← T
Size++
This Algorithm is valid also in case of empty list.
Dr Zeinab Eid

9. Insertion into a Doubly-Linked List (Cont.)
AddLast Algorithm
To add a new node as the last of list:
Algorithm addLast()
new(T)
T.data ← y
T.next ← tail
T.prev ← tail.prev
tail.prev.next ← T {Order is important}
tail.prev ← T
Size++
This Algorithm is valid also in case of empty list.
Dr Zeinab Eid

10. Removal from a Doubly-Linked List
RemoveLast Algorithm
Notice that before removal, we must check for empty list. If not, we will remove the last node in the list, as shown in Figure above.
Dr Zeinab Eid

11. Algorithm removeLast() If size = 0 then output “error”
else { T ← tail.prev
y ← T.data
T.prev.next ← tail
tail.prev ← T.prev
delete(T) {garbage collector}
size--
return y }
This algorithm is valid also in case of a single node, size=1, in which case we’ll get an empty list. Algorithm is one statement.
Dr Zeinab Eid

12. Insertion p A B C p q A B C X p q A B X C
We visualize operation AddAfter(p, X), which returns position q p A B C p q A B C X p q A B X C
Dr Zeinab Eid

13. Insertion Algorithm Algorithm insertAfter(p,e): Create a new node v
v.setElement(e)
v.setPrev(p) {link v to its predecessor}
v.setNext(p.getNext()) {link v to its successor}
(p.getNext()).setPrev(v) {link p’s old successor to v}
p.setNext(v) {link p to its new successor, v}
return v {the position for the element e}
Dr Zeinab Eid

14. Deletion A B C D p A B C p D A B C
We visualize remove(p), where p = last() A B C D p A B C p D A B C
Dr Zeinab Eid

15. Deletion Algorithm Algorithm remove(p):
t = p.element {a temporary variable to hold the return value}
(p.getPrev()).setNext(p.getNext()) {linking out p}
(p.getNext()).setPrev(p.getPrev())
p.setPrev(null) {invalidating the position p}
p.setNext(null)
return t
Dr Zeinab Eid

16. Performance
In the implementation of the List ADT by means of a doubly linked list
The space used by a list with n elements is O(n)
The space used by each position of the list is O(1)
All the operations of the List ADT run in O(1) time
Operation element() of the Position ADT runs in O(1) time
Dr Zeinab Eid

17. Position ADT (§ 5.2.2)
The Position ADT models the notion of place within a data structure where a single object is stored
It gives a unified view of diverse ways of storing data, such as
a cell of an array
a node of a linked list
Just one method:
object element(): returns the element stored at the position
Dr Zeinab Eid

18. List ADT (§ 5.2.3)
The List ADT models a sequence of positions storing arbitrary objects
It establishes a before/after relation between positions
Generic methods:
size(), isEmpty()
Accessor methods (all return type Position):
first(), last()
prev(p), next(p)
Update methods:
replace(p, e)
remove(p)
insertBefore(p, e)
insertAfter(p, e)
insertFirst(e)
insertLast(e)
Dr Zeinab Eid

19. Implementing Vector ADT with List ADT
size(), isEmpty()
first(), last()
prev(p), next(p)
replace(p, e)
remove(p)
insertBefore(p, e)
insertAfter(p, e)
insertFirst(e)
insertLast(e)
Vector ADTs:
size() and isEmpty()
elemAtRank(integer r)
object replaceAtRank(integer r, object o)
insertAtRank(integer r, object o)
object removeAtRank(integer r)
Dr Zeinab Eid