PROBLEM 3: (25 points)
In this problem, you will write all or part of two functions that sort an unsorted linked list into descending order. You will write all of one function, InsertionListDescendingIter. This function uses the insertion sort algorithm to sort the input linked list into a new linked list. You will also write two helper functions to implement the selection sort algorithm SelectionListDescendingRec. The selection sort will modify the input list. The prototype of these two sorting functions will be,
LinkedList * InsertionListDescendingIter(const LinkedList * head);
void SelectionListDescendingRec(const LinkedList * head);
To help you complete these tasks, you will be supplied with a file containing the following framework:
- The definitions of the LinkedList and LinkNode structures.
- The implementations of two functions which you may use in your insertion sort function:
- void insertListNode(LinkedList* list, double val);
- LinkedList * createLinkedList();
- The implementation of function SelectionListDescendingRec.
- The implementation of other LinkedList functions that may be used in testing of your functions. These functions may not be used within the functions you write.
Two initial tests, using the functions described in the previous point, should produce the following output. You will need to do additional testing yourself to make sure your code functions for all possible cases.
Original linked list:
88.000000 23.000000 36.000000 17.000000 2.000000 63.000000 28.000000
Insertion sort sorted linked list:
88.000000 63.000000 36.000000 28.000000 23.000000 17.000000 2.000000
Original List:
88.000000 83.000000 45.000000 27.000000 91.000000 76.000000 62.000000
Selection sort sorted List:
91.000000 88.000000 83.000000 76.000000 62.000000 45.000000 27.000000
The functions you will write are:
A. Two helper functions called by the selection sort function, SelectionListDescendingRec:
1. void swapValues(ListNode* node1, ListNode* node2);
Function swapValues takes pointers to two ListNodes as its arguments. The function exchanges the values in the two ListNodes pointed to by the two pointers.
2. ListNode * findMax(ListNode* start, ListNode* maxNode);
Function findMax recursively finds the pointer to the ListNode with the largest value. The pointer to the ListNode containing the largest pointer is returned as the return value of the function. It begins looking for the ListNode with the largest value at the ListNode pointed to by pointer start. The ListNode pointed to by the pointer start can be any ListNode in the linked list.
B. LinkedList * InsertionListDescendingIter(const LinkedList* head);
Consider the function, InsertionListDescendingIter, for insertion sort. The pointer to the original unsorted linked list is passed into the function. The list pointed to by this pointer will not be changed in any way by your insertion sort function. Your insertion sort function will create a new sorted linked list containing links holding the same values as the original list. All new links will be allocated dynamically. The pointer to the new list will be passed back to the calling function as its return value. The solution inside your insertion sort function may call only the supplied functions listed below:
- void insertListNode(LinkedList* list, double val);
- LinkedList* createLinkedList();
To implement the insertion sort, repeat the next 3 steps until all nodes have been inserted into the new list:
1. Select the next link in the linked list.
2. Make a new link containing the value in the selected link.
3. Insert the new link into the new list.
Stop when the next pointer in the current node is NULL.
Please note the following constraints for all three functions:
- You may not use global variables.
- Your code must not contain memory leaks or dangling pointers.
