1. Chapter 17
Linked List

2. Objective Linked lists basic ideas: header nodes and iterator classes
Implementation details
doubly linked lists
circular linked lists

3. Arrays Linked Lists arrayname contiguous direct access of elements
insertion / deletion difficult
Linked Lists
noncontiguous
must scan for element
insertion /deletion easy
arrayname

4. Iterating through a data structure
for (int i = 0; i < length; i++)
cout<< a[i];
for (ListNode p = theList.first; p != null; p = p.next)
cout<< p.data ;

5. Adding an element A0 A1 A2 first last class ListNode { Object data;
ListNode* next; }
At any point, we can add a new last item x by doing this:
last->next = new ListNode();
last = last->next;
last->data = x;
last->next = null;

6. A0 A1 A2 first last class ListNode { Object data; ListNode* next; }
At any point, we can add a new last item x by doing this:
last->next = new ListNode() ;
last = last->next;
last->data = x;
last->next = null;

7. A0 A1 A2 first last class ListNode { Object data; ListNode* next; }
At any point, we can add a new last item x by doing this:
last->next = new ListNode();
last = last->next;
last->data = x;
last->next = null;

8. A0 A1 A2 x first last class ListNode { Object data; ListNode* next; }
At any point, we can add a new last item x by doing this:
last->next = new ListNode();
last = last->next;
last->data = x;
last->next = null;

9. A0 A1 A2 x first last class ListNode { Object data; ListNode* next; }
At any point, we can add a new last item x by doing this:
last->next = new ListNode();
last = last->next;
last->data = x;
last->next = null;

10. Inserting an element A0 A1 A2 current first last class ListNode {
Object element;
ListNode* next; }
At any point, we can add a new last item x by doing this:
tmp = new ListNode();
tmp->element = x;
tmp->next = current->next;
Current->next = tmp;

11. A0 A1 A2 current first last tmp class ListNode { Object element;
ListNode* next; }
At any point, we can add a new last item x by doing this:
tmp = new ListNode();
tmp->element = x;
tmp->next = current->next;
Current->next = tmp;
tmp

12. A0 A1 A2 current x first last tmp class ListNode { Object element;
ListNode* next; }
At any point, we can add a new last item x by doing this:
tmp = new ListNode();
tmp->element = x;
tmp->next = current->next;
current->next = tmp;
tmp

13. A0 A1 A2 current x first last tmp class ListNode { Object element;
ListNode* next; }
At any point, we can add a new last item x by doing this:
tmp = new ListNode();
tmp->element = x;
tmp->next = current->next;
current->next = tmp;
tmp

14. A0 A1 A2 current x first last tmp class ListNode { Object element;
ListNode* next; }
At any point, we can add a new last item x by doing this:
tmp = new ListNode();
tmp->element = x;
tmp->next = current->next;
current->next = tmp;
tmp

15. Simplified version
current->next = new ListNode(x, current->next);

16. Deleting an element A0 A1 A2 current last class ListNode {
Object element;
ListNode* next; }
current->next = current->next->next;

17. Deleting an element A0 A1 A2 current last class ListNode {
Object element;
ListNode* next; }
Current->next = current->next->next; Memory leak!

18. Deleting an element A0 A1 A2 current last
Node *deletedNode = current->next;
current->next = current->next->next;
delete deletedNode;

19. Header Nodes a b c header
Header nodes allow us to avoid special cases [in the code] such as insertion of the first element and removal of the last element.
The header node holds no data but serves to satisfy the requirement that every node have a previous node.
Not necessarily a standard implementation.

20. C++ implementation
We have a list.
This list consists of listNodes.
In order to access these listNodes, we need an iterator.
Code: online

21. Doubly Linked Lists a b c head tail
Consider how hard it is to back up in a singly linked list.
Also consider text editor example
class DoubleListNode {
Object element;
ListNode* next;
ListNode* prev; }

22. Empty Doubly Linked Listc
head
tail
// constructor
DoubleList() {
head = new DoubleListNode ();
tail = new DoubleListNode ();
head->next = tail;
tail->prev = head; }

23. Inserting into a Doubly Linked Listc
head
tail
current
newNode = new DoublyLinkedListNode()
newNode->prev = current;
newNode->next = current->next;
newNode->prev->next = newNode;
newNode->next->prev = newNode;
current = newNode

24. Inserting into a Doubly Linked Listc b
head
tail
current
newNode = new DoublyLinkedListNode()
newNode->prev = current;
newNode->next = current->next;
newNode->prev->next = newNode;
newNode->next->prev = newNode;
current = newNode

25. Inserting into a Doubly Linked Listc b
head
tail
current
newNode = new DoublyLinkedListNode()
newNode->prev = current;
newNode->next = current->next;
newNode->prev->next = newNode;
newNode->next->prev = newNode;
current = newNode

26. Inserting into a Doubly Linked Listc b
head
tail
current
newNode = new DoublyLinkedListNode()
newNode->prev = current;
newNode->next = current->next;
newNode->prev->next = newNode;
newNode->next->prev = newNode;
current = newNode

27. Inserting into a Doubly Linked Listc b
head
tail
current
newNode = new DoublyLinkedListNode()
newNode->prev = current;
newNode->next = current->next;
newNode->prev->next = newNode;
newNode->next->prev = newNode;
current = newNode

28. Inserting into a Doubly Linked Listc b
head
tail
current
newNode = new DoublyLinkedListNode()
newNode->prev = current;
newNode->next = current->next;
newNode->prev->next = newNode;
newNode->next->prev = newNode;
current = newNode

29. Inserting into a Doubly Linked Listc b
head
tail
current
newNode = new DoublyLinkedListNode()
newNode->prev = current;
newNode->next = current->next;
newNode->prev->next = newNode;
newNode->next->prev = newNode;
current = newNode

30. Deleting an element from a double linked listc b
head
current
oldNode=current;
oldNode->prev->next = oldNode->next;
oldNode->next->prev = oldNode->prev;
current = oldNode->prev;
delete oldNode;

31. Deleting an element from a double linked listc b
head
current
oldNode
oldNode=current;
oldNode->prev->next = oldNode->next;
oldNode->next->prev = oldNode->prev;
current = oldNode->prev;
delete oldNode;

32. Deleting an element from a double linked listc b
head
current
oldNode
oldNode=current;
oldNode->prev->next = oldNode->next;
oldNode->next->prev = oldNode->prev;
current = oldNode->prev;
delete oldNode;

33. Deleting an element from a double linked listc b
head
current
oldNode
oldNode=current;
oldNode->prev->next = oldNode->next;
oldNode->next->prev = oldNode->prev;
current = oldNode->prev;
delete oldNode;

34. Deleting an element from a double linked listc b
head
current
oldNode
oldNode=current;
oldNode->prev->next = oldNode->next;
oldNode->next->prev = oldNode->prev;
current = oldNode->prev;
delete oldNode;

35. Deleting an element from a double linked listc
head
current
oldNode=current;
oldNode->prev->next = oldNode->next;
oldNode->next->prev = oldNode->prev;
current = oldNode->prev;
delete oldNode;

36. Circular Linked lists a b c d
first

37. Sorted Linked List
A sorted link list is one in which items are in sorted order. It can be derived from a list class.
code

38. Common errors (Page 599 )
Splicing in nodes incorrectly when performing insertion
Forgetting incomplete class declaration
Calling delete at wrong time during remove()
More errors on page 599 are given

39. In class exercises … Question 17.3 from the book.
Write an algorithm for printing a singly linked list in reverse. (Don’t use recursion).

40. In class exercises Question 17.7 from the book.
Suppose that you have a pointer to a node in singly linked list that guaranteed not to be the last node in the list. You do not have pointers to any other nodes (except by following links). Describe an O(1) algorithm that logically removes the value stored in such a node from the linked list, maintaining the integrity of the linked list (Hint: Involve the next node)

41. Programming Homework
Implement a linked list
On line
Due Feb 28th.