Chapter 17 Linked List

Chapter 17Linked 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.

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

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

A0 A1 A2 first last 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;

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;

A0 A1 A2 current first Inserting an element last 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;

A0 A1 A2 current first last tmp Inserting an element 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;

A0 A1 A2 current x first last tmp Inserting an element 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;

A0 A1 A2 current x first last tmp Inserting an element 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 x first last tmp Inserting an element 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;

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

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

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

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

Header node 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 nodeholds no data but serves to satisfy the requirement that every node have a previous node. Not necessarily a standard implementation.

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

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

a c head tail current Inserting into a 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 a 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 a c current b head tail 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 a 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

Circular Linked Lists a b c d 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.

Chapter 17 Linked List