quick sort c++

Comment

0

/* 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: \n"; 
    printArray(arr, n); 
    return 0; 
} 

// This code is contributed by rathbhupendra

Popularity 9/10 Helpfulness 3/10 Language cpp

Source: www.geeksforgeeks.org

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on Jan 09 2022

Lucky Lobster

0 Answers Avg Quality 2/10

quick sort c++

Comment

3

#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]<<"\t"; 
      
} 
   
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; 
}

Popularity 9/10 Helpfulness 6/10 Language cpp

Source: Grepper

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on Dec 25 2021

abdelghani

0 Answers Avg Quality 2/10

c++ code for quicksort

Comment

3

#include<bits/stdc++.h>
using namespace std;
int partition(int a[],int low,int high)
{
    int pivot =a[high],i=low-1,j=low;
    for(j=low;j<=high-1;j++)
    {
        if(a[high]>=a[j])
        {
            i++;
            swap(a[i],a[j]);
        }
    }
    swap(a[i+1],a[high]);
    return i+1;
    
}
void quicksort(int a[],int low,int high)
{
    if(low<high)
    {
        int  t = partition(a,low,high);
        quicksort(a,low,t-1);
        quicksort(a,t+1,high);
    }
}
int main()
{
    //quick sort
    int a[8] = {3,10,8,51,92,6,2,1};
    quicksort(a,0,7);
    for(int i=0;i<8;i++)
    {
        cout<<a[i]<<" ";
    }
    
    return 0;
}

Popularity 9/10 Helpfulness 6/10 Language cpp

Source: Grepper

Tags: c++ quicksort qu

Share

Link to this answer
Share Copy Link

Contributed on Dec 26 2021

Eager Eagle

0 Answers Avg Quality 2/10

quick sort c+++

Comment

0

 
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);
}

Popularity 8/10 Helpfulness 4/10 Language cpp

Source: www.geeksforgeeks.org

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on Feb 19 2022

Jealous Jackal

0 Answers Avg Quality 2/10

quick sort c++

Comment

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);
	}
}

Popularity 8/10 Helpfulness 4/10 Language cpp

Source: www.stdio.vn

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on Jun 24 2022

Tiien

0 Answers Avg Quality 2/10

quick sort c++

Comment

1

#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]<<" ";
    }

}

Popularity 9/10 Helpfulness 4/10 Language cpp

Source: Grepper

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on Feb 04 2022

Red Team

0 Answers Avg Quality 2/10

quick sort c++

Comment

4

// 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;
}

Popularity 10/10 Helpfulness 3/10 Language cpp

Source: www.geeksforgeeks.org

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on Feb 25 2022

MASOOM AGARWAL

0 Answers Avg Quality 2/10

quick sort c++

Comment

0

#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;

}

Popularity 8/10 Helpfulness 3/10 Language cpp

Source: Grepper

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on May 30 2022

Lubna Amro

0 Answers Avg Quality 2/10

quick sort c++

Comment

0

#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;
 }

Popularity 8/10 Helpfulness 3/10 Language cpp

Source: Grepper

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on Aug 31 2022

Vishvajeet Singh Nayal 21BCE3732

0 Answers Avg Quality 2/10

c++ quick sort

Comment

0

#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;
}

Popularity 7/10 Helpfulness 3/10 Language csharp

Source: Grepper

Tags: c# c++

Share

Link to this answer
Share Copy Link

Contributed on Dec 17 2022

SDAlez

0 Answers Avg Quality 2/10

quick sort c++

Contents

More Related Answers

quick sort c++

Closely Related Answers

quick sort c++

c++ code for quicksort

quick sort c+++

quick sort c++

quick sort c++

quick sort c++

quick sort c++

quick sort c++

c++ quick sort

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.