Answers for "quick sort program in c"

2

quick sort program in c

``````#include<stdio.h>
void quicksort(int number[25],int first,int last){
int i, j, pivot, temp;

if(first<last){
pivot=first;
i=first;
j=last;

while(i<j){
while(number[i]<=number[pivot]&&i<last)
i++;
while(number[j]>number[pivot])
j--;
if(i<j){
temp=number[i];
number[i]=number[j];
number[j]=temp;
}
}

temp=number[pivot];
number[pivot]=number[j];
number[j]=temp;
quicksort(number,first,j-1);
quicksort(number,j+1,last);

}
}

int main(){
int i, count, number[25];

printf("How many elements are u going to enter?: ");
scanf("%d",&count);

printf("Enter %d elements: ", count);
for(i=0;i<count;i++)
scanf("%d",&number[i]);

quicksort(number,0,count-1);

printf("Order of Sorted elements: ");
for(i=0;i<count;i++)
printf(" %d",number[i]);

return 0;
}``````
Posted by: Guest on May-13-2020
1

Quick sort in C

``````// Quick sort in C

#include <stdio.h>

// function to swap elements
void swap(int *a, int *b) {
int t = *a;
*a = *b;
*b = t;
}

// function to find the partition position
int partition(int array[], int low, int high) {

// select the rightmost element as pivot
int pivot = array[high];

// pointer for greater element
int i = (low - 1);

// traverse each element of the array
// compare them with the pivot
for (int j = low; j < high; j++) {
if (array[j] <= pivot) {

// if element smaller than pivot is found
// swap it with the greater element pointed by i
i++;

// swap element at i with element at j
swap(&array[i], &array[j]);
}
}

// swap the pivot element with the greater element at i
swap(&array[i + 1], &array[high]);

// return the partition point
return (i + 1);
}

void quickSort(int array[], int low, int high) {
if (low < high) {

// find the pivot element such that
// elements smaller than pivot are on left of pivot
// elements greater than pivot are on right of pivot
int pi = partition(array, low, high);

// recursive call on the left of pivot
quickSort(array, low, pi - 1);

// recursive call on the right of pivot
quickSort(array, pi + 1, high);
}
}

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

// main function
int main() {
int data[] = {8, 7, 2, 1, 0, 9, 6};

int n = sizeof(data) / sizeof(data[0]);

printf("Unsorted Array\n");
printArray(data, n);

// perform quicksort on data
quickSort(data, 0, n - 1);

printf("Sorted array in ascending order: \n");
printArray(data, n);
}``````
Posted by: Guest on April-24-2021
1

quicksort in code

``````// A full c++ quicksort algorithm no bs
// quicksort in code

#include <iostream>

using namespace std;

void QuickSort(int arr[], int start, int end);
int Partition(int arr[], int start, int end);
void SwapArrMem(int arr[], int a, int b);

int main()
{

int arr[4]; //change the size of the array to your desired array size

cout << "enter " << sizeof(arr) / sizeof(arr[0]) << " numbers. press enter after input" << endl;

for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{

cin >> arr[i];
}

cout << endl << "The sorted numbers are:" << endl << endl;

QuickSort(arr, 0, sizeof(arr) / sizeof(arr[0]) - 1);

for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
cout << arr[i] << endl;
}

}

void QuickSort(int arr[], int start, int end)
{
if (start >= end) return;

int index = Partition(arr, start, end);
QuickSort(arr, start, index - 1);
QuickSort(arr, index + 1, end);
}

int Partition(int arr[], int start, int end)
{
int pivotindex = start;
int pivotvalue = arr[end];
for (int i = start; i < end; i++)
{
if (arr[i] < pivotvalue)
{
SwapArrMem(arr, i, pivotindex);
pivotindex++;
}
}
SwapArrMem(arr, pivotindex, end);
return pivotindex;
}

void SwapArrMem(int arr[], int a, int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}``````
Posted by: Guest on October-09-2020
0

quicksort in c

``````int cmpfunc (const void * a, const void * b) {
return ( *(int*)a - *(int*)b );
}``````
Posted by: Guest on October-11-2020