Question

我正在尝试使用快速排序来分类CYCLIC LINKED LIST！

DoublyLinkedList包含ListElements。

ListElement有元素优先，它引用了它的前身和继承者。

e.g。 DoubleLinkyedList in首先包含ListElement。首先可以用first.prev oder first.next引用。

链接列表中的最后一个元素具有对第一个元素的引用，例如last = first.prev;

我的问题是，我一直收到错误，但我不知道哪一个是错误的，因为它就像一个永无止境的循环而且终端没有打印出精确的异常。

我的类Sorter.java的代码，我实现了排序操作：

package ads1ss13.pa;


public class Sorter {

public DoublyLinkedList quicksort(DoublyLinkedList in, int numOfElements) {


    System.out.println("STARTE sort() in quicksorT()");

    in = Sort(in, in.first.getId(), in.first.prev.getId());

    return in;
}

public DoublyLinkedList Sort(DoublyLinkedList in, int l, int r)
{
    System.out.println("Sort()");

    l = in.first.getId();
    r = in.first.prev.getId();
    ListElement pivot = null;

    System.out.println("l: "+l+"; r: "+r);

    if(l < r)
    {
        pivot = in.first.prev;
    }

    System.out.println("pivot: "+pivot);

    System.out.println("Ausfuehren der Partition mit l, r, pivot");

    int p = Partition(in, l, r, pivot);

    System.out.println("Ausgabe aus Partition p: "+p);

    System.out.println("Ausführen der Sort() mit l und p-1 für r");


    Sort(in, l, p-1);

    System.out.println("Ausführen der Sort() mit p+1 für l, und r");
    Sort(in, p+1, r);

    return in;
}

public int Partition(DoublyLinkedList in, int l, int r, ListElement pivot)
{
    System.out.println("Partition()");

    int i = l;
    int j = r;
    ListElement r_ListElement = in.first.prev;
    ListElement i_element = in.first.next;
    ListElement j_element = pivot;

    System.out.println("i: "+i+"; j: "+j+", pivot: "+j_element);

    do {

        do {
            i = i + 1;
            i_element = i_element.next;
        } while (i_element.getKey() < pivot.getKey());

        do {
            j = j - 1;
            j_element = j_element.prev; 
        } while (j > i || j_element.getKey() > pivot.getKey());

        if(i_element.getKey() < j_element.getKey())
        {
            swap(in, i_element, j_element);
        }

    } while (i < j);

    swap(in, i_element, r_ListElement);

    return i;
}

public void swap(DoublyLinkedList in, ListElement links, ListElement rechts)
{
    if(links.next.getId()==rechts.getId()){

        ListElement Lprev = links.prev;
        ListElement Rnext = rechts.next;
        Lprev.next=rechts;
        rechts.prev=Lprev;
        links.next=Rnext;
        Rnext.prev=links;
        links.prev=rechts;
        rechts.next=links;

        }

        else if(rechts.next.getId()==links.getId())
        {
            swap(in, rechts, links);
        }
        else
        {
            ListElement Lprev=links.prev;
            ListElement Lnext = links.next; 
            links.next=rechts.next;
            links.prev=rechts.prev;
            rechts.next=Lnext;
            rechts.prev=Lprev; 
            links.prev.next=links;
            links.next.prev=links;
            rechts.prev.next=rechts;
            rechts.next.prev=rechts;
        }


        if(in.first.getId()==links.getId())
        {
            in.first = rechts;
        }
        else if(in.first.getId()==rechts.getId())
        {
            in.first = links;

        }
}
}

您是否知道为什么我的代码永远不会切换到sort()的第二次递归调用以及返回哪个错误？

Answer 1

这很难分析，因为我无法将代码抛入调试器。但是，有一些事情可以让你走上正轨：

问题1。

您将int l和int r作为参数，但您会立即覆盖它们：

l = in.first.getId();
r = in.first.prev.getId();

这几乎肯定不是你想要做的，因为你会一遍又一遍地重新启动。这可能是造成你无限循环的原因。

第2期。

if(l < r)
{
    pivot = in.first.prev;
}

如果l >= r，则数据透视为null，这将导致NullPointerException

第3期。

您的分区逻辑错误。您不需要嵌套循环。只要将元素与数据透视表进行比较，就可以立即进行交换（您将始终知道它应该位于枢轴的哪一侧）。

Quicksort链接列表枢轴最后元素

1 个答案:

问题1。

第2期。

第3期。