合并排序无法递归工作

Question

I want to build an algorithm where I'm sorting a linked list via merge sort. Here the code:

private Item mergeSort(Item l){
    //if the list contains of just one item we don't have to sort it anymore
    if(l.next == null) return l;
    //divide your list in two parts and get both starts of both lists
    Item middle = getMidItem(l);
    Item start1 = l;
    Item start2 = middle.next;
    middle.next = null;
    //process recursively the same process but with the both new lists until both lists only contain of one item
    Item item1 = mergeSort(start1);
    Item item2 = mergeSort(start2);
    //if both lists are sorted put them together
    return merge(item1, item2);
}

This function works recursively. First, if it hasn't another element, I return the current one and stop the function. If it has more than one element, I determine the middle of the element (getMidItem works properly I've debugged it several times) and divide both lists in two parts. After that, I recursively open the function again and do it for both lists now until the list contains of just one element. If this going to happen, I return all elements and merge them.

The merge function determines which element is the smaller one, puts the references of the smaller one on the front and the bigger one on the end, until it has run over the whole list. The problem in here is, my whole structure. If I run it he will get to one point, where the lists contains of just one element and he returns it, saves it and merges only in the last recursion step and stops it. And in the end, I don't get my list, but only the first element of the list.

I realized that this isn't going to work, but I have actually no clue, how I can rewrite it, so that it does what I want. I know how merge sort does work, but I don't know how to implement it, like this way. And before somebody says, that "it is hard that way, just rewrite the method body and return the first, the middle and the last one or do it with an array", I have to do it that way. It's homework.

Here is the merge function:

public static Item merge(Item a, Item b){
    //if both items are null return null, if one is null return the other
    if(a == null && b == null) return null;
    else if(a == null && b != null) return b;
    else if(a != null && b == null) return a;
    else{
        //create minimum and check if 'a' or 'b' is smaller and set it to minimum
        Item min = null;
        //if a is smaller than b, a should be returned and the next item of 'a' should be 'b'
        if(a.value.compareTo(b.value) < 0){
            //the next reference of the smaller element should be the bigger one
            min = a;
            a = a.next;
        }
        else{
            //same but the other way around
            min = b;
            b = b.next;

        }
        //you create the next reference of the minimum 
        Item p = min;
        if(a != null && b != null){
            //you iterate through the whole list and put the references of the smaller one on the front and the bigger one behind
            while(a.next != null && b.next != null){
                if(a.value.compareTo(b.value) < 0){
                    p.next = a;
                    a = a.next;
                }
                else{
                    p.next = b;
                    b = b.next;
                }
            }
        }
        return p;
    }
}

Answer 1

You have a logical problem with your merge(...) method when merging the lists:

   if(a != null && b != null){ // PROBLEM OCCURS HERE
        //you iterate through the whole list and put the references of the smaller one on the front and the bigger one behind
        while(a.next != null && b.next != null){ // AND HERE
            if(a.value.compareTo(b.value) < 0){
                p.next = a;
                a = a.next;
            }
            else{
                p.next = b;
                b = b.next;
            }
        }
    }

You check whether a != null && b != null . What if only one list is null ? In this case you neglect content from the second list and therefore loose data. You have to account for the fact that one of the lists may run out of data (ie is null ) while the other list still holds elements.

Make a pen & paper-test with your mergesort and an already sorted list. This should reveal the problem.