Java中的快速排序列表

Question

我正在嘗試使用Java練習快速排序列表，我認為這是正確的，但它顯示“線程主異常...”

public class QuickSort {

  public static void sort(List<Integer> list) {
    sort(list, 0, list.size() - 1);
  }

  public static void sort(List<Integer> list, int from, int to) {
    if (list.size() <= 1) {
        return;
    }
    int pivot = from;
    int left = from + 1;
    int right = to;
    while (left < right) {
        while (list.get(pivot) >= list.get(left)) {
            left++;
        }
        while (list.get(pivot) <= list.get(right)) {
            right--;
        }
        if (left < right) {
            Collections.swap(list, left, right);
        }
    }
    Collections.swap(list, pivot, left - 1);
    sort(list, from, pivot - 1);
    sort(list, pivot + 1, to);
  }
}

Answer 1

您的問題在這里：

while (list.get(pivot) <= list.get(right)) {
        right--;
    }

因為，在最壞的情況下，說一個已經排序的list ，您的right--將為負。

看一下下面的代碼，這將為您提供想法：

public static void quicksort(List<Integer> list, int left, int right) {
    int q;
    if (right > left) {
        q = partition(list, left, right);
        // after ‘partition’
        // list[left..q-1] ≤ list[q] ≤ list[q+1..right]
        quicksort(list, left, q - 1);
        quicksort(list, q + 1, right);
    }
}

static int partition(List<Integer> list, int left, int right) {
    int P = list.get(left);
    int i = left;
    int j = right + 1;
    for (;;) { // infinite for-loop, break to exit
        while (list.get(++i) < P)
            if (i >= right)
                break;
        // Now, list[i]≥P
        while (list.get(--j) > P)
            if (j <= left)
                break;
        // Now, list[j]≤P
        if (i >= j)
            break; // break the for-loop
        else
            // swap(list[i],list[j]);
            Collections.swap(list, i, j);
    }
    if (j == left)
        return j;
    // swap (list[left],list[j]);
    Collections.swap(list, left, j);
    return j;
}

在此處查看演示運行。

Answer 2

試試這個：

public static void sort(List<Integer> list) {
    sort(list, 0, list.size() - 1);
}

public static void sort(List<Integer> list, int from, int to) {
    if (from < to) {
        int pivot = from;
        int left = from + 1;
        int right = to;
        int pivotValue = list.get(pivot);
        while (left <= right) {
            // left <= to -> limit protection
            while (left <= to && pivotValue >= list.get(left)) {
                left++;
            }
            // right > from -> limit protection
            while (right > from && pivotValue < list.get(right)) {
                right--;
            }
            if (left < right) {
                Collections.swap(list, left, right);
            }
        }
        Collections.swap(list, pivot, left - 1);
        sort(list, from, right - 1); // <-- pivot was wrong!
        sort(list, right + 1, to);   // <-- pivot was wrong!
    }
}