从C到C＃的递归MergeSort转换

Question

I am completely stuck with this recursive implementation of a merge sort due to the .NET requirement that all variables must first be instantiated before being used. My professor wants us to translate C code for MergeSort into C#, using a recursive algorithm. Here is the C code:

void doMergeSort(contact **head)
{
    // do not process empty or single-node list
    if (head==NULL || *head == NULL || (*head)->next==NULL)
        return;

    contact *first, *second;

    // split the list in half
    splitList(*head, &first, &second);

    // perform recursive merge sort on both halves
    doMergeSort(&first);
    doMergeSort(&second);

    // Merge both halves back together,
    mergeList(first, second)
}

Here is my implementation of it:

public static void DoMergeSort(ref LinkNode<T> head)
{
    if (head == null || head.Next == null)
        return;

    LinkNode<T> first = null, second = null;

    SplitList(head, ref first, ref second);

    DoMergeSort(ref first);
    DoMergeSort(ref second);

    head = MergeLists(first, second);
}

Now, because of the rules of C#/.NET, I cannot leave out instantiating first and second, but declaring them as null within the function screws up the recursive nature of it. I have been stuck on this problem for multiple days and and my professor is being little help. Would I be better off trying to translate this into an iterative function, or is there a way I can accomplish this recursively?

My only concern with taking an iterative approach is that it would "break the rules" of the assignment.

Answer 1

I may be missing something about C#, but setting first and second = null should not be a problem since SplitList(...) is supposed to split the list from head (which is not null) into two halves, the first half goes into left, the second half goes into second. Then the recursion occurs with the now non-empty first and then second lists, and each level of recursion creates yet another pair of first and second.

The code doesn't quite follow the C code, you need to check if a list only has one node (the C code checks (*head)->next == NULL to do this). If there's only one node, the function should just return.

Although not a part of your class assignment, there is an iterative version of merge sort for linked lists. It uses a small (26 to 32) array of internal lists. It's faster than the recursive version since it doesn't have to scan sub-lists to split them. Wiki article describes this.

https://en.wikipedia.org/wiki/Merge_sort#Bottom-up_implementation_using_lists