为什么在链表前半部分调用mergesort时出现栈溢出异常

Question

public class Solution {

    public static LinkedListNode<Integer> mergeSort(LinkedListNode<Integer> head) {
        //Your code goes 
         LinkedListNode slow=head, fast=head, temp=head;
         while(fast!=null && fast.next!=null){
             temp=slow;
             fast=fast.next.next;
             slow=slow.next;
         }
          temp.next=null;
          LinkedListNode left_side=mergeSort(head);
          LinkedListNode right_side=mergeSort(slow);

          return merge(left_side, right_side);
    }

    public static LinkedListNode merge(LinkedListNode<Integer> head1, LinkedListNode<Integer> head2){
       LinkedListNode temp_node=new LinkedListNode(0);
       LinkedListNode current_node= temp_node;

       while(head1!=null && head2!=null){
           if(head1.data<=head2.data){
               current_node.next=head1;
               head1=head1.next;
           }else{
               current_node.next=head2;
               head2=head2.next;
           }
           current_node=current_node.next;
       }
       if(head1!=null){
          current_node.next=head1;
          head1=head1.next;
       }
       if(head2!=null){
           current_node=head2;
           head2=head2.next;
       }
       
       return temp_node.next;


   }
}

我期待一个排序列表，但我收到了StackOverflowError 。

我应该如何纠正它？ 该错误专门针对我在链表左侧调用mergSort的行显示。 我应该怎么办？

Answer 1

您正在 mergeSort() 方法中使用递归，并且 mergeSort function 没有退出条件。在调用递归之前您应该有一个退出条件。 否则它将继续调用相同的方法，直到堆栈变满。 因此堆栈溢出错误。

Answer 2

拇指已经回答了这个问题。 如果有兴趣，这里有自下而上和自上而下的合并排序单链表示例。 自下而上更快，快多少取决于节点数量以及节点是否分散（缓存未命中）。 将列表复制到数组，对数组进行排序，然后从数组创建一个新的排序列表会更快。 合并 function 对于这两个示例是相同的： if(true){head...}... while(true){dest...} 是为了避免使用虚拟节点（避免分配和释放虚拟节点）每次调用合并时的节点）。

自下而上

    // bottom up merge sort for single link list
    static Node sortbu(Node head) {
        final int NUMLIST = 32;
        Node[] alist = new Node[NUMLIST];
        Node node;
        Node next;
        int i;
        // if < 2 nodes, return
        if(head == null || head.next == null)
            return null;
        node = head;
        // merge node into array
        while(node != null){
            next = node.next;
            node.next = null;
            for(i = 0; (i < NUMLIST) && (alist[i] != null); i++){
                node = merge(alist[i], node);
                alist[i] = null;
            }
            if(i == NUMLIST)   // don't go past end of array
                i--;
            alist[i] = node;
            node = next;
        }
        // node == null
        // merge array into single list
        for(i = 0; i < NUMLIST; i++)
            node = merge(alist[i], node);
        return node;
    }

    // merge two already sorted lists
    static Node merge(Node list0, Node list1) {
        if(list0 == null)
            return list1;
        if(list1 == null)
            return list0;
        Node head;
        Node dest;
        if(true){
            if(list0.data <= list1.data){
                head = list0;
                dest = list0;
                list0 = list0.next;
                if(list0 == null){
                    dest.next = list1;
                    return head;
                }
            } else {
                head = list1;
                dest = list1;
                list1 = list1.next;
                if(list1 == null){
                    dest.next = list0;
                    return head;
                }
            }
        }
        while(true){
            if(list0.data <= list1.data){
                dest.next = list0;
                dest = list0;
                list0 = list0.next;
                if(list0 == null){
                    dest.next = list1;
                    return head;
                }
            } else {
                dest.next = list1;
                dest = list1;
                list1 = list1.next;
                if(list1 == null){
                    dest.next = list0;
                    return head;
                }
            }
        }
    }

自顶向下

    // top down merge sort for single link list entry function
    static Node sorttd(Node head) {
        int n = size(head);
        if(n < 2)
            return head;
        head = sorttdr(head, n);
        return head;
    }

    // top down merge sort for single link list recursive function
    static Node sorttdr(Node head, int n) {
        if(n < 2)
            return head;
        int n2 = (n/2);
        Node node = advance(head, n2-1);
        Node next = node.next;
        node.next = null;
        head = sorttdr(head, n2);
        next = sorttdr(next, n-n2);
        head = merge(head, next);
        return head;
    }

    // return size of list
    static int size(Node head) {
    int i = 0;
        while(head != null){
            head = head.next;
            i++;
        }
        return i;
    }

    // advance to node n
    static Node advance(Node head, int n) {
        while(0 < n--)
            head = head.next;
        return head;
    }

    // merge two already sorted lists
    static Node merge(Node list0, Node list1) {
        if(list0 == null)
            return list1;
        if(list1 == null)
            return list0;
        Node head;
        Node dest;
        if(true){
            if(list0.data <= list1.data){
                head = list0;
                dest = list0;
                list0 = list0.next;
                if(list0 == null){
                    dest.next = list1;
                    return head;
                }
            } else {
                head = list1;
                dest = list1;
                list1 = list1.next;
                if(list1 == null){
                    dest.next = list0;
                    return head;
                }
            }
        }
        while(true){
            if(list0.data <= list1.data){
                dest.next = list0;
                dest = list0;
                list0 = list0.next;
                if(list0 == null){
                    dest.next = list1;
                    return head;
                }
            } else {
                dest.next = list1;
                dest = list1;
                list1 = list1.next;
                if(list1 == null){
                    dest.next = list0;
                    return head;
                }
            }
        }
    }