Search
 
SCRIPT & CODE EXAMPLE
 

CPP

quick sort c++

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

c++ code for quicksort

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

quick sort c++

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

}
Comment

quick sort c+++

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

quick sort c++


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

}
Comment

quick sort c++

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

quick sort c++

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

quick sort c++

/* 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
Comment

quick sort c++

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

c++ quicksort

/* 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
    }
}
Comment
PREVIOUS NEXT
Code Example
Cpp :: c++ average 
Cpp :: sizeof’ on array function parameter ‘arr’ will return size of ‘int*’ [-Wsizeof-array-argument] 
Cpp :: C++ Vector Operation Add Element 
Cpp :: iterate through map c++ 
Cpp :: how to convert ascii to char in cpp 
Cpp :: how to set a variable to infinity in c++ 
Cpp :: c++ get line 
Cpp :: how to add external library in clion 
Cpp :: max in c++ 
Cpp :: how to play sounds in c++ 
Cpp :: erase element from vector c++ 
Cpp :: setw c++ 
Cpp :: find element in vector 
Cpp :: intersection.cpp 
Cpp :: how can we create 4 digit random number in c++ 
Cpp :: c++ compile to exe command line 
Cpp :: getline 
Cpp :: c++ find object in vector by attribute 
Cpp :: ++ how to write quotation mark in a string 
Cpp :: return array of string in function c++ 
Cpp :: C++ String Compare Example 
Cpp :: c++ function of find maximum value in an array 
Cpp :: iostream c++ 
Cpp :: print in c ++ 
Cpp :: uparam(ref) 
Cpp :: 1768. Merge Strings Alternately leetcode solution in c++ 
Cpp :: create a vector of size n in c++ 
Cpp :: three way comparison operator c++ 
Cpp :: c++ program to convert fahrenheit to celsius 
Cpp :: c++ catch Unhandled exception 
ADD CONTENT
Topic
Content
Source link
Name
9+1 =