java 如何随机排序数据,使用Java中的随机数据库快速排序

I've been assigned to implement a quick sort with a random pivot point (because it's supposedly the most efficient/safest way), yet I've been slaving over a bogosort. Can anyone direct me on how to do it? And can someone help me look at my bogosort to see if I can save it anyway?

public static void Quick(int[] target, int lo, int hi) {

if(hi-lo==0){return;}

Random numberGenerator = new Random();

int pivot = (numberGenerator.nextInt(hi-lo)+lo);

int high;

for(high=hi; high>pivot ; high--){

if(target[high]

if(high-pivot==1){

int temp=target[high];

target[high]=target[pivot];

target[pivot]=temp;

}

else{

int temp1 = target[pivot];

int temp2 = target[pivot+1];

target[pivot]=target[high];

target[pivot+1]=temp1;

target[high]=temp2;

}

}

}

int low;

for(low=lo; low

if(target[low]>target[pivot]){ //if highest was smaller than pivot, move far end

if(pivot-low==1){

int temp=target[low];

target[low]=target[pivot];

target[pivot]=temp;

}

else{

int temp1 = target[pivot];

int temp2 = target[pivot-1];

target[pivot]=target[low];

target[pivot-1]=temp1;

target[low]=temp2;

}

}

}

if(low-lo>0){

Quick(target, lo, low-1);

}

if(hi-high>0){

Quick(target, high+1, hi);

}

}

解决方案

See this pseudocode for inplace patitioning (from Wikipedia):

function partition(array, left, right, pivotIndex)

pivotValue := array[pivotIndex]

swap array[pivotIndex] and array[right] // Move pivot to end

storeIndex := left

for i from left to right - 1 // left ≤ i < right

if array[i] ≤ pivotValue

swap array[i] and array[storeIndex]

storeIndex := storeIndex + 1

swap array[storeIndex] and array[right] // Move pivot to its final place

return storeIndex

Notice it loops through the whole array (except the last index). The pivot isn't swapped until the end. In your code the pivot value keeps changing through the loop which doesn't seem correct.

Each time there is a swap the swap target (storeIndex above) should change.

Also you only need to swap values lower than the pivot to the left. If all the low values are to the left, then the high values will end up on the right.