CPSC 260 Data Structures and Algorithms for Computer Engineers Linked Lists!

Transcription

1 CPSC 260 Data Structures and Algorithms for Computer Engineers Linked Lists! Winter 2013 Instructor: Hassan Khosravi

2 Problems with Arrays and Vectors With arrays and vectors you are allocated a large space. how would you insert an new element into an array How would you remove an element from the array How would you increase the memory allocated? 1.2

3 Linked Lists Use Linked List to overcome some of these problems Instead of requesting an array, get one object at a time Domain: a collection of nodes each of which contains a data element; a pointer to a node at the head of the list Structure: there is a pointer to the first node in the list and each node contains a pointer that points to the next node in the list, with the exception of the last 1.3

4 Arrays operations Linked Lists Insert Delete Find Print 1.4

5 Node- Implementation typedef int Item_type; class Node{ public: Node(); Node(const ItemType& item, Node* next); Node(const ItemType& item); private: friend class LinkedList;! ItemType item; Node* next;}; 1.5

6 LinkedList - Implementation class LinkedList{ public: LinkedList(); ~LinkedList(); void deletelist(); void insertfirst(node*& node); void insertfirst(const ItemType& item); void insertlast(node*& node); void insertlast(const ItemType& item); Node* find(const ItemType& item); void printvalues(); void printvaluesrec(); bool deleteitem(const ItemType& item); private: Node* head; void printrechelper(node* current); }; 1.6

7 Insert an item at the beginning of the list void LinkedList::insertFirst(const ItemType& item) { Node* node = new Node(item); node->next = head; head = node; } void LinkedList::insertFirst(Node*& node) { node->next = head; head = node; } 1.7

8 Insert an item at the end of the list void LinkedList::insertLast(const ItemType& item) { Node* node = new Node(item); if (head == nullptr) head = node; else { Node* current = head; while(current->next!= nullptr) current = current->next; current->next = node; } } 1.8

9 Insert an item at the end of the list void LinkedList::insertLast(const ItemType& item) { Node* node = new Node(item); if (head == nullptr) head = node; else { Node* current = head; while(current->next!= nullptr) current = current->next; current->next = node; } } 1.9

10 Find an item in the list Node* LinkedList::find(const ItemType& item) { Node* current = head; while (current!=nullptr && current->item!=item) current = current->next; return current; } 1.10

11 Delete an item from the list Deleting an item from the middle of the list Deleting an item from the beginning of the list Deleting an item from the end of the list 1.11

12 Delete an item from the list bool LinkedList::deleteItem(const ItemType& item){ Node* current= head; Node* previousnode = NULL; while( current!= NULL && current->item!= item ) { } previousnode = current; current = current->next; if( current == NULL ) return false; else { }} // item not found if( previousnode == NULL ) // item is at front of list else head = current->next; previousnode->next = current->next; delete current; return true; 1.12

13 Print all items in the list void LinkedList::printValues() { Node* current=head; while (current!=nullptr) { cout<< current->item; current = current->next; } } 1.13

14 Print all items in the list let s make the observation that if we process the first node, we can consider the next node (if any) to be the head of another linked list and simply apply the same operation to that list and so on until we end up with an empty list. What does this sound like? void LinkedList::printRecHelper(Node* current) { } if (current!=nullptr) { } cout<<current->item; printrechelper(current->next); void LinkedList::printValuesRec() { } printrechelper(head); 1.14

15 Delete the LinkedList Can we delete the list recursively? void LinkedList::deleteList() { if (head!= nullptr) { Node* current = head; head = head->next; delete current; deletelist(); } } 1.15

16 Circular LinkedLists Some problems are circular by nature A simple example is keeping track of whose turn it is in a multiplayer board game How would this change the implementation of our class? Constructor? Traversing? Finding? Exercise: Use inheritance to create a class for Circular LinkedList 1.16

17 Doubly Linked List What if we want to traverse our list backwards? Say, to search for the last occurrence of an item. What if we want to delete an element when we have a pointer to it. Delete(node) Each node can point to the previous node as well as a pointing to the next node. Such a list looks as follows: 1.17

18 Doubly Linked List class Node { public: Node(); Node(const ItemType& item, Node* next); Node(const ItemType& item); private: friend class LinkedList; ItemType item; Node* next; Node* previous; }; How would the LinkedList class would change? 1.18

19 Doubly Linked List Creating an empty linked list Node *makeempty() { Node *head = new Node; head->next = head; head->prev = head; return head; } InsertFirst 1.19

20 Doubly Linked List- Insert 1.20

21 Doubly Linked List- Remove Exercise: Use inheritance to create a class for doubly LinkedList 1.21

22 The list class If you feel like you are reinventing the wheel you are absolutely right C++ STL has a doubly-linked list #include <list> using namespace std; list<string> names; Adding elements to the end of a list is straight-forward: names.push_back(tom); names.push_back(dick); names.push_back(harry); 1.22

23 The list class-iterators Cannot directly access elements using subscript access (e.g. names[2]) Instead, start at the beginning, then visit each element in turn list-iterator marks a position in a list list<string>::iterator pos; pos = names.begin(); The ++ operator moves to the next element: pos++; The -- operator moves an iterator backward: pos--; 1.23

24 Use the * operator to find the value that is stored at that position Remember, if pos points to an element, then *pos is that element To read or change an element: string value = *pos; *pos = Romeo ; // The list value at the position is changed Changing pos merely changes the current position: pos = names.begin(); // The list value at the position is changed 1.24

25 The list class-insertion To insert an element before the iterator position, use the insert function: names.insert(pos, Romeo); To insert at the beginning of the list: pos = names.begin(); names.insert(pos, Romeo); To insert at the end: pos = names.end(); // Points one past the end names.insert(pos, Juliet); The end() iterator does not point at a valid object 1.25

26 The list class-traversal end() is useful for stopping a traversal: pos = names.begin(); while (pos!= names.end()) { cout << *pos << \n»; pos++; } With a for loop: for (pos = names.begin(); pos!= names.end(); pos++) cout << *pos << \n; 1.26

27 Removal To remove an element, move an iterator to the element: pos = names.begin(); pos++; Call the erase() method: names.erase(pos); //pos now points to what was the 3 rd element 1.27

28 The Efficiency of List and Arrays Operations We will analyze and compare the efficiency of fundamental operations on linked lists and vectors These operations are: Getting the k th element Linear time with lists Constant time with arrays Adding and removing an element at a given position Constant time with lists Linear time with Arrays. 1.28

29 Queue FIFO First in, first out Items inserted at the back, removed from the front To visualize a queue, consider people lining up in a store Stacks LIFO Last in, first out Items inserted and removed at one end, the top 1.29

30 The STL has a stack template class To insert and remove, use push() and pop() #include <stack>; using namespace std; stack<string> s; s.push(tom); s.push(dick); s.push(harry); while (s.size() > 0) { cout << s.top() << \n; s.pop(); } top() doesn't modify the stack 1.30

31 STL queue The STL has a queue template class To insert and remove, use push() and pop() #include <queue>; using namespace std; queue<string> q; q.push(tom); q.push(dick); q.push(harry); while (q.size() > 0) { cout << q.front() << \n; q.pop(); } front() doesn't modify the queue 1.31