Question

我使用数组以静态方式在java中实现了quickSort算法。

public static <T extends Comparable<T>> void quickSort(T[] A){
    quickSort(A, 0, A.length-1);
}

private static <T extends Comparable<T>> void quickSort(T[] A, int p, int r){
    if(p < r){
        int q = partition(A, p, r);
        quickSort(A, p, q);
        quickSort(A, q+1, r);
    }
}

private static <T extends Comparable<T>> int partition(T[] A, int p, int r){
    T x = A[p];
    int i = p;
    int j = r;
    while(true){
        while(A[j].compareTo(x) > 0 && j > p){
            j--;
        }
        while(A[i].compareTo(x) < 0 && i < r){
            i++;
        }
        if(i < j)
            swap(A, i, j);
        else
            return j;
    }
}

有没有办法使用Lists实现这个算法，保留＆＃34;在loco＆＃34;属性。我认为使用没有索引的列表是一个问题，因为你需要知道两个不同的＆＃34; while＆＃34; ，如果引用属于另一个节点之前的节点。有没有人知道避免这种麻烦的方法？

Answer 1

使用List而不是数组实现相同的算法没有问题。您可以像使用数组一样使用List：使用set和get方法。它还有方便的方法，如subList，可用于快速排序。子列表是列表的视图;不涉及复制。因此，这消除了传递上限和下限的需要。

static void sort(List<Integer> list) {
    if (!list.isEmpty()) {
        int pivotValue = list.get(list.size() - 1);
        int storeIndex = 0;
        for (int i = 0; i < list.size() - 1; i++) {
            if (list.get(i) < pivotValue) {
                Collections.swap(list, i, storeIndex++);
            }
        }
        Collections.swap(list, list.size() - 1, storeIndex);
        sort(list.subList(0, storeIndex));
        sort(list.subList(storeIndex + 1, list.size()));
    }
}

您指的是使用没有索引的列表的问题。当然，可以从列表中add和remove对象而不使用索引。但是，很难看到如何在不使用索引的情况下实现快速排序。例如，拾取枢轴和交换元素都需要索引。

是否有可能在列表中实现快速排序？

1 个答案: