1. Review on linked lists

2. Motivation * A “List” is a useful structure to hold a collection of data. n Currently, we use arrays for lists * Examples: List of ten students marks int studentMarks[10]; List of temperatures for the last two weeks double temperature[14];

3. Motivation * list using static array int myArray[1000]; int n; We have to decide (to oversize) in advance the size of the array (list) * list using dynamic array int* myArray; int n; cin >> n; myArray = new int[n]; We allocate an array (list) of any specified size while the program is running * linked-list (dynamic size) size = ?? The list is dynamic. It can grow and shrink to any size.

4. Array naturally represents a (ordered) list, the link is implicit, consecutive and contiguous! Now the link is explicit, any places! 2045 7585 Data Link 20 45 75 85 Data Link 20457585 Data Link 0 1 2 array linked list

5. Linked Lists: Basic Idea * A linked list is an ordered collection of data * Each element of the linked list has n Some data n A link to the next element * The link is used to chain the data Example: A linked list of integers: 20457585 Data Link

6. * The list can grow and shrink Linked Lists: Basic Ideas 20457585 2045 addEnd(75), addEnd(85) deleteEnd(85), deleteHead(20), deleteHead(45) 75

7. * Original linked list of integers: * Insertion (in the middle): * Deletion (in the middle) Linked Lists: Operations 20457585 20457585 20457585 60 old value deleted item

8. struct Node{ int data; Node* next; }; We can also: typedef Node* NodePtr; Definition of linked list type:

9. Linked List Structure * Node : Data + Link n Definition struct Node { int data;//contains useful information Node* next;//points to next element or NULL }; n Create a Node Node* p; p = new Node;//points to newly allocated memory n Delete a Node delete p;

10. n Access fields in a node (*p).data;//access the data field (*p).next;//access the pointer field Or it can be accessed this way p->data//access the data field p->next//access the pointer field

11. Representing and accessing linked lists * We define a pointer Node* head; that points to the first node of the linked list. When the linked list is empty then head is NULL. 20457585 Head

12. Passing a Linked List to a Function  When passing a linked list to a function it should suffice to pass the value of head. Using the value of head the function can access the entire list.  Problem: If a function changes the beginning of a list by inserting or deleting a node, then head will no longer point to the beginning of the list.  Solution: When passing head always pass it by reference (not good!) or using a function to return a new pointer value It is roughly the same as for an array!!!

13. Implementation of an (Unsorted) Linked List

14. Start the first node from scratch Node* newPtr; newPtr = new Node; newPtr->data = 20; newPtr->next = NULL; head = newPtr; Head newPtr 20 Head head = NULL;

15. Inserting a Node at the Beginning newPtr = new Node; newPtr->data = 13; newPtr->next = Head; head = newPtr; Head newPtr 13 20

16. Keep going … Head newPtr 50401320

17. void addHead(Node*& head, int newdata){ Node* newPtr = new Node; newPtr->data = newdata; newPtr->next = Head; head = newPtr; } Adding an element to the head: Call by reference, scaring!!! NodePtr&

18. Node* addHead(Node* head, int newdata){ Node* newPtr = new Node; newPtr->data = newdata; newPtr->next = Head; return newPtr; } Also written (more functionally, better!) as: Compare it with ‘addHead’ with a dynamic array implementation

19. (to delete) Deleting the Head Node Node* p; p = head; head = head->next; delete p; head p 50401320

20. void deleteHead(Node*& head){ if(head != NULL){ NodePtr p = head; head = head->next; delete p; } Node* deleteHead(Node* head){ if(head != NULL){ NodePtr p = head; head = head->next; delete p; } return head; } As a function:

21. Displaying a Linked List p = head; p = p->next; 2045 head p 2045 head p

22. void displayList(Node* head){ NodePtr p; p = head; while(p != NULL){ cout data << endl; p = p->next; } A linked list is displayed by walking through its nodes one by one, and displaying their data fields (similar to an array!). void displayArray(int data[], int size) { int n=0; while ( n<size ) { cout << data[i] << endl; n++; } For an array:

23. //return the pointer of the node that has data=item //return NULL if item does not exist Node* searchNode(Node* head, int item){ NodePtr p = head; NodePtr result = NULL; bool found=false; while((p != NULL) && (!found)){ if(p->data == item) { found = true; result = p;} p = p->next; } return result; } Searching for a node (look at array searching first!)

24. void main() { const int size=8; int data[size] = { 10, 7, 9, 1, 17, 30, 5, 6 }; int value; cout << "Enter search element: "; cin >> value; int n=0; int position=-1; bool found=false; while ( (n<size) && (!found) ) { if(data[n] == value) { found=true; position=n;} n++; } if(position==-1) cout << "Not found!!\n"; else cout << "Found at: " << position << endl; } Remember array searching algorithm: It is essentially the same!

25. Variations of linked lists * Unsorted linked lists * Sorted linked lists * Circular linked lists * Doubly linked lists * …

26. Further considerations for the unsorted lists: * Physical copy of list for operators like ‘delection’ and ‘addHead’ * ‘delete’ should be understood as a decomposition into a sub-list …

27. Node* deleteHead(Node* head){ // physically copy head into a new one, newhead // so to keep the original list intact! Node* newhead … if(newhead != NULL){ Node* p = newhead; newhead = newhead->next; delete p; } return newhead; }

28. * Original linked list of integers: * Add to the end (insert at the end): More operation: adding to the end 50401320 50401320 60 Last element The key is how to locate the last element or node of the list!

29. void addEnd(NodePtr& head, int newdata){ NodePtr newPtr = new Node; newPtr->data = newdata; newPtr->next = NULL; NodePtr last = head; if(last != NULL){ // general non-empty list case while(last->next != NULL) last=last->next; last->next = newPtr; } else// deal with the case of empty list head = newPtr; } Add to the end: Link new object to last->next Link a new object to empty list

30. NodePtr addEnd(NodePtr head, int newdata){ NodePtr newPtr = new Node; newPtr->data = newdata; newPtr->next = NULL; NodePtr last = head; if(last != NULL){ // general non-empty list case while(last->next != NULL) last=last->next; last->next = newPtr; } else// deal with the case of empty list head = newPtr; return head; } Add to the end as a function:

31. Implementation of a Sorted Linked List

32. Inserting a Node Head cur 20 33 4575 prev... newPtr 1.(a) Create a new node using: NodePtr newPtr = new node; (b) Fill in the data field correctly. 2. Find “prev” and “cur” such that the new node should be inserted between *prev and *cur. 3. Connect the new node to the list by using: (a) newPtr->next = cur; (b) prev->next = newPtr;

33. Finding prev and cur Suppose that we want to insert or delete a node with data value newValue. Then the following code successfully finds prev and cur such that prev->data data

34. prev = NULL; cur = head; found=false; while( (cur!=NULL) && (!found) ) { if (newValue > cur->data) { prev=cur; cur=cur->next; } else found = true; } Prev is necessary as we can’t go back! It’s a kind of search algo,

35. prev = NULL; cur = head; while( (cur!=NULL) && (newValue>cur->data) ) { prev=cur; cur=cur->next; } Logical AND (&&) is short-circuited, sequential, i.e. if the first part is false, the second part will not be executed. Finally, it is equivalent to:

36. //insert item into linked list according to ascending order Node* insertNode(Node* head, int item){ NodePtr newp, cur, pre; newp = new Node; newp->data = item; pre = NULL; cur = head; while( (cur != NULL) && (item>cur->data)){ pre = cur; cur = cur->next; } if(pre == NULL){//insert to head of linked list newp->next = head; head = newp; } else { pre->next = newp; new->next = cur; } return head; } If the position happens to be the head General case

37. // not recommended void type function void insertNode(NodePtr& head, int item){ NodePtr newp, cur, pre; newp = new Node; newp->data = item; pre = NULL; cur = head; while( (cur != NULL) && (item>cur->data)){ pre = cur; cur = cur->next; } if(pre == NULL){//insert to head of linked list newp->next = head; head = newp; } else { pre->next = newp; new->next = cur; }

38. (to delete) Deleting a Node * To delete a node from the list 1. Locate the node to be deleted (a) cur points to the node. (b) prev points to its predecessor 2. Disconnect node from list using: prev->next = cur->next; 3. Return deleted node to system: delete cur; Head cur 20457585 prev...

39. Node* deleteNode(Node* head, int item){ NodePtr prev=NULL, cur = head; while( (cur!=NULL) && (item > cur->data)){ prev = cur; cur = cur->next; } if ( cur!==NULL && cur->data==item) { if(cur==head) head = head->next; else prev->next = cur->next; delete cur; } return head; } Delete an element in a sorted linked list: If the element is at the head General case We can delete only if the element is present! If (cur==NULL || cur->data!=item) Item is not in the list! Get the location

40. void deleteNode(NodePtr& head, int item){ NodePtr prev=NULL, cur = head; while( (cur!=NULL) && (item > cur->data)){ prev = cur; cur = cur->next; } if ( cur!==NULL && cur->data==item) { if(cur==Head) Head = Head->next; else prev->next = cur->next; delete cur; } // in a void function, not recommended If the element is at the head General case We can delete only if the element is present! If (cur==NULL || cur->data!=item) Item is not in the list! Get the location