#include <iostream>
using namespace std;
// Swap two elements - Utility function
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
// partition the array using last element as pivot
int partition (int arr[], int low, int high)
{
int pivot = arr[high]; // pivot
int i = (low - 1);
for (int j = low; j <= high- 1; j++)
{
//if current element is smaller than pivot, increment the low element
//swap elements at i and j
if (arr[j] <= pivot)
{
i++; // increment index of smaller element
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
//quicksort algorithm
void quickSort(int arr[], int low, int high)
{
if (low < high)
{
//partition the array
int pivot = partition(arr, low, high);
//sort the sub arrays independently
quickSort(arr, low, pivot - 1);
quickSort(arr, pivot + 1, high);
}
}
void displayArray(int arr[], int size)
{
int i;
for (i=0; i < size; i++)
cout<<arr[i]<<" ";
}
int main()
{
int arr[] = {12,23,3,43,51,35,19,45};
int n = sizeof(arr)/sizeof(arr[0]);
cout<<"Input array"<<endl;
displayArray(arr,n);
cout<<endl;
quickSort(arr, 0, n-1);
cout<<"Array sorted with quick sort"<<endl;
displayArray(arr,n);
return 0;
}
#include<iostream>
using namespace std;
int solve(int arr[], int s, int e, int &pivotIndex)
{
int i=s,j=e;
while(i<pivotIndex && j>pivotIndex)
{
while(arr[i]<=arr[pivotIndex])
{
i++;
}
while(arr[j]>arr[pivotIndex])
{
j--;
}
if(i<pivotIndex && j>pivotIndex)
{
swap(arr[i++],arr[j--]);
}
}
}
int partition(int arr[], int s, int e)
{
int count=0;
int pivot = arr[s];
for(int i=s+1;i<=e;i++)
{
if(arr[i]<=pivot)
{
count++;
}
}
int pivotIndex = s + count;
swap(arr[pivotIndex], arr[s]);
return solve(arr,s,e,pivotIndex);
/* Or we can do same here no need to call function
int i=s,j=e;
while(i<pivotIndex && j>pivotIndex)
{
while(arr[i]<=arr[pivotIndex])
{
i++;
}
while(arr[j]>arr[pivotIndex])
{
j--;
}
if(i<pivotIndex && j>pivotIndex)
{
swap(arr[i++],arr[j--]);
}
}
return pivotIndex;
*/
}
void helper(int arr[], int s, int e)
{
if(s>=e)
{
return;
}
// partition of array
int p = partition(arr,s,e);
// sorting left part
helper(arr,s,p-1);
// sorting right part
helper(arr,p+1,e);
}
void quickSort(int input[], int size) {
helper(input,0,size-1);
}
int main()
{
int size = 6;
int input[1000] = {5,6,0,9,1,4};
quickSort(input,size);
for(int i=0;i<size;i++)
{
cout<<input[i]<<" ";
}
}
int partition(int arr[], int start, int end)
{
int pivot = arr[start];
int count = 0;
for (int i = start + 1; i <= end; i++) {
if (arr[i] <= pivot)
count++;
}
// Giving pivot element its correct position
int pivotIndex = start + count;
swap(arr[pivotIndex], arr[start]);
// Sorting left and right parts of the pivot element
int i = start, j = end;
while (i < pivotIndex && j > pivotIndex) {
while (arr[i] <= pivot) {
i++;
}
while (arr[j] > pivot) {
j--;
}
if (i < pivotIndex && j > pivotIndex) {
swap(arr[i++], arr[j--]);
}
}
return pivotIndex;
}
void quickSort(int arr[], int start, int end)
{
// base case
if (start >= end)
return;
// partitioning the array
int p = partition(arr, start, end);
// Sorting the left part
quickSort(arr, start, p - 1);
// Sorting the right part
quickSort(arr, p + 1, end);
}
#include <iostream>
using namespace std;
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
int partition (int arr[], int low, int high)
{
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high - 1; j++)
{
if (arr[j] < pivot)
{
i++;
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
void quickSort(int arr[], int low, int high)
{
if (low < high)
{
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
int main()
{
int arr[] = {11,678,9835,5,8,0};
int arr2[] = {7,9,0,1,-4,8,6};
int n = sizeof(arr) / sizeof(arr[0]);
quickSort(arr, 0, n - 1);
printArray(arr, n);
int n2 = sizeof(arr2) / sizeof(arr2[0]);
quickSort(arr2, 0, n2 - 1);
printArray(arr2, n2);
return 0;
}
// C++ Implementation of the Quick Sort Algorithm.
#include <iostream>
using namespace std;
int partition(int arr[], int start, int end)
{
int pivot = arr[start];
int count = 0;
for (int i = start + 1; i <= end; i++) {
if (arr[i] <= pivot)
count++;
}
// Giving pivot element its correct position
int pivotIndex = start + count;
swap(arr[pivotIndex], arr[start]);
// Sorting left and right parts of the pivot element
int i = start, j = end;
while (i < pivotIndex && j > pivotIndex) {
while (arr[i] <= pivot) {
i++;
}
while (arr[j] > pivot) {
j--;
}
if (i < pivotIndex && j > pivotIndex) {
swap(arr[i++], arr[j--]);
}
}
return pivotIndex;
}
void quickSort(int arr[], int start, int end)
{
// base case
if (start >= end)
return;
// partitioning the array
int p = partition(arr, start, end);
// Sorting the left part
quickSort(arr, start, p - 1);
// Sorting the right part
quickSort(arr, p + 1, end);
}
int main()
{
int arr[] = { 9, 3, 4, 2, 1, 8 };
int n = 6;
quickSort(arr, 0, n - 1);
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
return 0;
}
void quicksort(int a[], int l, int r)
{
if (l <= r)
{
int pivot = a[(l + r)/2];
int i = l, j = r;
while (i <= j)
{
//if u wanna sort from high to low
//change a[i] > pivot
// a[j] < pivot
while (a[i] < pivot)
i++;
while (a[j] > pivot)
j--;
if (i <= j)
swap(a[i++], a[j--]);
}
if (l < j)
quicksort(a, l, j);
if (r > i)
quicksort(a, i, r);
}
}
/* C++ implementation of QuickSort */
#include <bits/stdc++.h>
using namespace std;
// A utility function to swap two elements
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
/* This function takes last element as pivot, places
the pivot element at its correct position in sorted
array, and places all smaller (smaller than pivot)
to left of pivot and all greater elements to right
of pivot */
int partition (int arr[], int low, int high)
{
int pivot = arr[high]; // pivot
int i = (low - 1); // Index of smaller element and indicates the right position of pivot found so far
for (int j = low; j <= high - 1; j++)
{
// If current element is smaller than the pivot
if (arr[j] < pivot)
{
i++; // increment index of smaller element
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
/* The main function that implements QuickSort
arr[] --> Array to be sorted,
low --> Starting index,
high --> Ending index */
void quickSort(int arr[], int low, int high)
{
if (low < high)
{
/* pi is partitioning index, arr[p] is now
at right place */
int pi = partition(arr, low, high);
// Separately sort elements before
// partition and after partition
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
/* Function to print an array */
void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
// Driver Code
int main()
{
int arr[] = {10, 7, 8, 9, 1, 5};
int n = sizeof(arr) / sizeof(arr[0]);
quickSort(arr, 0, n - 1);
cout << "Sorted array:
";
printArray(arr, n);
return 0;
}
// This code is contributed by rathbhupendra
#include<iostream>
using namespace std;
void swap(int j , int k)
{
int temp;
temp = j;
j = k;
k = temp;
}
int partition(int arr[] , int s , int e)
{
int pivot = arr[e]; // last element as pivot
int pindex = s; // initially 0
for(int i=s ; i<e; i++)
{
if(arr[i]<pivot)
{
int temp = arr[i];
arr[i] = arr[pindex];
arr[pindex] = temp;
pindex++;
}
}
int temp = arr[e];
arr[e] = arr[pindex];
arr[pindex] = temp;
return pindex;
}
void QuickSort(int arr[] , int s , int e )
{
if(s<e)
{
int p = partition(arr , s , e );
QuickSort(arr , s , (p-1) ) ;
QuickSort(arr , (p+1) , e );
}
}
int main()
{
int i,n;
cout<<" enter the number of elements in the array :"<<endl;
cin>>n;
int a[n];
cout<<" enter the elements of the array :"<<endl;
for(i=0; i<n; i++)
{
cin>>a[i];
}
QuickSort(a , 0 , n-1);
cout<< " sorted array :"<<endl;
for(i=0; i<n; i++)
{
cout<<a[i]<<endl;
}
return 0;
}
/* low --> Starting index, high --> Ending index */
quickSort(arr[], low, high)
{
if (low < high)
{
/* pi is partitioning index, arr[p] is now
at right place */
pi = partition(arr, low, high);
quickSort(arr, low, pi - 1); // Before pi
quickSort(arr, pi + 1, high); // After pi
}
}