Chapter 17 Linked List Saurav Karmakar Spring 2007

LISTS Easiest implementation of LIST --- ARRAY :: has Disadvantages. 1) To insert an item at the beginning or middle of an array  sliding lots of items over one place to make room :: ~ O(n) 2) Arrays have a fixed length :: can't be changed.  Adding items to a list  Allocation a whole new array if the array containing LIST is full and then move all the items from the old array to the new one.

Linked List Consists of connected, dynamically allocated nodes. A linked list is made up of "nodes". Each node has two components: an item, and a reference to the next node in the list.

Comparison with Array 1.Arrays contiguous direct access of elements insertion / deletion difficult 2.Linked Lists noncontiguous must scan for element insertion /deletion easy 1.Arrays contiguous direct access of elements insertion / deletion difficult 2.Linked Lists noncontiguous must scan for element insertion /deletion easy arrayname

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

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; A0A1A2 firstlast Adding an element

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; A0A1A2 firstlast

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; A0A1A2 firstlast

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; A0A1A2x firstlast

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; A0A1A2x firstlast

class ListNode { Object element; ListNode* next; } At any point, we can insert a new item x by doing this: tmp = new ListNode(); Tmp->element = x; Tmp->next = current->next; Current->next = tmp; last Inserting an element A0A1A2 first current

class ListNode { Object element; ListNode* next; } At any point, we can insert a new item x by doing this: tmp = new ListNode(); Tmp->element = x; Tmp->next = current->next; Current->next = tmp; Inserting an element A0A1A2 first last current tmp

class ListNode { Object element; ListNode* next; } At any point, we can insert a new item x by doing this: tmp = new ListNode(); Tmp->element = x; Tmp->next = current->next; Current->next = tmp; Inserting an element A0A1A2 first last current x 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; Inserting an element A0A1A2 first last current x 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; Inserting an element A0A1A2 first last current x tmp

Simplified version Current->next = new ListNode(x, current->next) tmp = new ListNode(); Current->next = tmp; Tmp->next = current->next; Tmp->element = x;

class ListNode { Object element; ListNode* next; } Current->next = current->next->next; Deleting an element A0A1A2 current last

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

Delete a Node Node *deletedNode = current->next; Current- >next = current->next->next; Delete deletedNode;

Length Function The Length function takes a linked list and computes the number of elements in the list. /*Given a linked list head pointer, compute and return the number of nodes in the list.*/ int Length(struct node* head) { struct node* current = head; int count = 0; while (current != NULL) { count++; current = current->next; } return count; }

abc 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. Header node

abc head tail class DoubleListNode { Object element; ListNode* next; ListNode* prev; } class DoubleListNode { Object element; ListNode* next; ListNode* prev; } A doubly linked list allows bidirectional traversal by storing two pointers per node. Doubly Linked Lists

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

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 ac head tail current

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

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

Inserting into a Doubly Linked List ac head tail newNode = new DoublyLinkedListNode() newNode->prev = current; newNode->next = current->next; newNode->prev->next = newNode; newNode->next->prev = newNode; current = newNode b 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 ac head tail b 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 ac head tail b 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 ac head tail b current

Circular Linked Lists abcd first

Sorted Linked List A sorted link list is one in which items are in sorted order. The major difference from linked list is the insertion operation.