双头队列（Deque）Quicksort

Question

我一直在与我的快速排序功能搏斗，但仍然不知道我做错了什么。

当我在包含随机生成元素的双端队列上运行快速排序时[6,92,63,90,79,94,8,13,72,28]

结果是[13,8,28,94,92,63,72,90,79,6]

public class DoublyLinkedDeque<E extends Comparable<E>> implements DequeADT<E>
{
    ...

    public void quickSort(DoublyLinkedDeque<E> deque, Comparator<E> comp) 
    {
        int n = deque.size();
        if (n < 2) 
        {
            return;
        }
        // using first as arbitrary pivot
        E pivot = deque.first();                     
        DoublyLinkedDeque<E> left = new DoublyLinkedDeque<>();
        DoublyLinkedDeque<E> equalsPivot = new DoublyLinkedDeque<>();
        DoublyLinkedDeque<E> right = new DoublyLinkedDeque<>();
        while (!deque.isEmpty()) 
        {
            // divide original into left, equalsPivot, and right
            E element = deque.dequeueFront();
            int tmpCompare = comp.compare(element, pivot);
            // element is less than pivot
            if (tmpCompare < 0)                             
            {
                left.enqueueFront(element);
            }
            // element is equal to pivot
            else if (tmpCompare == 0)                       
            {
                equalsPivot.enqueueFront(element);
            }
            // element is greater than pivot
            else                                   
            {
                right.enqueueFront(element);
            }
        }
        // sort elements less than pivot
        quickSort(left, comp);                      
        // sort elements greater than pivot
        quickSort(right, comp);                      
        // concatenate results
        while (!left.isEmpty())
        {
            deque.enqueueFront(left.dequeueFront());
        }
        while (!equalsPivot.isEmpty())
        {
            deque.enqueueFront(equalsPivot.dequeueFront());
        }
        while (!right.isEmpty())
        {
            deque.enqueueFront(right.dequeueFront());
        }
    }
}


public static void main(String[] args)
{        

    DoublyLinkedDeque<Integer> deque = new DoublyLinkedDeque<Integer>();

    /* ADDING RANDOM NUMBER TO deque */

    Comparator<Integer> intComparator = new Comparator<Integer>()
    {
        @Override
        public int compare(Integer i1, Integer i2)
        {
            return (i1 < i2 ? -1 : i1 > i2 ? +1 : 0);
        }
    };

    deque.quickSort(deque, intComparator);

}

Answer 1

如果我正确理解了您的代码，那么错误就在最后一部分，您将连接结果。

从左侧部分（小于数字的数字）开始，删除其第一个元素并将其从左侧推入队列，因此它成为最右侧的元素。然后你按下枢轴，然后是右边部分的元素（数字大于数字），成为队列中最左边的元素。

例如

• 左：[3]
• pivot：[5]
• 右：[7]

现在连接（分步）

1. left - ＆gt; deque [3]
2. pivot（enqueueFront） - ＆gt; deque [5,3]
3. right（enqueueFront） - ＆gt; deque [7,5,3]

因此我们假设这个集合现在是左侧部分处理的结果。现在，如果您将该集合与[9,8]

的另一组错误排序的较大值（右侧部分）相结合
• 左：[7,5,3]
• 右：[9,8]

你得到（简化步骤）

1. [7]
2. [5,7]
3. [3,5,7]
4. [9,3,5,7]
5. [8,9,3,5,7]

可以看出，部分排序的子列表的顺序与每次递归交替。导致带有部分排序片段的错误排序结果集。

TL; DR 检查连接的顺序或使用正确的添加操作（正面与背面）