I'm a little confused on quicksort.
For example, with this algorithm taken from programcreek.com using the middle element as the pivot point:
public class QuickSort {
public static void main(String[] args) {
int[] x = { 9, 2, 4, 7, 3, 7, 10 };
System.out.println(Arrays.toString(x));
int low = 0;
int high = x.length - 1;
quickSort(x, low, high);
System.out.println(Arrays.toString(x));
}
public static void quickSort(int[] arr, int low, int high) {
if (arr == null || arr.length == 0)
return;
if (low >= high)
return;
// pick the pivot
int middle = low + (high - low) / 2;
int pivot = arr[middle];
// make left < pivot and right > pivot
int i = low, j = high;
while (i <= j) {
while (arr[i] < pivot) {
i++;
}
while (arr[j] > pivot) {
j--;
}
if (i <= j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
i++;
j--;
}
}
// recursively sort two sub parts
if (low < j)
quickSort(arr, low, j);
if (high > i)
quickSort(arr, i, high);
}
}
Can someone explain the 2 recursive calls at the bottom, as well as why there is a need to create an i and j variable to copy the left and right markers.
Also, can someone explain the difference between a quicksort algorithm using the middle element vs using the first or last element as the pivot point? The code looks different in a sense that using the last / first element as the pivot point is usually written with a partition method instead of the code above.
Thanks!
Quicksort is based on divide and conquer method, first we take a pivot element and put all elements that are less than this pivot element on the left and all the elements that are greater than this pivot element on the right and after that we recursively perform the same thing on both sides of pivot for left side Quicksort(array,low,pivot-1) for right side Quicksort(array,low,pivot+1)
This was the answer of your first question
and now what is the difference between choosing the middle or first element as pivot so
when we choose first element as pivot after sorting when i becomes greater than j we swap the pivot element(first element) with j so that the element that we chose as pivot comes at the place where all elements less than it comes at the left side and all elements greater than it comes it the right side.
and when we choose the middle element as pivot its already in the middle so there's no need to swap it.
This is a variation of Hoare partition scheme. The "classic" Hoare partition scheme increments i and decrements j before comparing to pivot. Both this example and the questions example include the partition logic in the main function.
void quickSort(int a[], size_t lo, size_t hi)
{
int pivot = a[lo+(hi-lo)/2];
int t;
if(lo >= hi)
return;
size_t i = lo-1;
size_t j = hi+1;
while(1)
{
while (a[++i] < pivot);
while (a[--j] > pivot);
if (i >= j)
break;
t = a[i];
a[i] = a[j];
a[j] = t;
}
QuickSort(a, lo, j);
QuickSort(a, j+1, hi);
}
The questions code increments i and decrements j after comparing to pivot.
The partition logic splits up a partition so that the left side <= pivot, right side >= pivot. The pivot and elements equal to pivot can end up anywhere on either side, and may not end up in their sorted position until a base case of a sub-array of size 1 is reached.
The reason for using the middle element for pivot is that choosing the first or last element for pivot will result in worst case time complexity of O(n^2) if the array is already sorted or reverse sorted. The example in this answer will fail if the last element is used for pivot (but the questions example will not).
Related
After a while, I was trying to implement quickSort on my own.
To me the implementation looks fine, but some test cases are apparently failing.
class MyImplementation {
public int[] sortArray(int[] nums) {
quicksort(nums, 0, nums.length - 1);
return nums;
}
private void quicksort(int[] nums, int lo, int hi){
if(lo < hi){
int j = partition(nums, lo, hi);
quicksort(nums, lo, j-1);
quicksort(nums, j+1, hi);
}
}
private int partition(int[] nums, int lo, int hi){
int pivot = nums[lo];
int head = lo + 1;
int tail = hi;
while(head < tail){
while(head < hi && nums[head] < pivot) ++head;
while(nums[tail] > pivot) --tail;
if(head < tail){
swap(nums, head, tail);
++head;
--tail;
}
}
if(nums[head] < pivot)
swap(nums, lo, head);
else
swap(nums, lo, head - 1);
return head;
}
private void swap(int[] nums, int i, int j){
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
It's passing in many cases, like these :-
[5,2,3,1]
[5,1,1,2,0,0]
[7,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]
but it's failing in the following test cases :-
[5,71,1,91,10,2,0,0,13,45,7]
the output I am getting is :-
[0,0,1,2,5,10,7,71,13,45,91]
instead of :-
[0,0,1,2,5,7,10,13,45,71,91]
I know, I can copy from somewhere to get the correctly working code, but can we figure out why this code is not working from an Algorithmic point of view!!
What is the logical flaw in this code?
How can we fix this with minimum changes and get a perfectly working code?
The currently accepted answer fixes the issue, but actually, the Lomuto algorithm (which is the algorithm being implemented) should be able to use j+1 as start for the second partition, since the pivot is expected to be at j and therefore doesn't need to be part of recursive sorts.
The real problem is that your partition method doesn't always return the index of the pivot:
if(nums[head] < pivot)
swap(nums, lo, head);
else
swap(nums, lo, head - 1);
return head;
In case of the else, the pivot is not swapped to index head, but to head - 1, and therefore the returned index should be head - 1 in that case.
Here is a simple fix:
if(nums[head] < pivot)
swap(nums, lo, head);
else
swap(nums, lo, --head);
return head;
That's quite subtle. The bug is here:
private void quicksort(int[] nums, int lo, int hi){
if(lo < hi){
int j = partition(nums, lo, hi);
quicksort(nums, lo, j-1);
quicksort(nums, j+1, hi);
// ^^^ j+1 must be j
}
}
The most subtle part is that it is not in general necessary to use j as the starting point of the "high" part to recurse on, but your partitioning algorithm requires it. So you will see various examples that recurse on different partitions, and they can be correct as well, in combination with whatever partitioning algorithm they use, but there is not much freedom to mix.
Your partitioning algorithm is based on Hoare's partitioning algorithm (see below), not Lomuto's algorithm. Lomuto's partitioning algorithm puts the pivot in its final position and returns its index, so that index can be skipped in the recursion. Hoare's partitioning algorithm, or your variant of it, does not quite do that. Eg in the case that the else branch at the end of your partitioning algorithm is taken, the pivot ends up at head - 1, while element at head has some arbitrary value not-less-than the pivot, all we know is that it belongs in the "high" partition but it has not been sorted yet and cannot be skipped.
In combination with Hoare's partitioning, it is common to see the recursion on [lo .. p] (where p is the index returned by the partitioning algorithm) and [p+1 .. hi], but that is not suitable in this case because your version of it returns head instead of tail, effectively making p one higher, so the partitions become [lo .. p-1] and [p .. hi].
As for this being similar to Hoare partitioning, consider that the important part of this partitioning algorithm looks like this:
while(head < tail){
while(head < hi && nums[head] < pivot) ++head;
while(nums[tail] > pivot) --tail;
if(head < tail){
swap(nums, head, tail);
++head;
--tail;
}
}
Outer loop that iterates until the indexes "cross" (or meet)
Two inner loops that iterate inwards, skipping elements that are already in the correct partition, to find two elements that are both in the wrong partition
One swap to simultaneously put two elements into their respective partitions
And how does Hoare's partition algorithm work, well, the same way really (from wikipedia):
loop forever
// Move the left index to the right at least once and while the element at
// the left index is less than the pivot
do i := i + 1 while A[i] < pivot
// Move the right index to the left at least once and while the element at
// the right index is greater than the pivot
do j := j - 1 while A[j] > pivot
// If the indices crossed, return
if i >= j then return j
// Swap the elements at the left and right indices
swap A[i] with A[j]
This uses an early-exit instead of a while-loop as the outer loop, and therefore doesn't need an if around the swap, but apart from such minor details, it is the same thing.
If it is expressed this way, as opposed to how it is expressed in this question, it is less reasonable to modify it to always return the pivot index (expressed this way, it is also much less obvious what guarantee it actually makes on its return value). With the variant found in this question, that sort of naturally falls out as a possible modification, as seen in trincots answer.
By contrast, the important part of Lomuto's partitioning algorithm works like this (also from wikipedia)
for j := lo to hi - 1 do
// If the current element is less than or equal to the pivot
if A[j] <= pivot then
// Move the temporary pivot index forward
i := i + 1
// Swap the current element with the element at the temporary pivot index
swap A[i] with A[j]
This is based on a totally different principle.
Following is a Hoare partitioning algorithm per Wikipedia.
Pseudo-code from Wikipedia:
algorithm partition(A, lo, hi) is
// Pivot value
pivot := A[ floor((hi + lo) / 2) ] // The value in the middle of the array
// Left index
i := lo - 1
// Right index
j := hi + 1
loop forever
// Move the left index to the right at least once and while the element at
// the left index is less than the pivot
do i := i + 1 while A[i] < pivot
// Move the right index to the left at least once and while the element at
// the right index is greater than the pivot
do j := j - 1 while A[j] > pivot
// If the indices crossed, return
if i ≥ j then return j
// Swap the elements at the left and right indices
swap A[i] with A[j]
A java implementation:
public class Main
{
public static void main(String[] args) {
int[] arr = new int[] { 2, 1, 2, 4, 3 };
Hoare.partition(arr, 0, 4);
for (int x : arr) System.out.println(x);
}
}
class Hoare
{
private static void Swap(int[] array, int i, int j)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
public static int partition(int []arr, int low, int high)
{
int pivot = arr[(low + high) / 2]; // pivot is 2 for this case.
// Expected out is:
// 1 2 2 3 4
// or
// 1 2 2 4 3
//
// Actual output is:
// 2 1 2 4 3
// Since 3 and 4 are greater than 2, then the partitioning isn't working.
int i = low - 1;
int j = high + 1;
while(true)
{
do {
i++;
}
while (arr[i] < pivot);
do {
j--;
}
while (arr[j] > pivot);
if (i >= j)
{
return j;
}
Swap(arr, i, j);
}
}
}
Why is the output wrong (indicated in code comments)? Is that a known limitation of Hoare algorithm? Is my implementation or Wikipedia's pseudocode is incorrect?
The Hoare algorithm guarantees that all elements before the pivot are less than or equal to the pivot value and all elements after the pivot are greater than or equal to the pivot value.
That also means that the pivot value is at the correct index in the final sorted array. That is important for the quicksort algorithm.
The Hoare partition does not guarantee that all elements equal to the pivot value are consecutive. That is not a requirement of the quicksort algorithm, so there is no point spending any additional computational power guaranteeing it.
In other words, the implementation is correct; the result is expected; and it will work in a quicksort without problems.
I'm trying to implement quicksort in Java to learn basic algorithms. I understand how the algo works (and can do it on paper) but am finding it hard to write it in code. I've managed to do step where we put all elements smaller than the pivot to the left, and larger ones to the right (see my code below). However, I can't figure out how to implement the recursion part of the algo, so sort the left and right sides recursively. Any help please?
public void int(A, p, q){
if(A.length == 0){ return; }
int pivot = A[q];
j = 0; k = 0;
for(int i = 0; i < A.length; i++){
if(A[i] <= pivot){
A[j] = A[i]; j++;
}
else{
A[k] = A[i]; k++;
}
}
A[j] = pivot;
}
Big Disclaimer: I did not write this piece of code, so upvotes is not needed. But I link to a tutorial which explains quicksort in detail. Gave me a much needed refreshment on the algorithm as well! The example given has very good comments that might just help you to wrap your head around it.
I suggest you adapt it to your code and write som tests for it to verify it works
Quicksort is a fast, recursive, non-stable sort algorithm which works by the divide and conquer principle. Quicksort will in the best case divide the array into almost two identical parts. It the array contains n elements then the first run will need O(n). Sorting the remaining two sub-arrays takes 2 O(n/2). This ends up in a performance of O(n log n).
In the worst case quicksort selects only one element in each iteration. So it is O(n) + O(n-1) + (On-2).. O(1) which is equal to O(n^2).*
public class Quicksort {
private int[] numbers;
private int number;
public void sort(int[] values) {
// check for empty or null array
if (values ==null || values.length==0){
return;
}
this.numbers = values;
number = values.length;
quicksort(0, number - 1);
}
private void quicksort(int low, int high) {
int i = low, j = high;
// Get the pivot element from the middle of the list
int pivot = numbers[low + (high-low)/2];
// Divide into two lists
while (i <= j) {
// If the current value from the left list is smaller than the pivot
// element then get the next element from the left list
while (numbers[i] < pivot) {
i++;
}
// If the current value from the right list is larger than the pivot
// element then get the next element from the right list
while (numbers[j] > pivot) {
j--;
}
// If we have found a value in the left list which is larger than
// the pivot element and if we have found a value in the right list
// which is smaller than the pivot element then we exchange the
// values.
// As we are done we can increase i and j
if (i <= j) {
exchange(i, j);
i++;
j--;
}
}
// This is the recursion part you had trouble with i guess?
// Recursion
if (low < j)
quicksort(low, j);
if (i < high)
quicksort(i, high);
}
private void exchange(int i, int j) {
int temp = numbers[i];
numbers[i] = numbers[j];
numbers[j] = temp;
}
}
Link to tutorial
I'm trying to sort this array:
[5 1 3 2 2 9 1]
I've ran the debugger and have been getting strange results. I put a break point on the line
merge(left, right);
and after the first pass these are the sub-arrays:
left = [1 3 5 2 2]
right = [9]
so I'm pretty sure the 'divide' part is where I'm going wrong. Can somebody have a look at my code and see if they can spot the error?
public int[] arrayToSort = { 5, 1, 3, 2, 2, 9, 1 };
...
private void mergeSort(int[] array, int low, int high) {
// Base case
if (!(high - low <= 1)) {
int mid = low + (high - low) / 2;
// Split array into sub-arrays
int[] left = new int[mid];
int[] right = new int[high - mid];
// Fill sub-arrays
for (int i = low; i < mid; i++) {
left[i - low] = array[i];
}
for (int i = mid; i < high; i++) {
right[i - mid] = array[i];
}
mergeSort(left, low, mid);
mergeSort(right, mid + 1, high);
merge(left, right);
} else {
return;
}
}
private void merge(int[] left, int[] right) {
int lLength = left.length;
int rLength = right.length;
// Pointer for left array
int i = 0;
// Pointer for right array
int j = 0;
// Pointer for merged array
int k = 0;
while (i < lLength && j < rLength) {
if (left[i] < right[j]) {
arrayToSort[k] = left[i];
i++;
} else {
arrayToSort[k] = right[j];
j++;
}
k++;
}
while (i < lLength) {
arrayToSort[k] = left[i];
i++;
k++;
}
while (j < rLength) {
arrayToSort[k] = right[j];
j++;
k++;
}
}
Appreciate any help!
edit: Noticed a mistake in my code (a parameter wasn't getting used) and modified it. Here is the error I get now (from the above code):
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
at Launcher.mergeSort(Launcher.java:43)
at Launcher.mergeSort(Launcher.java:49)
at Launcher.main(Launcher.java:21)
So it complains at the line
left[i - low] = array[i];
Just looking at the code, the second recursive call should be:
mergeSort(right, mid, high);
More space than is needed is allocated for left:
int[] left = new int[mid-low];
Merge() function needs a low parameter to know where to start the merge at (k = low, not k = 0).
I wonder why bottom up merge sort is rarely taught these days, as it's simpler to understand.
Can you spot the problem in this snippet? ->
int mid = low + (high - low) / 2;
int[] left = new int[mid];
int[] right = new int[high - mid];
// ...
mergeSort(left, low, mid);
mergeSort(right, mid + 1, high);
What about the size of left and right, and the indexes passed to the recursive call to mergeSort?
The indexes you pass, are indexes in the received array, not in left and right.
The problem is most obvious when you look at right. The index high will be inevitably always out of bounds.
The above would make more sense like this:
mergeSort(left, 0, left.length);
mergeSort(right, 0, high.length);
Now the indexes are correct. They are also pointless, because now they are simply the full range of the sub-arrays, and as such not needed at all. This weirdness is just a symptom of a deeper problem.
Keep in mind that merge must eventually update the original array. For that it needs the reference to the original array, and the left and right ranges. You are passing to merge the left and right sub-arrays. The reference to the original array and the indexes of the ranges are lost in your implementation.
Consider this:
int mid = low + (high - low) / 2;
mergeSort(array, low, mid);
mergeSort(array, mid + 1, high);
merge(array, low, mid, high);
Notice that:
the original array reference is preserved, as it's passed down to recursive calls
the indexes are valid indexes in the original array
there are no more sub-arrays here
Change your implementation of merge accordingly, to merge the specified ranges in the array, modifying that array. An easy way to do it is to merge the ranges into a work array of size high - low, and then copying from the merged work array back to the range in the original.
I was trying to solve following programming exercise from some java programming book
Write method that partitions the array using the first element, called a pivot. After the partition, the elements in the list are rearranged so that all the elements before the pivot are less than or equal to the pivot and the elements after the pivot are greater than the pivot. The method returns the index where the pivot is located in the new list. For example, suppose the list is {5, 2, 9, 3, 6, 8}. After the partition, the list becomes {3, 2, 5, 9, 6, 8}. Implement the method in a way that takes at most array.length comparisons.
I've implemented solution, but it takes much more than array.length comparisons.
The book itself has solution, but unfortunately it's just plain wrong (not working with some inputs). I've seen the answer to this similar question, and understood "conquer" part of Quicksort algorithm, but in this algorithm values are partitioned using mid-value, but in my case using of 1st array value as a pivot is required.
This is the pivot routine from the linked answer (adapted from 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;
}
The number of inter-element comparisons in this algorithm is either n or n+1; because in each main loop iteration, i and j move closer together by at exactly c units, where c is the number of comparisons performed in each of the inner while loops. Look at those inner loops - when they return true, i and j move closer by 1 unit. And if they return false, then, at the end of the main loop, i and j will move closer by 2 units because of the swap.
This split() is readable and short, but it also has a very bad worst-case (namely, the pivot ending at either end; follow the first link to see it worked out). This will happen if the array is already sorted either forwards or backwards, which is actually very frequent. That is why other pivot positions are better: if you choose x=a[lo+hi/2], worst-case will be less common. Even better is to do like Java, and spend some time looking for a good pivot to steer clear from the worst case. If you follow the Java link, you will see a much more sophisticated pivot routine that avoids doing extra work when there are many duplicate elements.
It seem that the algorithm (as taken from "Introduction to algorihtm 3rd ed") can be implemented as follows (C++) should be similar in Java`s generics:
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);
}
}
However, its a simple pseudocode implementation, I dont know if it`s the best pivot to pick from. Maybe (l+r)/2 would be more proper.
Pretty simple solution with deque:
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);
}
Output is:
2
3
5 <-- pivot
9
6
8
There is video that I made on Pivot based partition I explained both the methods of patitioning.
https://www.youtube.com/watch?v=356Bffvh1dA
And based on your(the other) approach
https://www.youtube.com/watch?v=Hs29iYlY6Q4
And for the code. This is a code I wrote for pivot being the first element and it takes O(n) Comparisons.
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);
}
}
The partition function below works as follow:
The last variable points to the last element in the array that has not been compared to the pivot element and can be swapped.
If the element directly next to the pivot element is less than the pivot
element. They are swapped.
Else if the pivot element is less than the next element, the nextelement is swapped with the element whose index is the last variable.
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;
}