1 / 37

Chapter 16-1 Linked Structures

Chapter 16-1 Linked Structures. Dale/Weems. Chapter 16 Topics. Meaning of a Linked List Meaning of a Dynamic Linked List Traversal, Insertion and Deletion of Elements in a Dynamic Linked List Specification of a Dynamic Linked Sorted List

eliana-middleton
Download Presentation

Chapter 16-1 Linked 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 16-1Linked Structures Dale/Weems

  2. Chapter 16 Topics • Meaning of a Linked List • Meaning of a Dynamic Linked List • Traversal, Insertion and Deletion of Elements in a Dynamic Linked List • Specification of a Dynamic Linked Sorted List • Insertion and Deletion of Elements in a Dynamic Linked Sorted List

  3. What is a List? • A list is a varying-length, linear collection of homogeneous elements • Linear means that each list element (except the first) has a unique predecessor and each element (except the last) has a unique successor

  4. To implement the List ADT The programmer must 1) choose a concrete data representation for the list, and 2) implement the list operations

  5. Recall:4 Basic Kinds of ADT Operations • Constructors -- create a new instance (object) of an ADT • Transformers -- change the state of one or more of the data values of an instance • Observers-- allow client to observe the state of one or more of the data values of an instance without changing them • Iterators -- allow client to access the data values in sequence

  6. List Operations Transformers • Insert • Delete • Sort Observers • IsEmpty • IsFull • Length • IsPresent change state observe state 6

  7. ADT List Operations Iterator • Reset • GetNextItem • Reset prepares for the iteration • GetNextItem returns the next item in sequence • No transformer can be called between calls to GetNextItem (Why?) Iteration Pair

  8. Array-based class List SelSort IsEmpty Private data: length data [0] [1] [2] [MAX_LENGTH-1] currentPos IsFull Length Insert Delete IsPresent Reset GetNexItem

  9. // Specification file array-based list (“list.h”) const int MAX_LENGTH = 50; typedef int ItemType; class List// Declares a class data type { public: // Public member functions List(); // constructor bool IsEmpty () const; bool IsFull () const; int Length () const; // Returns length of list void Insert (ItemType item); void Delete (ItemType item); bool IsPresent(ItemType item) const; void SelSort (); void Reset (); ItemType GetNextItem (); private: // Private data members int length; // Number of values currently stored ItemType data[MAX_LENGTH]; int CurrentPos; // Used in iteration }; 9

  10. Implementation Structures • Use a built-in array stored in contiguous memory locations, implementing operations Insert and Delete by moving list items around in the array, as needed • Use a linked list in which items are not necessarily stored in contiguous memory locations • A linked list avoids excessive data movement from insertions and deletions

  11. Implementation Possibilities for a List ADT List Linked list Built-in array Built-in dynamic data and pointers Built-in array of structs

  12. Array Representation of a Linked List component link Node[0] head Node[1] Node[2] Node[3] Node[4] Node[5] Node[6] Node[7]

  13. Data Structure of Array Based Linked List struct NodeType { int component; int link; }; NodeType node[1000]; // Max. 1000 nodes int head;

  14. Insert a New Node into a Linked List component link Node[0] head Insert 25, Setting link to 7 Node[1] Node[2] Node[3] Node[4] Change link from 7 to 1 Node[5] Node[6] Node[7]

  15. Delete a Node from a Linked List component link Node[0] head Node[1] Node[2] Node[3] Deleted Node[4] Node[5] Node[6] Change the link From 4 to 0 Node[7]

  16. ‘X’ ‘C’ ‘L’ head A Linked List • A linked list is a list in which the order of the components is determined by an explicit link member in each node • Each node is a struct containing a data member and a link member that gives the location of the next node in the list

  17. head “Ted” “Irv” “Lee” Dynamic Linked List • A dynamic linked list is one in which the nodes are linked together by pointers and an external pointer (or head pointer) points to the first node in the list

  18. 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL Nodes can be located anywhere in memory • The link member holds the memory address of the next node in the list head

  19. ‘A’6000 .component .link Declarations for a Dynamic Linked List // Type declarations struct NodeType { char component; NodeType* link; } typedef NodeType* NodePtr; // Variable DECLARATIONS NodePtr head; NodePtr ptr; 19

  20. ptr .Component .link ptr ‘A’ 6000 .component .link *ptr ptr ‘A’ 6000 .component .link (*ptr).component ptr->component Pointer Dereferencing and Member Selection ‘A’ 6000 ptr 20

  21. ptr .component .link ptr is a pointer to a node ‘A’ 6000 ptr 21

  22. ptr *ptr is the entire node pointed to by ptr ‘A’ 6000 .component .link *ptr 22

  23. ptr .component .link ptr->componentis a node member ‘A’ 6000 ptr->component (*ptr).component // Equivalent 23

  24. ptr .component .link ptr->linkis a node member ‘A’ 6000 ptr->link (*ptr).link // Equivalent 24

  25. ptr 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component // Or, do something else with node *ptr ptr = ptr->link; }

  26. ptr 3000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  27. ptr 3000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  28. ptr 3000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  29. ptr 5000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  30. ptr 5000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  31. ptr 5000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  32. ptr 2000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  33. ptr 2000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  34. ptr 2000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  35. ptr NULL 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  36. ptr NULL 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head Traversing a Dynamic Linked List // Pre: head points to a dynamic linked list ptr = head; while (ptr != NULL) { cout << ptr->component; // Or, do something else with node *ptr ptr = ptr->link; }

  37. The End of Chapter 16 Part 1

More Related