1 / 27

Linked List

Linked List. Chapter 17 Linked List as Objects. Linked List Design. We completed the basic operations in a linked list (Part A): Traverse the list Search for an item Insert an item Delete an item The last topic in the course is to implement linked list as objects. Where are we?.

bjorn
Télécharger la présentation

Linked List

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 List Chapter 17 Linked List as Objects COMP103 - Linked Lists (Part B)

  2. Linked List Design • We completed the basic operations in a linked list (Part A): • Traverse the list • Search for an item • Insert an item • Delete an item • The last topic in the course is to implement linked list as objects. COMP103 - Linked Lists (Part B)

  3. Where are we? • So far, we have not treated linked list as an object. • We have not applied the principle of Abstract Data Type. • It is declared as struct type, therefore, the main program CAN access directly the fields in a NODE, such as data and link. • This creates problems when we • change the implementation of the NODE • don’t want to release the internal structure of NODE for security reasons COMP103 - Linked Lists (Part B)

  4. Linked List Design // Node Constructor Node :: Node (int dataIn) { data = dataIn; link = NULL; } Node declared as a class: • 2 private members: • Data (relevant information) • link (pointer to the next Node) • Private constructor • Friend class List(to create and access a node) class Node { private: int data; Node* link; friend class List; Node (int); // constructor }; // class Node COMP103 - Linked Lists (Part B)

  5. Friend class List as object 2 public functions Also keeps the 3 required pointers, as private variables addToList deleteFromList COMP103 - Linked Lists (Part B)

  6. Class Definition of List class List { private: Node* pHead; Node* pPre; // predecessor Node* pCur; // current position in list bool addNode(int item); void deleteNode (); bool searchList (int argument); public: List (); // constructor ~List (); // destructor int addToList (int dataIn); bool deleteFromList (int key); }; COMP103 - Linked Lists (Part B)

  7. addToList(public function) // Return 0  successful add // Return 1  item already in the list // Return 2  dynamic memory is full int List::addToList(int item) { int success; success = 0; // Default is successful if (searchList(item) == true) success = 1; // Found duplicate data else if (addNode(item) == false) success = 2; // Memory overflow return success; } • Calls 2 private functions: • searchList • addNode COMP103 - Linked Lists (Part B)

  8. searchList(private function) bool List::searchList(int target) { bool found; pPre = NULL; pCur = pHead; // Search until target <= list data while (pCur && target > pCur->data) { pPre = pCur; pCur = pCur->link; } // Determine if target found if (pCur && target == pCur->data) found = true; else found = false; return found; } COMP103 - Linked Lists (Part B)

  9. addNode(private function) bool List::addNode(int item) { Node* pNew; pNew = new Node(item); if (!pNew)return false; // memory overflow if (pPre == NULL){ // Add before first node or to empty list pNew->link = pHead; pHead = pNew; } else { // Add in the middle or at the end pNew->link = pPre->link; pPre->link = pNew; } return true; } COMP103 - Linked Lists (Part B)

  10. deleteFromList(public function) bool List::deleteFromList(int key) { if (searchList(key)) { deleteNode(); return true; // found } else return false; // not found } • Calls 2 private functions: • searchList • deleteNode COMP103 - Linked Lists (Part B)

  11. deleteNode(private function) void List::deleteNode() { if (pPre == NULL) pHead = pCur->link; // first node is deleted else pPre->link = pCur->link; // node at other location is deleted delete (pCur); return; } COMP103 - Linked Lists (Part B)

  12. List constructor (default) When a new list is constructed, we must setpHead = NULL, because the list is initially empty. pPreandpCurmust also beNULL, since there is no node to point to. List::List() { pHead = NULL; pPre = NULL; pCur = NULL; } COMP103 - Linked Lists (Part B)

  13. List destructor When a list is destroyed, we must delete all the nodes. To do this, we traverse the list and we delete the nodes one by one. List::~List() { Node *pDelete; Node *pTemp; pDelete = pHead; // while there are more nodes while (pDelete!=NULL) { pTemp = pDelete->link; delete pDelete; // delete the current node pDelete = pTemp; // go to the next node } } COMP103 - Linked Lists (Part B)

  14. Recall the declarations of Node and List class List { private: Node* pHead; Node* pPre; // predecessor Node* pCur; // current position in list bool addNode(int item); void deleteNode (); bool searchList (int argument); public: List (); // constructor ~List (); // destructor int addToList (int dataIn); bool deleteFromList (int key); }; class Node { private: int data; Node* link; friend class List; Node (int); }; // class Node COMP103 - Linked Lists (Part B)

  15. Problem!! • The data structure is in the node class, • Inside the List we do not know and cannot access the data in the node. • Outside the node, applications cannot access the pHead, pPre, pCur, etc. How can we traverse the item in the List from a program? COMP103 - Linked Lists (Part B)

  16. Solution Another ADT (class) ListIterator enables one to manipulate a List object. • We can “use” ListIterator to perform the following functions: • Set the manipulation to start at the first item of the list: • functionreset • Advance to the next node in the list: • functionoperator++ • Determine whether the current node is valid or not: • functionoperator! • Access the content of the current node: • functionoperator* COMP103 - Linked Lists (Part B)

  17. Iterator, List & Node COMP103 - Linked Lists (Part B)

  18. ListIterator Class Definition class ListIterator { private: Node *pWalker; public: // set pWalker to the first node void reset(List &pList); // returns data in the current node int operator*(); // check whether pWalker points to a valid node bool operator!(); // advance to next node Node* operator++(int); }; COMP103 - Linked Lists (Part B)

  19. Access to private data class Node { … // add this declaration friend class ListIterator; … }; class List { … // add this declaration friend class ListIterator; … }; • ListIterator must access the private members of Node and List • Therefore, ListIterator must be a friend of both Node and List COMP103 - Linked Lists (Part B)

  20. reset and operator! main() { List list; ListIterator listWalker; listWalker.reset(list) … // add items to list while (!listWalker) { … } } // sets current pointer to header void ListIterator :: reset (List& list) { pWalker = list.pHead; } // checks whether pointer is valid bool ListIterator :: operator! () { return pWalker != NULL; } This statement will become false when we reach the end of the list COMP103 - Linked Lists (Part B)

  21. operator++() main() { List list; ListIterator listWalker; listWalker.reset(list) … // add items to list while (!listWalker) { … listWalker++; } } // advance to the next node Node* ListIterator :: operator++ (int) { if (pWalker) pWalker = pWalker->link; return pWalker; } The syntax operator++(int) is used to denote the postfix operator: listWalker++ If you use operator++(void) instead, you declare a prefix operator: ++listWalker Will return to this later!! COMP103 - Linked Lists (Part B)

  22. operator*() main() { List list; ListIterator listWalker; listWalker.reset(list) … // add items to list while (!listWalker) { … cout << *listWalker; listWalker++; } } // returns data in the current node int ListIterator :: operator* () { if (!pWalker) { cout << "Invalid list reference\n"; exit (105); } else return pWalker->data; } COMP103 - Linked Lists (Part B)

  23. Example: calculate average const int LIST_SIZE = 100; // Prototype Declarations void buildList(List &list); void printAvrgList(List &list); void printList(List &list); void main() { List list; buildList(list); printList(list); printAvrgList(list); } COMP103 - Linked Lists (Part B)

  24. buildList(List &list) void buildList (List &list) { int datum, result; int i; for (i = 0; i < LIST_SIZE; i++) { cout << “input integer: “ << endl; cin >> datum; // input integer result = list.addToList (datum); if (result == 1) cout << "Duplicate data: " << datum << endl; else if (result == 2) cout << "\a\aERR 200: Memory Overflow\n"; } // end for } COMP103 - Linked Lists (Part B)

  25. printList(List &list) void printList(List& list) { ListIterator listWalker; listWalker.reset(list); cout << “ The list is “<< endl; while (!listWalker) { cout << “data: “ << *listWalker << endl; listWalker++; } } COMP103 - Linked Lists (Part B)

  26. printAvrgList(List &list) void printAvrgList (List& list) { int count = 0, sum = 0; float avrg; ListIterator listWalker; listWalker.reset(list); // set to header while (!listWalker) { sum += *listWalker; // sum = sum + data count++; // increment count listWalker++;// next node } if (count) avrg = (float) sum / count; else avrg = 0; cout << "\nTotal value: " << sum << "\n for " << count << " items.“ << "\nAverage is: " << avrg << endl; } COMP103 - Linked Lists (Part B)

  27. The End COMP103 - Linked Lists (Part B)

More Related