13-Doubly Linked List data structure.pdf

Doubly-Linked Lists
15-121 Fall 2020
Margaret Reid-Miller

Today
• Exam 1: mean 86, high 98
Amazing!!
• Hw6 will be posted tonight
• Change Hw due dates?
Plan for Today
• Singly-linked list removed at index method
• Java's LinkedList class
• Doubly-linked lists
Fall 2020 15-121 (Reid-Miller) 2

Singly-linked list
• Add at index 3
• Insert node between nodes at index 2 and 3.
• Think add “after 2,” not “before 3,” as you can
always add AFTER a node.
• When do you need to consider a special case?
When you add the first node (after head).
• Remove at index 3
• Remove returns the value of the node removed.
• Like add, need to remove the node “after 2”
• Are there any special cases to consider?

Exercise: Remove at given index
// Removes the object at the given index.
// Returns the object removed
public E remove(int index) {
if (index < 0 || index > size())
throw new IndexOutOfBoundsException();

Remove at index 3 goal
first
remove here
(index = 3)
null
2
obj

Remove at given index
// Removes the object at the given index.
// Returns the object removed
public E remove(int index) {
if (index < 0 || index > size())
throw new IndexOutOfBoundsException();
if (index == 0) {
return removeFirst();
}
…
// cont’d

Remove at given index (cont’d)
…
Node nodeBefore = first;
for (int i = 0; ; i++) {
nodeBefore = nodeBefore.next;
}
// remove the node
…
size--;
return obj;
}

Remove at index 3
first
remove here
(index = 3)
current
WRONG
1. current.next = current.next.next;
2. E obj = current.next.data;
null
2
2
obj
1

Remove at index 3
first
remove here
(index = 3)
current
Correct
1. E obj = current.next.data;
2. current.next = current.next.next;
null
2
1
obj
2

Remove at given index (cont’d)
…
for (int i = 0; i < index-1; i++) {
}
// remove the node
E obj = nodeBefore.next.data;
nodeBefore.next = nodeBefore.next.next;
size--;
return obj;
}

Remove at given index (cont’d alternate)
…
for (int i = 0; i < index-1; i++) {
}
// remove the node
Node nodeToRemove = nodeBefore.next;
nodeBefore.next = nodeToRemove.next;
size--;
return nodeToRemove.data;
}

Complexity
On a singly linked list with n nodes:
Worst Average Best
addFirst __________________
removeFirst __________________
add(index, obj) __________________
remove(index) __________________
O(n) O(n) O(1)
O(n) O(n) O(1)
O(1)
O(1)

Disadvantages of
Singly-Linked Lists
• Insertion into a list is generally linear.
• In order to insert a node at an index greater
than 0, we need a reference to the previous
node.
• In order to remove a node that is not the first
node, we need a reference to the previous
node.
• We can only traverse the list in one direction.

Java's LinkedList class
Java's LinkedList add(E obj) method runtime is O(1).
How?
LinkedList has a field that refers to the
last node in the list.
Java's LinkedList remove(int index) method runtime
is O(1). How is it possible even if your have the last
node?
The nodes inside LinkedList are doubly linked in
order to remove from the end of the list in O(1) time.

Doubly-Linked Lists
prev data next
null
last
null
first

Doubly-Linked Lists
• Each data entry is stored in its own node
• Each node as two references: one reference is to the
next node and one is to the previous node (prev).
• A reference, often referred to as head, points to the
first node in the list and one reference, often referred
to as tail, points the the last node in the list.
• The head node’s prev reference is null and the tail
node’s next reference is null.
• An empty list would have head and tail references
equal to null

Node class
private class Node {
private E data;
private Node prev;
private Node next;
private Node(E obj, Node previous, Node next){
data = obj;
prev = previous;
this.next = next;
}

1. To add a node at a given index
find the node at index-1
null
last
null
first
null
null
before
newNode

4. Result of adding at given index
null
last
null
first

How would you implement addFirst?
null
last
null
first
How would you implement addLast?

How would you remove the node
referenced by current?
null
last
null
first current

How would you remove the node if
current == first?
null
last
null
first current

How would you remove the node if
current == last?
null
last
null
first current

How would you remove the node
current if first == tail?
tail
null
head
null
current

Doubly-linked list complexity
int size()
boolean add(E obj)
void add(int index, E obj)
E get(int index)
E set(int index, E obj)
boolean contains(Object obj)
int indexOf(Object obj)
E remove(int index)
boolean remove(Object obj)
Worst Average Best
O(1)
O(1)
O(n) O(n) O(1)
O(n) O(n) O(1)
O(n) O(n) O(1)
O(n) O(n) O(1)
O(n) O(n) O(1)
O(n) O(n) O(1)
O(n) O(n) O(1)

13-Doubly Linked List data structure.pdf

Recommended

Recommended

More Related Content

Similar to 13-Doubly Linked List data structure.pdf

Similar to 13-Doubly Linked List data structure.pdf (20)

More from ssusere3b1a2

More from ssusere3b1a2 (10)

Recently uploaded

Recently uploaded (20)

13-Doubly Linked List data structure.pdf