使用Java对链表进行递归合并排序

我在网上搜索了一个使用递归的链表的Java合并排序算法的干净而简单的实现

我找不到一个好的，所以我尝试在这里实现它。但是我被卡住了

以下是我到目前为止的情况：

public List mergeSortList(Node head, Node tail) {

    if ((head == null) || (head.next == null))
        return;

    Node middle = this.findMiddle(head);
    List left = mergeSortList(this.head, middle);
    List right = mergeSortList(middle.next, tail);
    return merge(left, right);
}

private List merge(List left, List right) {
    List returnedList = new LinkedList();

}

private Node findMiddle(Node n) {
    Node slow, fast;
    slow = fast = n;

    while (fast != null && fast.next.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow;
}

有人能帮我改正错误并填好存根吗

---

谢谢

这看起来是个好的开始。您的合并方法将与任何其他合并排序实现一样工作，只是您处理的是列表而不是整数

您需要做的是：

• 创建要返回的新列表（“结果”）
• 将列表“左”中的第一个元素与列表“右”中的第一个元素进行比较
• 将较小的元素复制到结果中
• 将指针前进到较小元素来自的列表中
• 重复上述步骤，直到到达列表的末尾
• 将所有剩余元素复制到结果中

---

尝试一下（发布您的更新代码），我们将很乐意为您提供更多帮助。

这看起来是一个好的开始。您的合并方法将与任何其他合并排序实现一样工作，只是您处理的是列表而不是整数

您需要做的是：

• 创建要返回的新列表（“结果”）
• 将列表“左”中的第一个元素与列表“右”中的第一个元素进行比较
• 将较小的元素复制到结果中
• 将指针前进到较小元素来自的列表中
• 重复上述步骤，直到到达列表的末尾
• 将所有剩余元素复制到结果中

---

试一试（发布您的更新代码），我们将很乐意为您提供更多帮助。

第一个错误如下：-

while(fast != null && fast.next.next != null)
{
   slow = slow.next;
   fast = fast.next.next;
}  

fast.next

在执行

fast.next.next

时可以为空，考虑到没有奇数元素的情况

以下是修改后的代码：-

while(fast != null && fast.next.next != null)
{
    slow = slow.next;
    if(fast.next!=null)
        fast = fast.next.next;
    else break;
}  

下面是另一个修改：-

public List mergeSortList(Node head)
{
    if ( (head == null) || (head.next == null))
       return head;
    Node middle = this.findMiddle(head);
    Node first = head;
    Node second = middle.next;
    middle.next = null; 
    Node left = mergeSortList(first);
    Node right = mergeSortList(second);
    return merge(left, right);
 }

---

说明：您不需要将tail传递给函数，您可以将中间的列表拆分为两个以null结尾的单独列表。在两个列表递归之后，只需重新连接它们以防止丢失原始列表

第一个错误如下：-

while(fast != null && fast.next.next != null)
{
   slow = slow.next;
   fast = fast.next.next;
}  

fast.next

在执行

fast.next.next

时可以为空，考虑到没有奇数元素的情况

以下是修改后的代码：-

while(fast != null && fast.next.next != null)
{
    slow = slow.next;
    if(fast.next!=null)
        fast = fast.next.next;
    else break;
}  

下面是另一个修改：-

public List mergeSortList(Node head)
{
    if ( (head == null) || (head.next == null))
       return head;
    Node middle = this.findMiddle(head);
    Node first = head;
    Node second = middle.next;
    middle.next = null; 
    Node left = mergeSortList(first);
    Node right = mergeSortList(second);
    return merge(left, right);
 }

---

说明：您不需要将tail传递给函数，您可以将中间的列表拆分为两个以null结尾的单独列表。在两个列表递归之后，只需重新连接它们，以防止丢失原始列表， 第一个方法是我们从main（）调用的递归方法，然后使用快速和慢速指针技术划分列表（快速行走2步，慢速行走1步），现在使用两个列表递归调用自己，并使用第二个方法mergeSortedList合并返回的列表，并且我们在递归中一次又一次地调用mergeSortedList，所以在最后，当每个列表中只剩下一个元素时，我们比较它们并按正确的顺序相加

ListNode sortList(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode fast = head;
        ListNode slow = head;
        // get in middle of the list :
        while (fast.next!= null && fast.next.next !=null){slow = slow.next; fast = fast.next.next;}
        fast = slow.next;
        slow.next=null;
        return mergeSortedList(sortList(head),sortList(fast));
        }

ListNode mergeSortedList(ListNode firstList,ListNode secondList){
            ListNode returnNode = new ListNode(0);
            ListNode trackingPointer = returnNode;
            while(firstList!=null && secondList!=null){
                if(firstList.val < secondList.val){trackingPointer.next = firstList; firstList=firstList.next;}
                else {trackingPointer.next = secondList; secondList=secondList.next;}
                trackingPointer = trackingPointer.next;
            }
            if (firstList!=null) trackingPointer.next = firstList;
            else if (secondList!=null) trackingPointer.next = secondList;
            return returnNode.next;
            }
        }

ListNode排序列表（ListNode头）{
if（head==null | | head.next==null）返回head；
ListNode fast=头部；
ListNode慢=头部；
//进入列表中间：
而（fast.next！=null&&fast.next.next！=null）{slow=slow.next；fast=fast.next.next；}
快=慢。下一步；
slow.next=null；
返回合并分类列表（分类列表（head）、分类列表（fast））；
}
ListNode合并分类列表（ListNode第一列表，ListNode第二列表）{
ListNode returnNode=新ListNode（0）；
ListNode trackingPointer=returnNode；
while（firstList！=null&&secondList！=null）{
if（firstList.val

解决方案分为两种方法， 第一个方法是我们从main（）调用的递归方法，然后使用快速和慢速指针技术划分列表（快速行走2步，慢速行走1步），现在使用两个列表递归调用自己，并使用第二个方法mergeSortedList合并返回的列表，并且我们在递归中一次又一次地调用mergeSortedList，所以在最后，当每个列表中只剩下一个元素时，我们比较它们并按正确的顺序相加

ListNode sortList(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode fast = head;
        ListNode slow = head;
        // get in middle of the list :
        while (fast.next!= null && fast.next.next !=null){slow = slow.next; fast = fast.next.next;}
        fast = slow.next;
        slow.next=null;
        return mergeSortedList(sortList(head),sortList(fast));
        }

ListNode mergeSortedList(ListNode firstList,ListNode secondList){
            ListNode returnNode = new ListNode(0);
            ListNode trackingPointer = returnNode;
            while(firstList!=null && secondList!=null){
                if(firstList.val < secondList.val){trackingPointer.next = firstList; firstList=firstList.next;}
                else {trackingPointer.next = secondList; secondList=secondList.next;}
                trackingPointer = trackingPointer.next;
            }
            if (firstList!=null) trackingPointer.next = firstList;
            else if (secondList!=null) trackingPointer.next = secondList;
            return returnNode.next;
            }
        }

ListNode排序列表（ListNode头）{
if（head==null | | head.next==null）返回head；
ListNode fast=头部；
ListNode慢=头部；
//进入列表中间：
而（fast.next！=null&&fast.next.next！=null）{slow=slow.next；fast=fast.next.next；}
快=慢。下一步；
slow.next=null；
返回合并分类列表（分类列表（head）、分类列表（fast））；
}
ListNode合并分类列表（ListNode第一列表，ListNode第二列表）{
ListNode returnNode=新ListNode（0）；
ListNode trackingPointer=returnNode；
while（firstList！=null&&secondList！=null）{
if（firstList.val

java工作解决方案。转到以下链接：

导入