快速排序出错（添加了一些重复项）

Question

I'm new to sorting algorithms and can't seem to figure out what went wrong. With an unsorted array of int [] uArr = {5,2, 10, 7, 6, 0, 8, 1, 9}, i'm given 0,1,2,5,5,6,8,10 (the nine in the org. array was replaced with a duplicate 5 and the 7 was lost). If I add duplicates to the array, I get more duplicates after the array is sorted and a few more missing numbers.

 public static void main(String args[]){
     int [] uArr = {5,2, 10, 7, 6, 0, 8, 1, 9};

     qSort(uArr, 0, 8);
     
 }

 public static void qSort(int [] A, int low, int high){
    
    if (low < high){
   int pivotL = partition(A, low, high);
   qSort(A, low, pivotL);
 qSort(A, pivotL+1, high);
    }       
}
public static int partition(int [] arr, int low, int high){
 int pivot = arr[low];
 int leftwall = low;
 for (int i = low + 1; i < high; i++){
if (arr[i] < pivot){
 int temp = arr[i];
 arr[i] = arr[leftwall];
arr[leftwall] = temp;
leftwall += 1;

}  
}

int temp2 = pivot;
pivot = arr[leftwall];
arr[leftwall] = temp2;
return leftwall;
}
}

Answer 1

So one thing you should seriously do is start writing documentation. Even though this is a small program, you seem to have forgotten what you were doing as you were writing the code.

For example, there are 9 elements in the array, and you pass in the offsets to sort, inclusive, as 0 through 8:

  qSort( uArr, 0, 8 );

But then in the partition routine you only sort elements less than the high value:

 for( int i = low + 1; i < high; i++ ) {

And unlike you the last value in the array, 9, is never touched for me and never sorted. So that's an issue. Figure out if you want your indexes to be inclusive or not. For me writing documentation as I go helps me keep these ideas straight.

I'm still looking for other problems like the duplication.

Update: I'm going to just post these as I figure them out, as a sort of stream-of-consciousness of how I look for problems. One thing I was taught early on is that adding print statements to your code can be faster than using a debugger. So (after re-formatting your code, because the formatting you posted was frankly crap) I added this:

 public static void qSort( int[] A, int low, int high ) {
    System.out.println( Arrays.toString( A ) + " low=" + low + " high=" + high );

And got this output:

run:
[5, 2, 10, 7, 6, 0, 8, 1, 9] low=0 high=8
[2, 0, 1, 5, 6, 5, 8, 10, 9] low=0 high=3
[0, 1, 2, 5, 6, 5, 8, 10, 9] low=0 high=2
[0, 1, 2, 5, 6, 5, 8, 10, 9] low=0 high=0
[0, 1, 2, 5, 6, 5, 8, 10, 9] low=1 high=2
[0, 1, 2, 5, 6, 5, 8, 10, 9] low=1 high=1
[0, 1, 2, 5, 6, 5, 8, 10, 9] low=2 high=2
[0, 1, 2, 5, 6, 5, 8, 10, 9] low=3 high=3
[0, 1, 2, 5, 6, 5, 8, 10, 9] low=4 high=8
[0, 1, 2, 5, 5, 6, 8, 10, 9] low=4 high=5
[0, 1, 2, 5, 5, 6, 8, 10, 9] low=4 high=4
[0, 1, 2, 5, 5, 6, 8, 10, 9] low=5 high=5
[0, 1, 2, 5, 5, 6, 8, 10, 9] low=6 high=8
[0, 1, 2, 5, 5, 6, 8, 10, 9] low=6 high=6
[0, 1, 2, 5, 5, 6, 8, 10, 9] low=7 high=8
[0, 1, 2, 5, 5, 6, 8, 10, 9] low=7 high=7
[0, 1, 2, 5, 5, 6, 8, 10, 9] low=8 high=8
[0, 1, 2, 5, 5, 6, 8, 10, 9]
BUILD SUCCESSFUL (total time: 0 seconds)

I did have to stare at the output for a while, but what I noticed next was two things. The 5 is duplicated almost immediately, and the 5 is also the first element, which means it's going to be chosen by your partition code as the pivot. So it looks as though you have problems re-merging the pivot with the array.

Update 2: OK found another problem. This one I found by writing your array out by hand and walking through each value of i and leftwall as it makes the first partition. Problem here:

When the pivot, 5, encounters the element 0 in the array, the rest of the array has not been sorted. The 10 , 7 , 6 , etc. are not less than the pivot and have not be touched. So when you make the swap, you sawp this:

[2, 5, 10, 7, 6, 0, 8, 1, 9]

for this:

[2, 5, 0, 7, 6, 5, 8, 1, 9]

This is because leftwall was 1 (it had been swapped with the 2 but not any other number, so it only had been incremented once) and there's the duplication and losing numbers too. I'm going to stop there because you have some pretty big problems.

What you need to do in this case is swap the 10 , not the pivot, with the 0 . This is going to require one additional pointer at least. Quicksort algorithms need to find the lowest and highest in the array and have two loops inside the outer for loop. What you have here is a kind of weird recursive insert sort. You'll need to think a bit more how to do this, but two more loops, nest inside the first, will be required.