QuickSort打破

Question

我正在尝试并行化快速排序，所以我首先在两个分区上使用分区和递归排序编写了串行版本。这工作..直到＆gt;的大小。 100,000，在这种情况下，如果其中一个分区太大，它将永远存在，永远不会完成。我无法弄清楚为什么会这样。它将以13k的速度运行在100k，然后在120k，它将在大约相同的时间运行或者根本不运行。

对于我的分区，我根据当前分区的第一个，中间和最后一个元素的中位数选择了枢轴，如果它们相等则转到最后一个元素。

这是我的分区：

private static int partition(int low, int high, int[] array){
    //get median of first, last, and middle element in our section
    int lVal, hVal, mVal, pIndex, pVal;
    lVal = array[low];
    hVal = array[high];
    mVal = array[((high-low+1)/2) + low];
    //System.out.println("LOW: " + low + "HIGH: " + high);
    if (lVal < hVal && lVal > mVal || lVal > hVal && lVal < mVal){
        pIndex = low;
        //System.out.println("Picking low index: " + low);
    } else if (hVal < lVal && hVal > mVal || hVal > lVal && hVal < mVal){
        pIndex = high;
        //System.out.println("Picking high index: " + high);
    } else if (mVal < hVal && mVal > lVal || mVal > hVal && mVal < lVal){
        pIndex = (high-low+1)/2+low;
        //System.out.println("Picking middle index: " + ((high-low+1)/2)+low);
    } else {
        pIndex = high;
    }
    pVal = array[pIndex];

    //put pivot at the back of our chunk
    int temp = array[pIndex];
    array[pIndex] = array[high];
    array[high] = temp;
    //printArray();

    //two pointer method.. high and low.. move them and swap if low > pivot and high < pivot
    int left = low;
    int right = high - 1;
    pIndex = 0;

    while (left <= right){
        while(left <= high && array[left] < pVal){
            left++;
        }
        while(right >= low && array[right] > pVal){
            right--;
        }
        //if both elements at the pointers are on the wrong side we swap
        if(left < right){
            temp = array[left];
            array[left] = array[right];
            array[right] = temp;
            left++;
            right--;
            //printArray();
        }
    }
    //need to get pivot from high to where the low pointer ended
    temp = array[left];
    array[left] = array[high];
    array[high] = temp;

    //printArray();
    return left;
}

无论有多少元素，这似乎都需要很长时间，因此我不确定这是否是原因。

这是我的排序：

public static void sort (int low, int high, Comparator c, int[] array){
        if(high - low > 1) {
            int pIndex = partition(low, high, array);

            sort(low, pIndex - 1, c, array);
            sort(pIndex + 1, high, c, array);
        }

}

关于为什么在某个时刻冻结的任何想法都会很棒。我运行了另一种我在互联网上找到的分区，它运行得很好我给它的任何尺寸，但我想知道这有什么问题。这是我用来测试它的单元测试。

@Test
public void testSortStandard() throws Exception {
    int size = 100000;
    //test randoms to 10000
    int[] a = new int[size];
    Random r = new Random();
    for(int i = 0; i < size; i++){
        a[i] = r.nextInt();
    }
    QuickSort.sort(0, a.length-1, null, a);

    testIsSorted(a);
}

它继续运行并运行并运行。我有一种感觉，它只是一遍又一遍地把事情分开来。