Linked List Problems

16SortedMerge() should return the new list. The new list should be made by splicingtogether the nodes of the first two lists (use MoveNode()). Ideally, Merge() should onlymake one pass through each list. Merge() is tricky to get right — it may be solvediteratively or recursively. There are many cases to deal with: either 'a' or 'b' may beempty, during processing either 'a' or 'b' may run out first, and finally there's the problemof starting the result list empty, and building it up while going through 'a' and 'b'./*Takes two lists sorted in increasing order, andsplices their nodes together to make one bigsorted list which is returned.*/struct node* SortedMerge(struct node* a, struct node* b) {// your code...15 — MergeSort()(This problem requires recursion) Given FrontBackSplit() and SortedMerge(), it's prettyeasy to write a classic recursive MergeSort(): split the list into two smaller lists,recursively sort those lists, and finally merge the two sorted lists together into a singlesorted list. Ironically, this problem is easier than either FrontBackSplit() orSortedMerge().void MergeSort(struct node* headRef) {// Your code...16 — SortedIntersect()Given two lists sorted in increasing order, create and return a new list representing theintersection of the two lists. The new list should be made with its own memory — theoriginal lists should not be changed. In other words, this should be Push() list building,not MoveNode(). Ideally, each list should only be traversed once. This problem alongwith Union() and Difference() form a family of clever algorithms that exploit theconstraint that the lists are sorted to find common nodes efficiently./*Compute a new sorted list that represents the intersectionof the two given sorted lists.*/struct node* SortedIntersect(struct node* a, struct node* b) {// Your code17 — Reverse()Write an iterative Reverse() function which reverses a list by rearranging all the .nextpointers and the head pointer. Ideally, Reverse() should only need to make one pass of thelist. This is a difficult problem. It requires a good understanding of pointer operations aswell as the ability to think through a complex code design. Any programmer can benefitfrom working through the code even if they need look at the solution first. The problem isa good example of the sort of code and memory issues which complex algorithmssometimes require. Many great programmers have struggled with Reverse() — it's aclassic. (A memory drawing for Reverse() an some hints are below.)