Concepts of Algorithms CSC-244 Unit 11 & 12 Sorting (Radix Sort) Shahid Iqbal Lone Computer College Qassim University K.S.A.

CSC 244 Concepts of Algorithms2 Radix Sort Radix Sort is a clever and little sorting algorithm. Radix Sort puts the elements in order by using the digits of the numbers/values. This sort is unusual because it does not directly compare any of the elements We instead create a set of buckets and repeatedly separate the elements into the buckets On each pass, we look at a different part of the elements

Radix Sort Assuming decimal elements and 10 buckets, we would put the elements into the bucket associated with its units digit The buckets are actually queues so the elements are added at the end of the bucket At the end of the pass, the buckets are combined in increasing order I will explain it with an example on next slid. CENG 213 Data Structures3

Radix Sort (Continued) 4CSC 244 Concepts of Algorithms Consider the following 9 numbers/values: We should start sorting by comparing and ordering the one's digits:

Radix Sort (Continued) CSC 244 Concepts of Algorithms 5 Notice that the numbers were added onto the list in the order that they were found, which is why the numbers appear to be unsorted in each of the bucket above. Now, we gather the buckets (in order from the 0 bucket to the 9 bucket) into the main list again: Note: The order in which we divide and reassemble the list is extremely important, as this is one of the foundations of this algorithm.

Radix Sort (Continued) 6CSC 244 Concepts of Algorithms Now, the buckets are created again, this time based on the ten's digit:

Radix Sort (Continued) 7 Now the sublists are gathered in order from 0 to 9: Finally, the sublists are created according to the hundred's digit: CSC 244 Concepts of Algorithms

Radix Sort (Continued) At last, the list is gathered up again: And now we have a fully sorted array! Radix Sort is very simple, and a computer can do it fast. When it is programmed properly, Radix Sort is in fact one of the fastest sorting algorithms for numbers or strings of letters. 8 CSC 244 Concepts of Algorithms

Radix Sort Algorithm Let ‘A’ is Linear Array and N is the number of values stored in A and R is the Radix/Base (10) of Number System. For the processing requirement, I am using a two-dimensional array i.e. C[100][10], where 100 are the pockets in every bucket and 10 are the buckets. Here a recursive function is going to use for RADIX SORT. Here A, N and C will be global entities. 9 CSC 244 Concepts of Algorithms

Radix Sort Algorithm (Continued) 10 CSC 244 Concepts of Algorithms

C-Language Code for Recursive Radix Sort 11 CSC 244 Concepts of Algorithms // C++ Code (RADIX SORT): #include int const MAX = 100; int A[MAX]; // Two dimensional array, where each row has ten columns int C[MAX][10]; int N; // Function Prototyping void get_Values(); void RadixSort (int); void display( ); int main() { get_Values(); if(N>1) RadixSort (10); // Here 10 is the Radix of Decimal Numbers display(); cout<<endl<<endl; return 0; }

C-Language Code for Recursive Radix Sort void get_Values() { cout "; cin>>N; cout<<"\n Put "<<N<<" Values..\n"; for(int I=0 ;I >A[I]; } void display() { cout<<"\n\n\t\t\t Sorted List\n\n"; for(int I =0;I < N ; I++) cout<<A[I]<<"\t"; } 12 CSC 244 Concepts of Algorithms void RadixSort (int R) { int I, J, X, D, Flag=0, p = -1; D=R/10; for(I=0;I<N;I++) {for(J=0 ;J < 10 ;J++) C[I][J] = -1; } for(I=0;I<N ; I++) { X=A[I]%R; int M=X/D; if( M > 0) Flag = 1; C[I][M]=A[I]; } for(J=0 ; J< 10 ; J++) { for( I=0 ; I < N ; I++) { if(C[I][J] != -1) { p++; A[p]=C[I][J]; } if(Flag == 1) { RadixSort(R*10); // recursive call } } // end of RadixSort( ) function

Radix sort: another way Using o Queue ADT Sorting methods which utilize digital properties of the numbers (keys) in the sorting process are called radix sorts. Example. Consider the list Step 1: ordering wrt ones Step 2: ordering wrt tens Step 3: ordering wrt hundreds After step 1: After step 2: After step 3: CSC 244 Concepts of Algorithms

Radix sort: using Queue ADT the algorithm Consider the following data structures: – a queue for storing the original list and lists resulting from collecting piles at the end of each step (call these master lists); – ten queues for storing piles 0 to 9; Pseudo code description of radix sort at the “idea” level: start with the one’s digit; while there is still a digit on which to classify data do { for each number in the master list do { add that number to the appropriate sublist } for each sublist do { for each number from the sublist do { remove the number from the sublist and append it to a newly arranged master list } advance the current digit one place to the left } 14 CSC 244 Concepts of Algorithms

Radix Sort: using Queue the algorithm (cont.) Here is a more detailed pseudo code description of the radix sort: Input: A queue Q of N items Output: Q sorted in ascending order Algorithm RadixSort (Q, N): digit := 1 while StillNotZero (digit) do { for (i := 1 to 10) do { create (sublist[i]) } while (! empty Q) do { dequeue (Q, item) pile := getPile (item, digit) + 1 O(N) enqueue (sublist[pile], item) swaps this outer loop will execute } “digit” times reinitialize (Q) for (j :=1 to 10) do { while (! empty sublist(j)) do { dequeue (sublist[j], item) O(N) enqueue (Q, item) } swaps } digit := digit * 10 } 15 CSC 244 Concepts of Algorithms

Efficiency of the Radix Sort Operations that affects the efficiency of radix sort the most are “dequeue- enqueue” swaps from and to the master list. Because the outer while-loop executes C times, and each of the inner loops is O(N), the total efficiency of radix sort is O(C*N). Notes: 1. If no duplicates are allowed in the list, we have log 10 N <= C for non-negative integers. 2. If there is a limit on the number of digits in the integers being sorted, we have C <= H * log 10 N. Therefore, radix sort is O(N * log N) algorithm if unique values are sorted; otherwise it is O(N) algorithm with a constant of proportionality, C, which can be large enough to make C * N > N * logN even for large N. A disadvantage of radix sort is that it required a large amount of memory to keep all of the sub-lists and the master list at the same time. 16 CSC 244 Concepts of Algorithms

About the getPile method The getPile method must return an appropriate isolated digit from the number currently considered. That digit + 1 yields the sublist, where the number is to be enqueued. A possible implementation of the getPile method is the following: int getPile (int number, int digit) { return (number % (10 * digit) / digit); } Examples: number = 1234 digit = 100 (1234 % 1000) / 100 = 2 number = digit = 1 (12345 % 10) / 1 = 5 17 CSC 244 Concepts of Algorithms

END 18 CSC 244 Concepts of Algorithms