K.K. WAGH POLYTECHNIC, NASHIK-03

DEPARTMENT OF COMPUTER TECHNOLOGY(Second Shift)

Demonstration of

Address Calculation Sort

Bucket sort, or bin sort, is a distribution sorting algorithm.

It is a stable sort, where the relative order of any two items with the same key is preserved.

It works in the following way: set up m buckets where each bucket is responsible for

an equal portion of the range of keys in the array. place items in appropriate buckets. sort items in each non-empty bucket using insertion

sort. concatenate sorted lists of items from buckets to get

final sorted order.

Analysis of running time of Bucket sort: Best Case Complexity: O(n logn) Worst Case Complexity: O(n2)

Bucket Sort

Example of Bucket SortThe example uses an input array of 9 elements. Key values are in the range from 10 to 19. It uses an auxiliary array of linked lists which is used as buckets.Items are placed in appropriate buckets and links are maintained to point to the next element. Order of the two keys with value 15 is maintained after sorting.

n ← length [A] For i = 1 to n do Insert A[i] into list B[nA[i]] For i = 0 to n-1 do Sort list B with Insertion sort Concatenate the lists B[0], B[1], . . B[n-

1] together in order.

Algorithm of Bucket Sort

Program for Bucket Sort#include<stdio.h>void Bucket_Sort(int array[], int n){

int i, j,k;int count[10][50];for(i=0; i < 10; i++){

for(j=0;j<50;j++)count[i][j] = 0;

}for(i=0,j=0; i < n; i++){ k=array[i]/10;

j++;count[k][j]=array[i];printf("\ncount[%d][%d]=%d",k,j,array[i]);

}

for(i=0,j=0,k=0; i < n; i++){

for(j=0;j<50;j++){

if(count[i][j]>0)array[k++] = count[i][j];

}}

}

int main(){

int array[100]; int num; int i;clrscr();printf("Enter How many Numbers : ");scanf("%d",&num);

Program for Bucket Sort

printf("Enter the %d elements to be sorted:\n",num);for(i = 0; i < num; i++ ){

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

printf("\nThe array of elements before sorting : \n");for (i = 0;i < num;i++){

printf("%d ", array[i]);}printf("\nThe array of elements after sorting :\n");Bucket_Sort(array, num); for (i = 0;i < num;i++){ printf("%d ", array[i]);}return 0;

}

Program for Bucket Sort

Radix Sort

Radix is the base of a number system or logarithm.

Radix sort is a multiple pass distribution sort. It distributes each item to a bucket according

to part of the item's key. After each pass, items are collected from the

buckets, keeping the items in order, then redistributed according to the next most significant part of the key.

This sorts keys digit-by-digit (hence referred to as digital sort), or, if the keys are strings that we want to sort alphabetically, it sorts character-by-character.

Radix sort uses bucket or count sort as the stable sorting algorithm, where the initial relative order of equal keys is unchanged.

Radix SortRadix sort is classified based on how it works internally:

least significant digit (LSD) radix sort: Processing starts from the least significant

digit and moves towards the most significant digit.

Most significant digit (MSD) radix sort: Processing starts from the most significant

digit and moves towards the least significant digit. This is recursive. It works in the following way:

Example of LSD-Radix Sort

3212 44 41 34 11 32 23

Input is an array of 15 integers. For integers, the number of buckets is 10, from 0 to 9. The first pass distributes the keys into buckets by the least significant digit (LSD). When the first pass is done, we have the following.

23 34

44

34

12

42

32

32

41

11

0 1 2 3 4 5 6 7 8 9

5087 77

77

50 87 58

58

08

084234

Example of LSD-Radix Sort…contd

50

We collect these, keeping their relative order:

Now we distribute by the next most significant digit, which is the highest digit in our example, and we get the following.

11

12

23 32

32

34

34

41

42

44

When we collect them, they are in order.

12 34 4232 444111 3223 34

12 3442 32 4441 3411 32 23 77 58 08

0 1 2 3 4 5 6 7 8 9

50 877708

08 50 77 87

58

58

87

#include <conio.h> #include <stdio.h>void main() { int unsorted[50] , bucket[10][50]={{0}} , sorted[50] ;int j , k , m , p , flag = 0, num, N;clrscr();

printf("\nEnter the number of elements to be sorted :");scanf("%d",&N);

printf("\nEnter the elements to be sorted :\n"); for(k=0 ; k < N ; k++){ scanf("\n%d",&num); sorted[k] = unsorted[k] = num;}

for(p=1; flag != N ; p*=10){ flag = 0; for(k=0;k<N;k++) { printf("\n flag=%d",flag); bucket[(sorted[k]/p)%10][k] = sorted[k]; printf("\n position of element=%d %d",((sorted[k]/p)%10),k); printf("\n element value=%d",bucket[(sorted[k]/p)%10][k]); if ( (sorted[k]/p)%10 == 0 )

{ flag++;}

}

for(j=0,m=0;j<10;j++) {

for(k=0;k<N;k++) { if( bucket[j][k] > 0 )

{ sorted[m] = bucket[j][k]; bucket[j][k] = 0 ; m++;}

} } } if (flag == N) {

printf("\nSorted List: \n");for(j=0 ; j < N ; j++) { printf("%d\t", sorted[j]); } printf("\n");

} getch() ;}

This can be one of the fastest types of distributive sorting technique if enough space is available also called as Hashing.

In this algorithm, a hash function is used and applied to each element in the list. The result of the hash function is placed in to an address in the table that represents the key.

Linked lists are used as address table for storing keys.(if there are 4 keys then 4 linked lists are used).

The hash function places the elements in linked lists are called as sub files. An item is placed into a sub-file in correct sequence by using any sorting method. After all the elements are placed into subfiles, the lists (subfies)are concatenated to produce the sorted list.

Address Calculation Sort

Procedure:1. In this method a hash function f is applied to

each key.

2. The result of this function determines into which of the several subfiles the record is to be placed.

The function should have the property that: if x <= y , f (x) <= f (y), Such a function is called order preserving.

3. An item is placed into a subfile in correct sequence by using any sorting method – simple insertion is often used.

4. After all the elements are placed into subfiles, the lists (subfiles) are concatenated to produce the sorted list.

Address Calculation Sort

Example:25 57 48 37 12 92 86

33Let us create 10 subfiles (linked lists). Initially

each of these subfiles is empty.

Key.

Address Calculation Sort

01

23

4

5

67

8

9

Example:The number is passed to hash function, which

returns its last digit (ten’s place digit), which is placed at that position only, in the linked lists.

num= 25 - f(25) gives 2

57 - f(57) gives 5

48 - f(48) gives 4

37 - f(37) gives 3

12 - f(12) gives 1

92 - f(92) gives 9

86 - f(86) gives 8

33 - f(33) gives 3 which is repeated.

Address Calculation Sort

01

23

4

5

67

8

9

25

57

4833

12

92

86

37

Example:After concatenating all linked list we get the

sorted list.

12 25 33 37 48 57 86 92

Efficiency: If all the elements (n) are uniformly distributed over m subfiles then n/m is approximately 1, time of the sort is near O(n).

On the other hand if maximum elements accommodate in one or two subfiles, then n/m is much larger significant work is required to insert element into proper subfile at its proper position and efficiency is O(n2).

Address Calculation Sort

Thank You