Homework Assignment #1

Transcription

1 CISC 2200 Data Structure Spring, 2016 Homework Assignment #1 1 Short practices on linked list, see Textbook Page 205, Problem Pointers: operations (deference, address-of), and syntax errors (a) Textbook Page 206, (in the table) (b) Textbook, Page 207, 18 (c) Textbook, Page 208, 19

2 3 From linked list to doubly linked list. Answer the following questions based upon the code given below (solution for lab4). (a) To build a doubly linked list, each node has two pointers, one pointing to its next node (i.e., successor) in the linked list, another pointing to the previous node (i.e., predecessor) in the linked list. In the code below, mark the change you would make to the type IntNodeType. //Lab4 solutions. // define a struct type named IntNodeType that includes a int and pointer // (to a IntNodeType) field struct IntNodeType int value; IntNodeType * next; IntNodeType (int v=0, IntNodeType * p=null):value(v),next(p) //intentionally empty ; (b) For the following two functions (as in lab4), mark changes you need to make for it to work on doubly linked list. /* Create a new node to store the given value, * and make this new node the first of the linked address of the first node, will be void InsertAtFront (IntNodeType * & head, int value) IntNodeType * p; p = new IntNodeType; p->value = value; p->next = head; head = p; 2

3 /* Creaet a new node with the given value, and append it to the linked list * given by the head pointer head: pointer pointing to the first node, NULL if the linked list is empty * if the linked list was empty, the head will point to the new node upon return num: the int number to be saved in the node nothing * void AppendInTheEnd (IntNodeType * & head, int num) IntNodeType * tail=null; IntNodeType * newnode = new IntNodeType (num,null); if (head==null) head = newnode; else //make tail points to the last node tail = head; while (tail->next!=null) tail = tail->next; tail->next = newnode; (c) For the following function, mark the changes you need to make: /* Create a linked list to store a[0],a[1],...a[size-1], return the header node s address IntNodeType * InitList (int a[], int size) IntNodeType * head=null, * tail=null, * newnode=null; for (int i=0;i<size;i++) newnode = new IntNodeType (a[i],null); if (tail==null) assert (head==null); head = tail = newnode; else tail->next = newnode; tail = newnode; 3

4 return head; (d) Maintaining two links in each node (previous node and next node) makes some operations simplier to implement. i. We don t need the second Search function anymore (i.e., we can use the first Search function that takes two parameters). Why? /* Search for given value in the listed list pointed to by firstnodeptr, * return the matching node s if the value is found in the linked list, the node s address will be returned, value: same as Search... IntNodeType * Search (IntNodeType * firstnodeptr, int value)... /* Search for given value in the listed list pointed to by firstnodeptr, * return the matching node s address, and * set its previous node s address in prevnode prevnode: set to the previous if the value is found in the linked list, the node s address will be returned, value: same as Search... IntNodeType * Search (IntNodeType * firstnodeptr, int value, IntNodeType * & prevnode)... ii. How would you modify the following functions (considering Search does not provide the previous node address. void InsertBeforeValue (IntNodeType * & head, int value, int beforevalue) IntNodeType * cur, * prev, * newnode; newnode = new IntNodeType (value,null); cur = Search (head, beforevalue, prev); assert (cur!=null); if (prev==null) assert (cur==head); 4

5 //insert the new node before the head newnode->next = head; head = newnode; else prev->next = newnode; newnode->next = cur; /* Delete the node storing the given value from the linked list 1. Find the value in the list (i.e., find the pointer that points to the node), and also remembers the address of its previous node 2. If the node to be removed is not in the header, skip it in the list (assign its next node s address to its prev node s next) otherwise set header to its next node s address 3. delete the node (to free up heap firstptr: if the value is stored in the head, then firstptr will be true if the value is removed; false if the value is not found bool Delete (IntNodeType * & firstptr, int value) IntNodeType * prev, * cur; cur = Search (firstptr, value, prev); if (cur==null) return false; else // remove cur node from the linked list if (prev!=null) //not the first one prev->next = cur->next; //bypass the cur node else //cur is the first node firstptr = cur->next; //update the head pointer delete cur; //deallocate the node itself return true; 5