System Programming

1. K.K. WAGH POLYTECHNIC,
NASHIK-03
DEPARTMENT OF COMPUTER
TECHNOLOGY(Second Shift)
Demonstration of
Address Calculation
Sort

2. 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

3. Example of Bucket Sort
The 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.

4. 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

5. 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]);
}

6. 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

7. 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

8. 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.

9. Radix Sort
Radix 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:

10. Example of LSD-Radix Sort
12 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
44
34
12
42
32
41
11
0 1 2 3 4 5 6 7 8 9
5087 77
77
50 87 58
58
08
0842

11. 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
34
41
42
44
When we collect them, they are in order.
12 42 444111 3223 34
12 42 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

12. #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;
}

13. 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++;
}
}

14. 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("%dt", sorted[j]);
} printf("n");
}
getch() ;
}

15.  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

16. 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

17. Example:
25 57 48 37 12 92 86 33
Let us create 10 subfiles (linked lists). Initially each of
these subfiles is empty.
Key.
Address Calculation Sort
0
1
2
3
4
5
6
7
8
9

18. 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
0
1
2
3
4
5
6
7
8
9
25
57
48
33
12
92
86
37

19. 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

20. Thank You