在链表上使用递归进行快速排序答案

【问题标题】：Quick Sort using recursion on a linked list在链表上使用递归进行快速排序
【发布时间】：2011-02-23 12:52:01
【问题描述】：

我必须在链表上使用递归进行快速排序......到目前为止我还不错，但是我遇到了一个小问题，我看不出它为什么不能正常工作.

这里是对象节点：

    public class Node
    {
      String name;
      Node next;
    }

这是程序的代码：

    public class QuickSortRecusionLinkedList
    {
      public static void quickS(int start, int finish, Node head, Node tail)
      {
        int left = start;
        int right = finish;
        Node pivot = head;
        for(int i = 0; i < ((left+right)/2); i++)
        {
          pivot = pivot.next;
        }
        Node temp = new Node();
        Node leftN = head;
        Node rightN = head;

        while(right > left)
        {
          leftN = head;
          for(int i = 0; i < left; i++)
          {
            leftN = leftN.next;
          }
          while ((leftN.name).compareToIgnoreCase((pivot.name))<0)
          {
            left = left + 1; 
            leftN = leftN.next;
          }
          rightN = head;
          for(int i = 0; i < right; i++)
          {
            rightN = rightN.next;
          }
          while ((pivot.name).compareToIgnoreCase((rightN.name))<0)
          {
            right = right - 1;
            rightN = head;
            for(int i = 0; i < right; i++)
            {
              rightN = rightN.next;
            }
          }

          if ( left <= right
             )
          {
            temp.name = leftN.name;
            leftN.name = rightN.name;
            rightN.name = temp.name;

            left = left +1;
            leftN = leftN.next;

            right = right -1;
            rightN = head;
            for(int i = 0; i < right; i++)
            {
              rightN = rightN.next;
            }

            int size = 1;
            temp = head;
            while (temp!=tail)
            {
              temp = temp.next;
              size++;
            }
            temp = head;
            while(temp != tail)
            {
              System.out.print(temp.name + ", ");
              temp = temp.next;
            }
            System.out.println(tail.name + ".");
          }
        }

        if(start < right) 
          quickS(start, right, head, tail);
        if(left < finish) 
          quickS(left, finish, head, tail);
      }

      public static void main(String[] args)
      {
        Node head = new Node();
        Node tail = new Node();
        Node a = new Node();
        Node b = new Node();
        Node c = new Node();

        head.name = "R";
        tail.name = "D";
        a.name = "Z";
        b.name = "C";
        c.name = "P";

        head.next = a;
        a.next = b;
        b.next = c;
        c.next = tail;

        int size = 0;
        Node temp = head;
        while (temp!= tail)
        {
          temp = temp.next;
          size++;
        }

        quickS(0,size,head,tail);
      }

    }

这是打印输出：

C, Z, R, P, D.
C, Z, R, P, D.
C, D, R, P, Z.
C, D, P, R, R.
C, D, P, R, R.
C, D, P, R, R.

最终结果应该是C, D, P, R, Z。但由于某种原因，该程序正在用Z 替换另一个R。代码有什么问题？

【问题讨论】：

重新格式化代码或将其粘贴。
使用调试器时看到了什么？
首先，我不知道如何编辑代码以使其正常，而不是像我现在拥有的那样奇怪......这是我能做到的最好的对不起。跨度>
这是作业吗？如果没有，为什么不直接使用 Collections.sort？
了解调试器的好机会。

标签： java sorting recursion linked-list

【解决方案1】：

可能的提示：当您使用它来交换名称时，请注意 temp 变量所指向的内容。

【讨论】：

谢谢johusman！在我输入 temp = new Node(); 之后它工作得很好在交换之前...谢谢
帮人做作业还是觉得有点脏，但这和快速排序算法本身并没有什么关系，只是一个愚蠢的疏忽:)
你几乎没有为他做功课！您刚刚指出了一个 [小] 逻辑错误

【解决方案2】：

恕我直言，这似乎是一件傻事。链表上的 Quiksort 会很快但。它的整个想法是使用数组。这里的目标是什么？

【讨论】：