1 / 32

Understanding Linked Lists: Advantages Over Arrays in Data Structures

This chapter provides a comprehensive overview of linked lists and their advantages when compared to array implementations. It outlines the fundamental differences, including dynamic allocation and ease of insertion and deletion. While arrays are fixed in length and require shifting elements to insert or delete, linked lists consist of dynamically allocated nodes, making operations more efficient. The chapter also includes code snippets for adding and deleting elements, as well as the implementation of various functions to manage linked lists effectively.

fenella-peoples
Télécharger la présentation

Understanding Linked Lists: Advantages Over Arrays in Data Structures

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 17Linked List Saurav Karmakar Spring 2007

  2. 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.

  3. 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.

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

  5. 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 ;

  6. 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;

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

  11. 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;

  12. 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;

  13. 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;

  14. 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;

  15. 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;

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

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

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

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

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

  21. 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.

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

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

  24. 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

  25. 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

  26. 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

  27. 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

  28. 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

  29. 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

  30. 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

  31. Circular Linked Lists a b c d first

  32. 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.

More Related