链表合并排序的实现

Question

I am trying out a question found online, which is to implement merge sort with linked list, but using the strange list interface implementation taught by my school instead of using just the nodes, so plain copying from other solutions does not work here. I was usually just expanding on BasicLinkedList and didn't really bother with the interface. This is my driver code and classes, and the merge sort does not run the way I want it to run and I can't seem to figure out why after debugging for a long time. Can anyone help me out here?

Do inform me if you need more information.

import java.util.*;

class Main {
    public static void main(String [] args) {
        BasicLinkedList<Integer> lst = BasicLinkedList.of(4,2,1,3);
        BasicLinkedList<Integer> sortedList = BasicLinkedList.mergeSort(lst);
        sortedList.print();

    }
}


class ListNode <E> {
    protected E element;
    protected ListNode <E> next;

    /* constructors */
    public ListNode (E item) { 
        element = item; 
        next = null; 
    }

    public ListNode (E item, ListNode <E> n) { 
        element = item; 
        next=n;
    }

    /* get the next ListNode */
    public ListNode <E> getNext ( ) {
        return this.next;
    }

    /* get the element of the ListNode */
    public E getElement ( ) {
        return this.element;
    }

    public void setNext(ListNode<E> item) {
        this.next = item;
    }


}




class BasicLinkedList <E> implements LinkedListInterface <E> {
    protected ListNode <E> head = null;
    protected int num_nodes = 0;


    public boolean isEmpty() 
        { return (num_nodes == 0); }

    public int size( ) 
        { return num_nodes; }

    public E getFirst ( ) throws NoSuchElementException {
        if (head == null) 
            throw new NoSuchElementException("can't get from an empty list");
        else return head.element;
    }

    public boolean contains (E item) {
        for (ListNode <E> n = head; n!= null; n=n.next)
            if (n.getElement().equals(item)) return true;

        return false;
    }

    public void addFirst (E item) {
        head = new ListNode <E> (item, head);
        num_nodes ++;
    }

    public E removeFirst ( ) throws NoSuchElementException {
        ListNode <E> ln;
        if (head == null) 
            throw new NoSuchElementException ("can't remove from an empty list");
        else { 
            ln = head;
            head = head.next;
            num_nodes --;
            return ln.element;
        }
    }

    public void print2 ( ) throws NoSuchElementException {
        if (head == null)
            throw new NoSuchElementException ("Nothing to print...");

        ListNode <E> ln = head;
        System.out.print ("List is: " + ln.element);
        for (int i=1; i < num_nodes; i++) {
            ln = ln.next;
            System.out.print (", " + ln.element );
        }
        System.out.println(".");
    }

    public void print () throws NoSuchElementException {
        if (head == null)
            throw new NoSuchElementException ("Nothing to print...");

        Iterator <E> itr = iterator();
        System.out.print ("List is: " + itr.next() );
        while (itr.hasNext()) 
            System.out.print ( ", " + itr.next() );
        System.out.println(".");
    }

    public Iterator<E> iterator() { 
        return new LinkedListIterator(); 
    }

    private class LinkedListIterator implements Iterator<E> {
        private ListNode<E> current = head;

        public boolean hasNext(){ return current != null;}
        public void remove()    { throw new UnsupportedOperationException(); }
        public E next() {
            if ( !hasNext()) {
                throw new NoSuchElementException();
            }
            E element = current.element;
            current = current.next;
            return element;
        }
    }


    public static <E> BasicLinkedList<E> of(E ... values) {
        BasicLinkedList<E> lst = new BasicLinkedList<>();
        for (int i=values.length-1;i> -1; i--) {
            lst.addFirst(values[i]);
        }
        return lst;
    }

    public static BasicLinkedList<Integer> mergeSort(BasicLinkedList<Integer> original) {
        if (original.size() < 2) {
            return original;
        } else {
            int totalSize = original.size();
            int newSize = totalSize/2;

            ListNode<Integer> middle = getMiddle(original);
            ListNode<Integer> nextOfMiddle = middle.next; 
            BasicLinkedList<Integer> right = new BasicLinkedList<>();
            right.head = nextOfMiddle;
            right.num_nodes = totalSize- newSize;
            //Create the left list, firstly by creating an empty shell and replace the head node
            BasicLinkedList<Integer> left = new BasicLinkedList();
            left.head = original.head;
            right.num_nodes = newSize;




            // set the next of middle node to null 
            middle.setNext(null);
            // System.out.println("Before MS");
            // debug(left,right);


            BasicLinkedList<Integer> newLeft = mergeSort(left);
            BasicLinkedList<Integer> newRight = mergeSort(right);

            // System.out.println("After MS");

            BasicLinkedList<Integer> lst = merge(newLeft,newRight);
            //lst.print();
            return lst;
        }
    }

    public static ListNode<Integer> getMiddle(BasicLinkedList<Integer> original) {
        if (original.head == null) 
            return null;
        ListNode<Integer> slowPtr = original.head;
        ListNode<Integer> fastPtr = slowPtr.next;
        while (fastPtr != null) {
            fastPtr = fastPtr.next; 
            if(fastPtr!=null) {
                slowPtr = slowPtr.next; 
                fastPtr=fastPtr.next; 
            } 
        } 
        return slowPtr; 
    } 

    //Merges 2 non-empty lists together
    public static BasicLinkedList<Integer> merge(
        BasicLinkedList<Integer> firstList,
        BasicLinkedList<Integer> secondList) {
        ListNode<Integer> firstHead = firstList.head;
        ListNode<Integer> secondHead = secondList.head;

        BasicLinkedList<Integer> newList = new BasicLinkedList<Integer>();
        // move smaller node into newList, and maintain its tail

        //debugNode(firstHead,secondHead);
        if (firstHead.getElement() <= secondHead.getElement()) {
            newList.head = firstHead;
            firstHead = firstHead.getNext();
        } else {
            newList.head = secondHead;
            secondHead = secondHead.getNext();
        }
        ListNode<Integer> newTail = newList.head;


        while (firstHead != null && secondHead != null) {
            // System.out.println("Before loop ");
            // debugNode(firstHead,secondHead);
            if (firstHead.getElement() < secondHead.getElement()) {
                newTail.setNext(firstHead);
                firstHead = firstHead.getNext();
            } else {
                newTail.setNext(secondHead);
                secondHead = secondHead.getNext();
            }
            newTail = newTail.getNext();
            // System.out.println("After loop ");
            // debugNode(firstHead,secondHead);
        }

        if (firstHead != null)
            newTail.setNext(firstHead);
        if (secondHead != null)
            newTail.setNext(secondHead);
        // perform cleanup
        firstList.head = null;
        secondList.head = null;
        return newList;
    }

    public static void debug(BasicLinkedList<Integer> left, BasicLinkedList<Integer> right) {
        System.out.print("Left");
        left.print();
        System.out.print("Right");
        right.print();
    }

    public static void debugNode(ListNode<Integer> first, ListNode<Integer> second) {
        System.out.print("Left");
        System.out.println(first.getElement());
        System.out.print("Right");
        System.out.println(first.getElement());
    }



}

import java.util.*;

public interface LinkedListInterface <E> {

    public boolean  isEmpty( );
    public int      size ( );
    public E        getFirst  () throws NoSuchElementException; 
    public boolean  contains (E item);
    public void     addFirst (E item);
    public E        removeFirst ( ) throws NoSuchElementException;  

    public void     print ();

    // ....etc....
    // ....etc....
}

According to my main driver code as shown, with the right merge sort function, List is: 1, 2 ,3, 4. should be printed out when starting with a list of [4,2,1,3] . My current merge sort prints out [1,3,2,4] and my debugging attempts are shown in the commented lines of code.

Answer 1

In method BasicLinkedList<Integer> mergeSort , you are not setting the size of the left linked list, rather you are setting the size of the right linked list twice.

Here is your code:

            right.head = nextOfMiddle;
            right.num_nodes = totalSize - newSize;
            //Create the left list, firstly by creating an empty shell and replace the head node
            BasicLinkedList<Integer> left = new BasicLinkedList();
            left.head = original.head;

            //here is the mistake
            //change it to  - left.num_nodes = newSize;
            right.num_nodes = newSize;

PS: I don't know which IDE you are using, but I would suggest you to download IntelliJ Idea and use its debugging features. Also, you might have other corner cases to test for.