具有重复值的QuickSort

Question

I have implemented the following code, but it does not seem to work for the case that my array has duplicate values.

 private int partition(Integer[] arr,int left, int right)
 {
    int i = left;
    int j = right;
    int pivot = arr[left];

    while(true) 
    {
        while(arr[i] <pivot) i++;
        while(arr[j] > pivot) j--;

        if(i < j)
        {
            print(arr);
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        else return j; 
    }
}


public void quickSort(Integer[] arr, int left,int right)
{
    print(arr);
    if(left >= right) return;

    int index = partition(arr,left,right);

    quickSort(arr,left,index-1);
    quickSort(arr,index+1,right);
}

I found a slightly different implementation that works pretty well in this case, but I don't understand why. Any help would be appreciated.

    private int partition(Integer[] arr, int left, int right)
    {
    int i = left-1;
    int j = right+1;
    int pivot = arr[left];


    while(true) 
    {

        while(arr[++i] < pivot) ;
        while(arr[--j] > pivot) ;

        if(i < j)
        {
            print(arr);
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        else return j; 
     }
     }

    public void quickSort(Integer[] arr, int left,int right)
    {
    print(arr);
    if(left >= right) return;

    int index = partition(arr,left,right);

    quickSort(arr,left,index);
    quickSort(arr,index+1,right);
    }

Answer 1

1.Pick up one element as the pivot

2.Move all elements less than the pivot to the left, and all elements greater than the pivot to the right

3.Apply the above steps on both parts

The following method implements quick sort. It defines a recursive method to sort subarrays, and also defines a method to partition an array into two parts.

public static void quickSort(int[] data, int first, int last)
      {
        if (first >= last)return;
        int pivot = partition(data, first, last);
        quickSort(data, first, pivot - 1); // sort the left part
        quickSort(data, pivot + 1, last); // sort the right part
      }

The partitioning process involves picking up the pivot and move elements around the pivot. A simple procedure is as below:

1,Allocate a new temporary array holding the partitioned result

2.Pick up the first element as the pivot

3.Scan the array from the second element, compare each element with the pivot, and put it to the left end of the temporary array if it is less than or equal to the pivot, otherwise put it to the right end.

4.Finally copy back the result from the temporary array to the original array

public static int partition(int[] data, int first, int last)
 {
int[] temp = new int[last - first + 1];
int pivot = data[first];
int i = 0, j = last - first, k;

for (k = first + 1; k <= last; k++)
{
    if (data[k] <= pivot)
        temp[i++] = data[k];
    else
        temp[j--] = data[k];
}
temp[i] = data[first];

// Copy data back into original array
for (k = first; k <= last; k++)
    data[k] = temp[k - first];
return first + i;
  }

The method above requires extra storage (linear space) holding the intermediate result. The following is an in-place version of the partitioning which does not require addtional storage:

1.Pick up the first element in the array as the pivot

2.Scan the array from both ends toward the middle

3.Whenever finding two elements on the wrong side, swap them

4.When the scans from both ends meet in the middle, swap the pivot with this middle element

public static int partition(int[] data, int first, int last)
 {
int pivot = data[first];
int left = first, right = last;

while (left < right)
{
    // Find an element bigger than the pivot from the left
    while (data[left] <= pivot && left < right)
        left++;
    // Find an element smaller than the pivot from the right
    while (data[right] > pivot)
        right--;
    // Swap the two elements found
    if (left < right)
        swap(data, left, right);
}

// move the pivot element to the middle
swap (data, first, right);
return right; }

1.If the pivot chosen at each time is the median element, then the partitioning is even, and the level of partitioning is O(log n)

2.If the pivot chosen at each time is either the smallest or the largest element (bad luck every time), then one part has no element and the other part holds all elements except the pivot itself. This will generate n levels of partitioning, which is essentially similar to selection sort.

3.If the pivot chosen randomly each time, then on average, the partitioning will be even, and the level of partitioning is close to O(log n).

Hopes this may bring you right idea about Quick Sort take some time to read all I provided comments in snippets too.

Answer 2

Here is your code:

    while(arr[i] <pivot) i++;
    while(arr[j] > pivot) j--;

Here is what is different in their code:

    while(arr[++i] < pivot) ;
    while(arr[--j] > pivot) ;

Notice they use the pre-increment/decrement operators ++i and --j. So, the first check in the while will in advance of the check increment or decrement.

which is equivalent to having:

do{ i++; }while(arr[i] < pivot);
do{ j--; }while(arr[j] > pivot);

Point is, you need to increment i and decrement j BEFORE your first comparisons.