Use C program write a function( Node *efficient_delete_match(Node *head, int delete_value, int *num_delete); )

here is the output

The function efficient_delete_match should delete any nodes from the list that have a value matching the argument delete_value and it should count the number of deletions that have occurred with num_deleted (a pass-by-reference parameter). The function should return a pointer to the potentially different) head of the resulting list (which could even be NULL/empty). The function should result in the same resulting list, and same num_deleted value, as the delete_all_matches function that we created in-class. However the delete_all_matches function was inefficient... it works by repeatedly calling delete_first_match until no matches are found. The delete_first_match function traverses the list until the first match is found, and so if we repeatedly call the function, we are traversing the list again and again. Your efficient_delete_match function should traverse the list only once. You can use multiple loops in your code if like, perhaps traversing a portion of the list, and then another portion of the list, but your code should not repeatedly traverse the same elements of the list. The delete_duplicates function may be helpful as inspiration for how to achieve this. As a result, the performance should be vastly improved compared to delete_all_matches, and test code is provided to demonstrate this. #include #include #include #include typedef struct node { int value; struct node *next; } Node; void print_list(Node *head); Node* insert_at_head(Node *head, int new_value); Node *delete_first_match(Node *head, int delete_value, bool *was_deleted); Node *delete_all_matches (Node *head, int delete_value, int *num_deleted); Node *efficient_delete_match(Node *head, int delete_value, int *num_deleted); int main() 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 printf(" efficient_delete_match test "); printf("****** ******** "); Node *list8 = NULL; list8 = insert_at_head(list8, 4); list8 = insert_at_head(list8, 3); list8 = insert_at_head(lists, 4); list8 = insert_at_head(lists, 5); list8 = insert_at_head(lists, 4); list8 = insert_at_head(list8, 4); list8 = insert_at_head(lists, 7); list8 = insert_at_head(lists, 4); list8 = insert_at_head(lists, 4); printf(" List 8... "); print_list(lists); int num_deleted = 0; list8 = efficient_delete_match(list8, 4, &num_deleted); printf(" List 8 after delete... "); print_list(list); printf("Number of elements deleted: %d ", num_deleted); } A 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 Node* insert_at_head (Node *head, int new_value) { Node *new_node = calloc(1, sizeof(Node)); new_node->value new_value; new_node->next NULL; if (head NULL) return new_node; else { new_node->next head; return new_node; } } void print_list(Node *head) { Node *current; current = head; int i = 0; while (current != NULL) { printf("Node %d: %d ", i, current-value); current = current->next; i++; } } 48 49 50 51 52 44 Node *delete_all_matches (Node *head, int delete_value, int *num_deleted) 45 46 Node *current = head; bool deleted = true; *num_deleted = 0; int i = 0; do { current - delete_first_match(current, delete_value, &deleted); if (deleted) *num_deleted = *num_deleted + 1; } while(deleted); 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 return current; } Node *delete_first_match(Node *head, int delete_value, bool *was_deleted) { if (head NULL) { *was_deleted = false; return NULL; } 66 67 68 69 70 71 72 73 74 75 76 77 if (head->value == delete_value) { Node *temp = head->next; free(head); *was_deleted = true; return temp; } 78 79 80 81 82 83 84 85 86 87 88 89 Node *current = head->next; Node *prev = head; while (current != NULL) { if (current-value == delete_value) { prev->next = current->next; free(current); *was_deleted = true; return head; } prev = current; current = current->next; *was_deleted = false; return head; 90 91 } efficient_delete_match test List 8... Node 0: 4 Node 1: 4 Node 2: 7 Node 3: 4 Node 4: 4 Node 5: 5 Node 6: 4 Node 7: 3 7 Node 8: 4 List 8 after delete... Node 0: 7 Node 1: 5 Node 2: 3 Number of elements deleted: 6