Chapter 17 Linked List

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

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

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 ;

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;

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;

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;

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;

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;

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;

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

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

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

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

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

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

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

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

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.

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

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

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

Inserting into a Doubly Linked List c head tail current newNode = new DoublyLinkedListNode() newNode->prev = current; newNode->next = current->next; newNode->prev->next = newNode; newNode->next->prev = newNode; current = newNode

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

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

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

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

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

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

Deleting an element from a double linked list c b head current oldNode=current; oldNode->prev->next = oldNode->next; oldNode->next->prev = oldNode->prev; current = oldNode->prev; delete oldNode;

Deleting an element from a double linked list c b head current oldNode oldNode=current; oldNode->prev->next = oldNode->next; oldNode->next->prev = oldNode->prev; current = oldNode->prev; delete oldNode;

Deleting an element from a double linked list c b head current oldNode oldNode=current; oldNode->prev->next = oldNode->next; oldNode->next->prev = oldNode->prev; current = oldNode->prev; delete oldNode;

Deleting an element from a double linked list c b head current oldNode oldNode=current; oldNode->prev->next = oldNode->next; oldNode->next->prev = oldNode->prev; current = oldNode->prev; delete oldNode;

Deleting an element from a double linked list c b head current oldNode oldNode=current; oldNode->prev->next = oldNode->next; oldNode->next->prev = oldNode->prev; current = oldNode->prev; delete oldNode;

Deleting an element from a double linked list c head current oldNode=current; oldNode->prev->next = oldNode->next; oldNode->next->prev = oldNode->prev; current = oldNode->prev; delete oldNode;

Circular Linked lists a b c d first

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

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

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

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)

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