双头队列(Deque)Quicksort

时间:2016-04-20 09:04:11

标签: java queue quicksort

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

当我在包含随机生成元素的双端队列上运行快速排序时[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);

}

1 个答案:

答案 0 :(得分:0)

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

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

例如

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

现在连接(分步)

  1. left - &gt; deque [3]
  2. pivot(enqueueFront) - &gt; deque [5,3]
  3. right(enqueueFront) - &gt; deque [7,5,3]
  4. 因此我们假设这个集合现在是左侧部分处理的结果。现在,如果您将该集合与[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]
    6. 可以看出,部分排序的子列表的顺序与每次递归交替。导致带有部分排序片段的错误排序结果集。

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