Write an algorithm for quick sort?

Answer 1

#include <stdio.h>

#include <stdlib.h>

#define size 50

void swap(int *x,int *y)

{

int temp;

temp = *x;

*x = *y;

*y = temp;

}

int partition(int i,int j )

{

return((i+j) /2);

}

void quicksort(int list[],int m,int n)

{

int key,i,j,k;

if( m < n)

{

k = partition(m,n);

swap(&list[m],&list[k]);

key = list[m];

i = m+1;

j = n;

while(i <= j)

{

while((i <= n) && (list[i] <= key))

i++;

while((j >= m) && (list[j] > key))

j--;

if( i < j)

swap(&list[i],&list[j]);

}

// swap two elements

swap(&list[m],&list[j]);

// recursively sort the lesser list

quicksort(list,m,j-1);

quicksort(list,j+1,n);

}

}

void printlist(int list[],int n)

{

int i;

for(i=0;i<n;i++)

printf("%d\t",list[i]);

}

void main()

{

int n,i;

int list[size];

printf("How many numbers do you want to enter");

scanf("%d",&n);

printf("Enter the numbers you want to sort");

for(i=0;i<n;i++)

{

scanf("%d",&list[i]);

}

printf("The list before sorting is:\n");

printlist(list,n);

// sort the list using quicksort

quicksort(list,0,n-1);

// print the result

printf("The list after sorting using quicksort algorithm:\n");

printlist(list,n);

}

Answer 2

//Quick Sort Functions for Descending Order

// (2 Functions)

void quicksort(apvector &array, int top, int bottom)

{

// top = subscript of beginning of vector being considered

// bottom = subscript of end of vector being considered

// this process uses recursion - the process of calling itself

int middle;

if (top < bottom)

{

middle = partition(array, top, bottom);

quicksort(array, top, middle); // sort top partition

quicksort(array, middle+1, bottom); // sort bottom partition

}

return;

}

//Function to determine the partitions

// partitions the array and returns the middle index (subscript)

int partition(apvector &array, int top, int bottom)

{

int x = array[top];

int i = top - 1;

int j = bottom + 1;

int temp;

do

{

do

{

j - -;

}while (x >array[j]);

do

{

i++;

} while (x

if (i < j)

{

temp = array[i]; // switch elements at positions i and j

array[i] = array[j];

array[j] = temp;

}

}while (i < j);

return j; // returns middle index

}

Answer 3

If you mean sort the individual characters in a String:

{

String str; // the string to sort

char[] charArray = str.toCharArray();

java.util.Arrays.sort(charArray);

str = new String(charArray);

}

If you mean sort an array of Strings:

{

String[] strs; // the array of string to sort

java.util.Arrays.sort(strs);

} bubble sort technique. public class bubbleSort { public static void main(String a[]) { int i; int array[] = {12,9,4,99,120,1,3,10}; System.out.println("Values Before the sort:\n"); for(i = 0; i < array.length; i++) System.out.print( array[i]+" "); System.out.println(); bubble_srt(array, array.length); System.out.print("Values after the sort:\n"); for(i = 0; i a[j]){ t = a[j-1]; a[j-1]=a[j]; a[j]=t; } } } } }

Answer 4

Given an array, A, and the lower and upper bounds of a subarray within the array, sort the subarray:

1. If lower bound is not less than upper bound then exit. The subarray is sorted.

2. Pick a pivot value from the subarray at random

3. Swap the pivot value with the value located in the upper bound

4. Let left = lower bound

5. Let right = upper bound

6. Repeat while left<right

{

6.1. Increment left while left value is less than pivot value

6.2 Decrement right while right value is not less than pivot value

6.3. If left<right, swap left value with right value

}

7. Swap left value with upper bound value (the pivot)

8. Repeat algorithm using the current lower bound and left-1 as the upper bound

9. Repeat algorithm using the current upper bound and left+1 as the lower bound