Data Structures and Algorithms

1. Data Structures and Algorithms Linked List 1

2. Lists • The Linked List • ADT Linked List • The Linked List Class Definition • Linked List Class implementation • Example Application 2

3. 2. The Linked List Linked List Abstraction: • Linked List: a container of data in the form of a linear configuration of nodes in which we can insert and delete nodes in any order. Each Node is linked to its successor in the list. If it also supports search by contents, it can represent a dictionary ADT. • Node: a containerfor one data item and has a direct relationship with at most two other nodes, its predecessor (if any) and its successor (if any). • Head node or first node is the only node without a predecessor. • Currentnode: special node in the list, indicated by the currentposition. • Previous Node: the predecessor of the current node 3

4. Ordered Linked List Class • We will construct a class “List” whose objects are linked lists. They will be implemented as dynamic lists. • The data members will be the nodes and the pointers to these nodes. • A node contains a key field and a data field. Search is by content (key) • The list will be orderedon the key field. 4

5. (a) ADT Linked List Linked List Data Members • Nodes. Each node has: • Data or information field of type dataType. • A key of type keyType • Link field (next) , a pointer to next node • Pointers: head, a pointer to the first node; cursor, a pointer to the current node; prev, a pointer to the previous node. 5

6. Data Members Current Last NULL head First prev cursor key data next 6

7. Node Specification // The linked structure for a node can be // specified as a Class in the private part of // the main linked list class. class node // Hidden from user { public: keyType key; // key dataType data; // Data node *next; // pointer to next node }; // end of class node declaration typedef node * NodePointer; // Pointers NodePointer head, cursor, prev; 7

8. Linked List Operations Notation Meaning • head the head pointer • cursor pointer to current node • prev pointer to predecessor node • pnew pointer to a new node • d item with the same type as the data portion of a node • k item with type as the key portion of the node • b boolean value • L Length of list 8

9. Linked List Class Operations • construct & initialize list to empty • listIsEmpty  b : return True if list is empty • curIsEmpty  b : return True if current position is empty • toFirst : to make the current node the first node; if list is empty, the current position is still empty • atFirst  b : to return True if the current node is the first node or if the list and the current position are both empty. 9

10. Linked List Class Operations • advance : to advance to next node. Assume the current position is nonempty initially. • toEnd: to make the current node the tail node; if list is empty, the current position is still empty • atEnd  b : to return True if the current node is the tail node or if the list and the current position are both empty. • listSize  L: to return the size of the list • updateData (d) : to update the data portion of the currentnode to contain d; assume the current position is nonempty. 10

11. Linked List Class Operations • retrieveData  d: to return the data in the currentnode; assume the current position is nonempty. • insertFirst (k,d) : insert a node with key (k) and data (d) at the head of the list; the new node becomes the current node. • insertAfter (k,d): insert a node after the current node without changing the current position; assume the current position is nonempty in a non-empty list. • insertBefore (k,d): insert a node before the current node ; current position becomes the new node 11

12. Linked List Class Operations • insertEnd(k,d):insert a node at the end of the list, current position becomes the new node. • deleteNode: delete the currentnode and set the current position to the next node; if the currentnode is the last node initially, the current position becomes empty; assume the current position is nonempty initially. • deleteFirst: delete the first node and set the current position to the next node; if it was initially the only node, the current position becomes empty; 12

13. Linked List Class Operations • deleteEnd: delete the last node and set the current position to empty. • makeListEmpty: delete whole list • search (k)  b : search the list for the node with key part that matches (k). If found, set cursor to the node and return True, else return false and the current position becomes empty. 13

14. Linked List Class Operations • orderInsert (k,d) : insert a node in a position that maintains an ascending order of the key portion of the nodes. • traverse: traverse list to print key and info fields. The Linked List will be implemented as a template class to allow different types for the key and data fields. 14

15. (b) Linked List Class Definition // File: List.h // Definition of Simple Linked List Template Class #ifndef LIST_H #define LIST_H // Specification of the class template <class keyType, class dataType> class List { public: 15

16. List Class Header File // Member Functions // Create an empty List List(); // Class Destructor ~List(); // Functions Prototype Definitions bool listIsEmpty() const; bool curIsEmpty() const; void toFirst(); bool atFirst() const; void advance(); 16

17. List Class Header File void toEnd(); bool atEnd() const; int listSize() const; void updateData (const dataType & ); void retrieveData (dataType &) const; void insertFirst (const keyType &, const dataType & ); void insertAfter (const keyType &, const dataType & ); void insertBefore (const keyType &, const dataType & ); void insertEnd (const keyType &, const dataType & ); void deleteNode(); void deleteFirst(); 17

18. List Class Header File void deleteEnd(); void makeListEmpty(); bool search (const keyType & ); void orderInsert(const keyType &, const dataType & ); void traverse(); 18

19. List Class Header File private: // Node Class class node { public: keyType key; // key dataType data; // Data node *next; // pointer to next node }; // end of class node declaration key data next 19

20. List Class Header File typedef node * NodePointer; // Pointers NodePointer head, cursor, prev; }; // End of class List declaration #endif// LIST_H #include "List.cpp" 20

21. Part of Implementation file // Class Constructor template <class keyType, class dataType> List<keyType, dataType>::List() { head = NULL; cursor = NULL; prev = NULL; } 21

22. // Class destructor template <class keyType, class dataType> List<keyType, dataType>::~List() { makeListEmpty(); } // return True if list is empty template <class keyType, class dataType> bool List<keyType, dataType>::listIsEmpty() const { return (head == NULL); } 22

23. // to make the current node the first node; // if list is empty, // the current position is still empty template <class keyType, class dataType> void List<keyType, dataType>::toFirst() { cursor = head; prev = NULL; } 23

24. // to advance to next node. Assume //the current position // is nonempty initially. template <class keyType, class dataType> void List<keyType, dataType>::advance() { prev = cursor; cursor = cursor->next; } 24

25. // to make the current node the tail node; // if list is empty, the current position is still empty template <class keyType, class dataType> void List<keyType, dataType>::toEnd() { toFirst(); if (! listIsEmpty()) while ( cursor->next != NULL) advance(); } 25

26. // to return the size of the list template <class keyType, class dataType> int List<keyType, dataType>::listSize() const { NodePointer q; int count; q = head; count = 0; while (q != NULL) { count++; q = q->next; } return count; } 26

27. // insert a node with data at the head of the list // the new node becomes the current node. template <class keyType, class dataType> void List<keyType, dataType>::insertFirst(const keyType &k, const dataType &d ) { NodePointer pnew; pnew = new node; pnew->key = k; pnew->data = d; pnew->next = head; head = pnew; cursor = head; prev = NULL; } 27

28. Learn on your own about: • Check the rest of the list operation • Array-based implementation of Linked Lists 28