Solutions to Practice Problems Using a Linked List

Solutions to Practice Problems Using a Linked List From Previous Day’s Notes • Create C functions to solve the following problems with linked lists. We’ll create solutions in the next class, but you try them first! 1. Write a recursive function that will search a list for a specific item, returning NULL if it is not found a pointer to the node containing the value if it is found. 2. Write a function that will insert a node pointed to by newnode before the node pointed to by target. head target newnode Page 1 1

Solution to Problem #1 struct node * lookup (int item, struct node *head) { if (head == NULL) return NULL; else if (item == head -> data) return head; else return(lookup(item, head -> next)); } ptr 23 Page 2 2

Solution to Problem #2 void insert_before (struct node ** head, //pointer to a pointer struct node *target, struct node *newnode) { struct node *p, *pre; //search target pointer and keep track of the previous pointer p = *head; //must de-reference while (p != NULL && p != target) { pre = p; p = p -> next; } //do the insert newnode -> next = p; if (*head == p) *head = newnode; else pre -> next = newnode; } Page 3 3

Doubly-Linked List Implementation Issues in C • A node in a doubly-linked list is a structure that has at least three fields. One of the fields is a data field; the two are pointers that contains the address of the logical predecessor node and logical successor node in the sequence. • An example doubly-linked list node with one data field: struct dllnode{ int data; struct dllnode *left; struct dllnode *right; }; Page 4 left data right 4

Basic Operations on a Doubly-Linked List 1. 2. 3. 4. Add a node. Delete a node. Search for a node. Traverse (walk) the list. Useful for counting operations or aggregate operations. • Note: the operations on a doubly-linked list are exactly the same that are required for a singly-linked list. As we discussed before, the reasons for using a doubly-linked list are application dependent for the Page 5 most part. 5

Adding Nodes to a Doubly-Linked List Adding a Node There are four steps to add a node to a doubly-linked list: • Allocate memory for the new node. • Determine the insertion point to be after (p. Cur). • Point the new node to its successor and predecessor. • Point the predecessor and successor to the new node. Current node pointer (p. Cur) can be in one of two states: • it can contain the address of a node (i. e. you are adding somewhere after the first node – in the middle or at the end) • it can be NULL (i. e. you are adding either to an empty list or at the beginning of the list) Page 6 6

Adding Nodes to an Empty Doubly-Linked List Initial: Code: p. New = (struct node *) /*create node*/ malloc(sizeof(struct dllnode)); p. New -> data = 39; p. New -> right = p. Head; p. New -> left = p. Head; p. Head = p. New; 39 p. Head p. Cur p. New 39 After: p. Head p. Cur Page 7 7

Adding a Node to the Middle of a Doubly-Linked List Before: p. New 64 55 124 p. Cur After: p. New 64 55 124 p. Cur Page 8 8

Adding a Node to the Middle of a Doubly-Linked List The Code p. New = (struct node *) malloc(sizeof(struct dllnode)); p. New -> data = 64; p. New -> left = p. Cur; p. New -> right = p. Cur -> right; p. Cur -> right -> left = p. New; p. Cur -> right = p. New; Page 9 9

Adding a Node to the End of a Doubly-Linked List Before: p. New 84 55 74 p. Cur After: p. New 84 55 74 p. Cur Page 10 10

Adding a Node to the end of a Doubly-Linked List The Code p. New = (struct node *) malloc(sizeof(struct dllnode)); p. New -> data = 84; p. New -> left = p. Cur; p. New -> right = p. Cur -> right; p. Cur -> right = p. New; Page 11 11

Inserting a Node Into a Doubly-Linked List //insert a node into a linked list struct node *p. New; p. New = (struct node *) malloc(sizeof(struct node)); p. New -> data = item; if (p. Cur == NULL){ //add before first logical node or to an empty list p. New -> left = p. Head; p. New -> right = p. Head; p. Head = p. New; } else { if (p. Cur -> right == NULL) { //add at the end p. New -> left = p. Cur; p. New -> right = p. Cur -> right; p. Cur -> right = p. New; } else { //add in the middle p. New -> left = p. Cur; p. New -> right = p. Cur -> right; p. Cur -> right -> left = p. New; p. Cur -> right = p. New; } Page 12 } 12

Deleting a Node from a Doubly-Linked List • Deleting a node requires that we logically remove the node from the list by changing various links and then physically deleting the node from the list (i. e. , return it to the heap). • Any node in the list can be deleted. Note that if the only node in the list is to be deleted, an empty list will result. In this case the head pointer will be set to NULL. • To logically delete a node: – First locate the node itself (p. Cur). – Change the predecessor’s and succesor’s link fields to point each other (see example). – Recycle the node using the free() function. Page 13 13

Deleting the First Node from a Doubly-Linked List Before: Code: p. Head = p. Cur -> right; p. Head 75 124 p. Cur ->right -> left = NULL; free(p. Cur); p. Cur After: p. Head Recycled 124 p. Cur Page 14 14

Deleting a Node from a Linked List – General Case Before: 75 23 12477 46 p. Cur After: 75 Recycled 23 77 124 p. Cur Page 15 15

Deleting a Node From a Doubly-Linked List The Code //delete a node from a linked list if (p. Cur -> left == NULL){ //deletion is on the first node of the list p. Head = p. Cur -> right; p. Cur -> right -> left = NULL; { else { //deleting a node other than the first node of the list p. Cur -> left -> right = p. Cur -> right; p. Cur -> right -> left = p. Cur -> left; } free(p. Cur). Page 16 16

Searching a Doubly-Linked List • Notice that both the insert and delete operations on a linked list must search the list for either the proper insertion point or to locate the node corresponding to the logical data value that is to be deleted. //search the nodes in a linked list p. Cur = p. Head; //search until the target value is found or the end of the list is reached while (p. Cur != NULL && p. Cur -> data != target) { p. Cur = p. Cur -> right; } //determine if the target is found or ran off the end of the list if (p. Cur != NULL) found = 1; else found = 0; Page 17 17

Traversing a Doubly-Linked List • List traversal requires that all of the data in the list be processed. Thus each node must be visited and the data value examined. • Notice that this is identical code to the singly-linked list except for the name of the pointer link. //traverse a linked list Struct dllnode *p. Walker; p. Walker = p. Head; printf(“List contains: n”); while (p. Walker != NULL){ printf(“%d ”, p. Walker -> data); p. Walker = p. Walker -> right; } Page 18 18