使用枢轴元素对数组进行分区的算法

Question

我试图从一些 java 编程书籍中解决以下编程练习

Write 方法使用第一个元素（称为枢轴）对数组进行分区。分区后，列表中的元素重新排列，使得枢轴之前的所有元素都小于或等于枢轴，枢轴之后的元素都大于枢轴。该方法返回新列表中枢轴所在的索引。例如，假设列表是 {5, 2, 9, 3, 6, 8}。分区后，列表变为{3, 2, 5, 9, 6, 8}。以最多进行array.length 比较的方式实现该方法。

我已经实现了解决方案，但它需要的远不止array.length 比较。

这本书本身有解决方案，但不幸的是它完全是错误的（不使用某些输入）。我已经看到了this 类似问题的答案，并且理解了快速排序算法的“征服”部分，但是在这个算法中，值使用中间值进行分区，但在我的情况下，需要使用第一个数组值作为枢轴。

Answer 1

这是来自链接答案（改编自 source here）的枢纽例程。

    int split(int a[], int lo, int hi) {
        // pivot element x starting at lo; better strategies exist
        int x=a[lo]; 

        //  partition
        int i=lo, j=hi;
        while (i<=j) {
            while (a[i]<x) i++;
            while (a[j]>x) j--;
            if (i<=j) swap(a[i++], a[j--]);
        }

        // return new position of pivot
        return i;
    }

该算法中元素间比较的次数要么是n，要么是n+1；因为在每次主循环迭代中，i 和 j 以恰好 c 个单位靠得更近，其中 c 是在每个内部循环中执行的比较次数while 循环。看看那些内部循环 - 当它们返回 true 时，i 和 j 移动了 1 个单位。如果它们返回 false，那么在主循环结束时，i 和 j 将因为交换而靠近 2 个单位。

这个 split() 可读且简短，但它也有一个非常糟糕的最坏情况（即，枢轴在任一端结束；请点击第一个链接查看它的结果）。如果数组已经向前或向后排序，就会发生这种情况，这实际上非常频繁。这就是为什么其他枢轴位置更好的原因：如果您选择 x=a[lo+hi/2]，最坏的情况将不太常见。更好的是do like Java，并花一些时间寻找一个好的支点来避开最坏的情况。如果您点击 Java 链接，您将看到一个更复杂的数据透视例程，它可以避免在有许多重复元素时做额外的工作。

Answer 2

似乎算法（取自“算法简介第三版”）可以实现如下（C++）在Java的泛型中应该是类似的：

template <typename T> void swap_in_place(T* arr, int a, int b)
{
    T tmp = arr[a];
    arr[a] = arr[b];
    arr[b] = tmp;
}

template <typename T> int partition(T* arr, int l, int r)
{
      T pivot = arr[r];
      int i = l-1;
      int j;
      for(j=l; j < r; j++) {
         if (arr[j] < pivot /* or cmp callback */) {
               // preincrement is needed to move the element
             swap_in_place<T>(arr, ++i, j);
          }
       }
       // reposition the pivot
       swap_in_place(arr, ++i, j);
       return i;
    }
template <typename T> void qsort(T* arr, int l, int r) 
{
    if ( l < r ) {
       T x = partition<T>(arr, l, r);
       qsort(arr, l, x-1);
       qsort(arr, x+1, r);
     }
 }

但是，它是一个简单的伪代码实现，我不知道它是否是最好的选择。也许 (l+r)/2 会更合适。

Answer 3

非常简单的双端队列解决方案：

int [] arr = {3, 2, 5, 9, 6, 8};

Deque<Integer> q = new LinkedBlockingDeque<Integer>();

for (int t = 0; t < arr.length; t++) {
    if (t == 0) {
        q.add(arr[t]);
        continue;
    }

    if (arr[t] <= arr[0])
        q.addFirst(arr[t]);
    else
        q.addLast(arr[t]);
}

for (int t:q) {
    System.out.println(t);
}

输出是：

2
3
5 <-- pivot
9
6
8

Answer 4

我在基于 Pivot 的分区上制作的视频我解释了两种分区方法。

https://www.youtube.com/watch?v=356Bffvh1dA

并基于您的（另一种）方法

https://www.youtube.com/watch?v=Hs29iYlY6Q4

对于代码。这是我为枢轴作为第一个元素而编写的代码，它需要 O(n) 次比较。

void quicksort(int a[],int l,int n)
{   
    int j,temp;
    if(l+1 < n)
    {
        int p=l;
        j=l+1;
        for(int i=l+1;i<n;++i)
        {
            if(a[i]<a[p])
            {
                temp=a[i];
                a[i]=a[j];
                a[j]=temp;
                j++;
            }

        }   
        temp=a[j-1];
        a[j-1]=a[p];
        a[p]=temp;
        quicksort(a,l,j);
        quicksort(a,j,n);
    }
}

Answer 5

下面的分区函数工作如下： last 变量指向数组中的最后一个元素，该元素没有
与枢轴元素进行比较并且可以交换。 如果直接靠近枢轴元素的元素小于枢轴 元素。他们被交换了。 否则，如果枢轴元素小于下一个元素，则将下一个
元素与索引为最后一个变量的元素交换。

static int partition(int[] a){
    int pivot = a[0];    
    int temp, index = 0;
    int last = a.length -1;

    for(int i = 1; i < a.length; i++){

        //If pivot > current element, swap elements
        if( a[i] <= pivot){
            temp = a[i];
            a[i] = pivot;
            a[i-1] = temp;             
            index = i;
        } 
        //If pivot < current elmt, swap current elmt and last > index of pivot
        else if( a[i] > pivot && last > i){
            temp = a[i];
            a[i] = a[last];
            a[last] = temp;
            last -= 1;
            i--;
        }
        else
            break;
    }
    return index;
}