Breaking News: Grepper is joining You.com. Read the official announcement!

quicksort algorithm

Add Answer

Hilarious Hyena answered on February 4, 2022 Popularity 10/10 Helpfulness 2/10

answer quicksort algorithm

related çeviri

related quick sort

related quicksort algorithm

related quick sort

related quicksort

related quick sort

related quicksort algorithm

quicksort algorithm

Comment

// in c++
#include<iostream>
#include<algorithm>
using namespace std;
int partition(int arr[], int low, int high){
    // i is used for determining the correct position of pivot element
    /*
      We can choose first element of the array as pivot element,
      or we can choose middle element/ last element / any element randomly as pivot element.
       In this program, we are using last element as pivot element.
    */
    int i = low -1;
    int pivot = arr[high];
    for(int j=low; j<= high-1; j++){
        if(arr[j] < pivot){
            i = i+1;
            // to do the swapping directly include "algorithms" library in the header, in c++
            swap(arr[i], arr[j]); 
        }
    }
    // put the pivot elements at its correct position
    swap(arr[i+1], arr[high]);
    return i+1;
}

void quickSort(int arr[], int low, int high){
    if(low < high){
    int pivot = partition(arr, low, high);
    quickSort(arr, low, pivot-1);
    quickSort(arr, pivot+1, high);
    }
}

// for printing the array
void printArray(int arr[], int n){
    for(int i=0; i<n; i++){
        cout<<arr[i]<<" " ;
    }
}
// main function

int main()
{
    int arr[100], pivot, low, high, n;
    cout<<"how many elements you want to put in the array"<<endl;
    cin>>n;
    cout<<endl;
    cout<<"insert elements in the  array"<<endl;
    for(int i =0; i<n; i++){
        cin>>arr[i];
    }
   
    cout<<"Array before Quick Sort"<<endl;
    printArray(arr, n);

     quickSort(arr, 0, n);

    cout<<endl;
    cout<<"Array after quick sort"<<endl;
    printArray(arr, n);

    return 0 ;

    
    
}

Popularity 10/10 Helpfulness 2/10 Language cpp

Source: Grepper

Tags: algorithm c++ quicksort

Link to this answer
Share Copy Link

Contributed on Jul 06 2022

Hilarious Hyena

0 Answers Avg Quality 2/10

Closely Related Answers

çeviri

Comment

Popularity 9/10 Helpfulness 3/10 Language whatever

Source: Grepper

Tags: whatever whateve

Link to this answer
Share Copy Link

Contributed on Feb 01 2023

Misty Mouse

0 Answers Avg Quality 2/10

çeviri

Comment

Come to tureng, brother.

Popularity 10/10 Helpfulness 2/10 Language whatever

Source: Grepper

Tags: translate tran

Link to this answer
Share Copy Link

Contributed on May 12 2022

Burak ÖVEÇ

0 Answers Avg Quality 2/10

quick sort

Comment

function swap(arr, leftIndex, rightIndex){
  // swap 2 elements in the array
    var temp = arr[leftIndex];
    arr[leftIndex] = arr[rightIndex];
    arr[rightIndex] = temp;
}
function partition(arr, left, right) {
    var pivot   = arr[Math.floor((right + left) / 2)], //middle element
        i       = left, //left pointer
        j       = right; //right pointer
    while (i <= j) { // while left pointer is smaller than right pointer
        while (arr[i] < pivot) { // move the left pointer to the right
            i++;
        }
        while (arr[j] > pivot) { // move the right pointer to the left
            j--;
        }
        if (i <= j) { //left pointer smaller or equal to right pointer
            swap(arr, i, j); //sawpping two elements
            i++;
            j--;
        }
    }
    return i;
}
// run as quickSort(array, 0, array.length - 1);
function quickSort(arr, left, right) {
    var index;
    if (arr.length > 1) {
        index = partition(arr, left, right); //index returned from partition
        if (left < index - 1) { //more elements on the left side of the pivot
            quickSort(arr, left, index - 1);
        }
        if (index < right) { //more elements on the right side of the pivot
            quickSort(arr, index, right);
        }
    }
    return arr;
}

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: sorting-algorithms.me

Tags: javascript j

Link to this answer
Share Copy Link

Contributed on Sep 13 2022

katanton reckless

0 Answers Avg Quality 2/10

quick sort

Comment

#https://github.com/paulnegz/sorts-py/blob/main/sort.py
def quick_sort(array :list)->list:
    def _quick_sort(array :list)->list:
        if len(array)<=1: return array
        
        pivot, is_bigger = array.pop(), lambda x: x>pivot
        left_partition = _quick_sort([x for x in array if not is_bigger(x)])
        right_partition = _quick_sort([x for x in array if is_bigger(x)])
        return [*left_partition, pivot, *right_partition]
    return _quick_sort(array)
  
arr = [7, 2, 4, 0, 1, 5, 8, 3, 2, 0]
print(quick_sort(arr)) # [0, 0, 1, 2, 2, 3, 4, 5, 7, 8]

Popularity 10/10 Helpfulness 2/10 Language python

Source: github.com

Tags: whatever whateve

Link to this answer
Share Copy Link

Contributed on Jun 25 2023

Paul Negedu

0 Answers Avg Quality 2/10

quicksort algorithm

Comment

Implementation of Quick Sort Algorithm in C:
# include <stdio.h>

// to swap two numbers
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];  // selecting last element as pivot
    int i = (low - 1);  // index of smaller element
 
    for (int j = low; j <= high- 1; j++)
    {
        // If the current element is smaller than or equal to 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);
}
/*  
    a[] is the array, p is starting index, that is 0, 
    and r is the last index of array.  
*/
void quicksort(int a[], int p, int r)    
{
    if(p < r)
    {
        int q;
        q = partition(a, p, r);
        quicksort(a, p, q-1);
        quicksort(a, q+1, r);
    }
}


// function to print the array
void printArray(int a[], int size)
{
    int i;
    for (i=0; i < size; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

int main()
{
    int arr[] = {9, 7, 5, 11, 12, 2, 14, 3, 10, 6};
    int n = sizeof(arr)/sizeof(arr[0]);
    
    // call quickSort function
    quicksort(arr, 0, n-1);
    
    printf("Sorted array: \n");
    printArray(arr, n);
    return 0;
}

Popularity 10/10 Helpfulness 2/10 Language cpp

Source: www.interviewbit.com

Tags: algorithm algo

Link to this answer
Share Copy Link

Contributed on Apr 27 2022

Magnificent Macaque

0 Answers Avg Quality 2/10

quick sort

Comment

  static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }  
  
  static int partition(int[] arr, int low, int high) { 
    
    int pivot = arr[high]; 
    // Index of smaller element and
    // indicates the right position
    // of pivot found so far
    int i = (low - 1); 
  
    for(int j = low; j <= high - 1; j++) {
      // If current element is smaller 
      // than the pivot
      if (arr[j] < pivot) {
        // Increment index of 
        // smaller element
        i++; 
        swap(arr, i, j);
      }
    }
    swap(arr, i + 1, high);
    return (i + 1);
  }
  
  static 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);
      }
  }

Popularity 10/10 Helpfulness 2/10 Language java

Source: Grepper

Tags: function functio

Link to this answer
Share Copy Link

Contributed on Sep 14 2022

Inexpensive Ibex

0 Answers Avg Quality 2/10

quicksort

Comment

# Python3 implementation of QuickSort  
  
  
# Function to find the partition position
def partition(array, low, high):
  
  # Choose the rightmost element as pivot
  pivot = array[high]
  
  # Pointer for greater element
  i = low - 1
  
  # Traverse through all elements
  # compare each element with pivot
  for j in range(low, high):
    if array[j] <= pivot:
      # If element smaller than pivot is found
      # swap it with the greater element pointed by i
      i = i + 1
  
      # Swapping element at i with element at j
      (array[i], array[j]) = (array[j], array[i])
  
  # Swap the pivot element with the greater element specified by i
  (array[i + 1], array[high]) = (array[high], array[i + 1])
  
  # Return the position from where partition is done
  return i + 1
  
# Function to perform quicksort
def quick_sort(array, low, high):
  if low < high:
  
    # Find pivot element such that
    # element smaller than pivot are on the left
    # element greater than pivot are on the right
    pi = partition(array, low, high)
  
    # Recursive call on the left of pivot
    quick_sort(array, low, pi - 1)
  
    # Recursive call on the right of pivot
    quick_sort(array, pi + 1, high)
  
    
          
# Driver code
array = [ 10, 7, 8, 9, 1, 5]
quick_sort(array, 0, len(array) - 1)
  
print(f'Sorted array: {array}')
      
# This code is contributed by Adnan Aliakbar

Popularity 10/10 Helpfulness 2/10 Language whatever

Source: www.geeksforgeeks.org

Tags: quicksort quic

Link to this answer
Share Copy Link

Contributed on Aug 04 2022

Lazy Locust

0 Answers Avg Quality 2/10

quick sort

Comment

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

print(quicksort([3,6,8,10,1,2,1]))
# Prints "[1, 1, 2, 3, 6, 8, 10]"

Popularity 10/10 Helpfulness 2/10 Language whatever

Source: cs231n.github.io

Tags: whatever whateve

Link to this answer
Share Copy Link

Contributed on Feb 04 2022

Purple Team

0 Answers Avg Quality 2/10

quicksort algorithm

Comment

Implementation of Quick Sort Algorithm in C:
# include <stdio.h>

// to swap two numbers
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];  // selecting last element as pivot
    int i = (low - 1);  // index of smaller element
 
    for (int j = low; j <= high- 1; j++)
    {
        // If the current element is smaller than or equal to 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);
}
/*  
    a[] is the array, p is starting index, that is 0, 
    and r is the last index of array.  
*/
void quicksort(int a[], int p, int r)    
{
    if(p < r)
    {
        int q;
        q = partition(a, p, r);
        quicksort(a, p, q-1);
        quicksort(a, q+1, r);
    }
}


// function to print the array
void printArray(int a[], int size)
{
    int i;
    for (i=0; i < size; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

int main()
{
    int arr[] = {9, 7, 5, 11, 12, 2, 14, 3, 10, 6};
    int n = sizeof(arr)/sizeof(arr[0]);
    
    // call quickSort function
    quicksort(arr, 0, n-1);
    
    printf("Sorted array: \n");
    printArray(arr, n);
    return 0;
}

Popularity 10/10 Helpfulness 1/10 Language cpp

Source: www.interviewbit.com

Tags: algorithm algo

Link to this answer
Share Copy Link

Contributed on Apr 27 2022

Magnificent Macaque

0 Answers Avg Quality 2/10

quicksort algorithm

Contents

More Related Answers

quicksort algorithm

Closely Related Answers

çeviri

çeviri

quick sort

quick sort

quicksort algorithm

quick sort

quicksort

quick sort

quicksort algorithm

Grepper

Documentation

Social

Legal

Contact

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