1 / 28

Linked Lists

Learn about linked lists, a data structure that optimizes memory usage by dynamically allocating and deallocating memory based on the number of elements in use. Compared to arrays, linked lists allow for direct access and have no maximum number of elements.

yolandab
Télécharger la présentation

Linked Lists

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. Linked Lists

  2. Motivation A list data structure that uses only the amount of memory needed for the number of elements in use at a given point in time.

  3. Compared to Arrays Arrays: - easily allocated/deallocated - direct access (accessing element n is done simply by indexing: [n]) Linked Lists: - no maximum number of elements - no waste of memory for unused elements.

  4. Node A Node is a dynamically allocated listelement, implemented as a structure that has at least two members: - key: a (usually) unique identifier for an element. - next: a pointer to a node.

  5. Definition A Linked Listis a linear, dynamically-allocated data structure. It consists of a head which is a pointer to a node. - The head points to the first element of the list; or is NULL when the list is empty. - The next pointer of each node points to the next node in the list; except the last node, where next is NULL.

  6. Examples:

  7. Class Definitions class node { friend class LList; private: int key; node * next; // circular reference OK }; class LList { private: node * head; };

  8. Algorithms When designing a function that operates on a Linked List, consider if the solution works for: - an empty list - a list of one node - a list of two or more nodes

  9. Algorithms "The Loop that solves all problems!" (well, most anyway) // point p to the first/head node node * p = head; while (p != NULL) { // process this node ... p = p->next; // go to next node } // or NULL

  10. Constructors #include <iostream> node::node() { key = 0; next = NULL; } LList::LList() { head = NULL; }

  11. Print void LList::print() { node * p = head; while (p != NULL) { cout << p->key << " "; p = p-> next; } }

  12. Search // return ptr to found node or // NULL = not found node * LList::search(intsrchKey) { node * p = head; while (p != NULL) { if (p->key == srchKey) return p; p = p->next; } return NULL; //looked at all, not found }

  13. Insert A new node should first be created and populated: void LList::insert(intnewkey) { node * n = new node; //allocate new node n->key = newkey; n->next = NULL; insert(n); // some insertion method } // given pointer to new node

  14. Insert (After) Given: - after: a pointer to a node in the List, after which the new node will be inserted. NULL to insert new head. - n: a pointer to the new node, already allocated and populated.

  15. Insert General Case: Blue arrows/null show values before insertion. Red arrows show links afterinsertion (changes)

  16. Insert New Head Case: red arrows show links after changes. Empty List Case: the same code will work when head is NULL

  17. Insert void LList::insertAfter(node* after, node* n) { if (head == NULL || after == NULL) { n->next = head; // insert as new head = n; // head of list } else { // insert middle/tail of list n->next = after->next; after->next = n; } // note: ORDER of statements is IMPORTANT! }

  18. Insert Checks: - Does it work for Empty List? [head is NULL] - Does it work for a List of 1 element? - as the new head? [after is NULL] - after the current head? [after == head] - Does it work for a list of 2 or more elements? - as the new head? [after is NULL] - as the new tail? (last in list) [after points to tail] - in the middle of the list?

  19. Remove Given: r- a pointer to a node in the List to be removed Removes the node from the list, but does not deallocate it. Alternative: Removes and deallocates the node.

  20. Remove Remove Head case:

  21. Remove General Case: Use b4 to find a pointer to the node before the one to remove

  22. Remove void LList::remove(node * r) { if (r == head) head = head->next; else { // must find node BEFORE one being removed node * b4 = head; while (b4->next != r) { b4 = b4->next; } b4->next = r->next; } r->next = NULL; // detach following node }

  23. Remove Checks: - Assumption: never invoked on Empty List - Assumption: r points to a node actually in the List. - Does it work for a List of 1 element? - Does it work for a list of 2 or more elements? - removing the head? - removing the tail? - removing a node in the middle of the list?

  24. Remove - Defensive Version void LList::remove(node * r) { if (head == NULL) return; // list empty, can't remove if (r == NULL) return; // nothing to remove!? if (r == x.head) x.head= x.head->next; else { // must find node BEFORE one being removed node * b4 = x.head; while (b4->next != r && b4 != NULL) { b4 = b4->next; } if (b4 == NULL) return; // node not in list!! b4->next = r->next; } r->next = NULL; }

  25. Remove Note: r still points to the removed node after remove() is finished. The function invoking remove() may choose to deallocate it or not.

  26. Remove - invocation void LList::fun() { ... node * p; p = ptr to node to remove; remove(p); cout << p->key << " was removed"; delete p; // deallocate removed node ... }

  27. Length // return: count of the nodes in the list void LList::length() { int num = 0; node * p = head; while (p != NULL) { num++; p = p->next; } return num; }

  28. Vocabulary

More Related