Schnelles Sortieren mit Rekursion auf eine verknüpfte Liste

Ich tun muss, um ein schnelles Sortieren mit Rekursion auf einer verlinkten Liste.... So weit ich das ok gewesen, aber ich lief in ein kleines problem, dass ich nicht sehen kann, um herauszufinden, warum es nicht richtig funktioniert.

Hier ist die Objekt-Knoten:

    public class Node
    {
      String name;
      Node next;
    }

Hier ist der Programm-code:

    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);
      }

    }

Hier ist der Ausdruck:

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.

Das Endergebnis sein sollte C, D, P, R, Z. aber aus irgendeinem Grund ist das Programm ersetzen Z für andere R. Was ist falsch an dem code?