Question

Radix sort Come up with an unsorted array of numbers (integer array). Sort the numbers in ascending order and descending order and display them using radix sort. First sort in ascending, then reset the array to its original order and finally sort the array again in descending order. (Write a C# program)

Answer 1

Radix Sort Algorithm

Radix sort is one of the arranging calculations used to sort a rundown of number numbers all together. In radix sort calculation, a rundown of number numbers will be arranged dependent on the digits of individual numbers. Arranging is performed from least noteworthy digit to the most huge digit.

Radix sort calculation requires the quantity of passes which are equivalent to the quantity of digits present in the biggest number among the rundown of numbers. For instance, in the event that the biggest number is a 3 digit number, at that point that rundown is arranged with 3 passes.

Bit by bit Process

The Radix sort calculation is performed utilizing the accompanying advances...

Stage 1 - Define 10 lines each speaking to a can for every digit from 0 to 9.

Stage 2 - Consider the most un-noteworthy digit of each number in the rundown which is to be arranged.

Stage 3 - Insert each number into their separate line dependent on the most un-huge digit.

Stage 4 - Group all the numbers from line 0 to line 9 in the request they have embedded into their separate lines.

Stage 5 - Repeat from stage 3 dependent on the following least noteworthy digit.

Stage 6 - Repeat from stage 2 until all the numbers are gathered dependent on the most huge digit.

Radix sort fuses the checking sort calculation so it can sort bigger, multi-digit numbers without having to conceivably diminish the productivity by expanding the scope of keys the calculation must sort over (since this may cause a great deal of sat around idly).

• 

Complexity of the Radix Sort Algorithm

To sort an unsorted list with 'n' number of elements, Radix sort algorithm needs the following complexities...

Worst Case : O(n)
Best Case : O(n)
Average Case : O(n)

ascending

void RadixSort (int a[], int n)

{

int I, m=0, exp=1, b[MAX];

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

{

on the off chance that (a[i]>m)

m=a[i];

}

while (m/exp>0)

{

int bucket[10]={0};

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

bucket[a[i]/exp%10]++;

for (i=1; i<10; i++)

bucket[i]+=bucket[i-1];

for (i=n-1; i>=0; I- - )

b[- - bucket[a[i]/exp%10]]=a[i];

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

a[i]=b[i];

}

exp*=10;

}

}

/desc

void RadixSort (int a[], int n){

int I, m=0, exp=1, b[MAX];

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

on the off chance that (a[i]>m)

m=a[i];

while (m/exp>0)

{

int bucket[10]={0};

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

bucket[9-a[i]/exp%10]++; /changed this line

for (i=1; i<10; i++)

bucket[i]+=bucket[i-1];

for (i=n-1; i>=0; I- - )

b[- - bucket[9-a[i]/exp%10]]=a[i];/changed this line

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

a[i]=b[i]; /changed this line

}

exp*=10;

}

}