This is a seminar presentation on "SORTING" for Semester 2 exam at St. Xavier's College.The power point presenation deals with the requirement of sorting in our life,types of sorting techniques,code for implementing them,the time and space complexity of different sorting algorithms,the applications of sorting,its use in the industry and its future scope.The slide show contains .gif files which can't be seen here.For more details or any queries send me a mail at agmajumder@gmail.com

1. SORTINGSORTING
Presented By - Ashin Guha Majumder
(Roll 551)

2. Sorting means arranging
elements of an array so
that they are placed in
some relevant order
which may either be
ascending or descending.
This order can be
numeric, lexicographic or
any other user defined
type.

3. An internal sort is any
data sorting process that
takes place entirely
within the main
memory of a computer.
This is possible
whenever the data to be
sorted is small enough
to all be held in the main
memory.
External sorting is
required when the data
being sorted do not fit
into the main memory of
a computing device
(usually RAM) and
instead they must reside
in the slower external
memory (usually a hard
drive).

4. What is Sorting ?
• How do we find the people who most
like us on … Amazon, Netflix,
Facebook..……Need a metric for
analyzing closeness/nearness - Need to
find people "close", sorting helps
• How does Google find matching web
pages?
• How does SoundCloud find your song?
• How does instagram find your image?
• Sorting to the rescue !

5. Sorting in General
• How do you search in a "real"
dictionary?
• How would a DICTIONARY be which
is not arranged in alphabetical order ?
• Oxford English Dictionary contains
full entries for 171,476 words in
current use
• No sequence – you might find the
required word in the first page(Best
Case) / an intermediate page(Average
Case) / the last page(Worst Case)
• Time required would be huge. So
definitely an arranged order would
help a lot !
• Hence we need sorting especially for
asymptotic amounts of data!
Workers sorting parcels in a postal facility
Workers sorting parcels in a postal
facility
A railroad classification yard, used
for sorting freight cars

7. Theory of the Asymptotic Notation

10. Radix sort is a non-comparative integer sorting algorithm
that sorts data with integer keys by grouping
keys by the individual digits which share
the same sigRadix sort is a
non-comparative integer sorting algorithm
that sorts data with integer keys by grouping
keys by the individual digits which share
the same significant position and value.
A positional notation is required,
but because integers can represent
strings of characters (e.g., names or dates)
and specially
formatted floating point numbers,
radix sort is not limited to integers.

11. 12 58 37 64 52 36 99 63 18 9 20 88 47
20
12
52 63 64 36
37
47
58
18
88
9
99
20 12 52 63 64 36 37 47 58 18 88 9 99

12. 9 12 18 20 36 37 47 52 58 63 64 88 99
9
12
18 20
36
37 47
52
58
63
64 99
20 12 52 63 64 36 37 47 58 18 88 9 99
88

13. 12 58 37 64 52 36 99 63 18 9 20 88 47
20 12 52 63 64 36 37 47 58 18 88 9 99
9 12 18 20 36 37 47 52 58 63 64 88 99
sort by rightmost digit
sort by leftmost digit

14. #include<stdio.h>
#include<conio.h>
radix_sort(int array[], int n);
void main()
{
int array[100],n,i;
clrscr();
printf("Enter the number of elements to
be sorted: ");
scanf("%d",&n);
printf("nEnter the elements to be
sorted: n");
for(i = 0 ; i < n ; i++ )
{
printf("tArray[%d] = ",i);
scanf("%d",&array[i]);
}
printf("nArray Before Radix
Sort:"); //Array Before Radix Sort
for(i = 0; i < n; i++)
{
printf("%8d", array[i]);
}
printf("n");
radix_sort(array,n);
printf("nArray After Radix Sort:
"); //Array After Radix Sort
for(i = 0; i < n; i++)
{
printf("%8d", array[i]);
}
printf("n");
getch();
}

15. radix_sort(int arr[], int n)
{
int bucket[10][5],buck[10],b[10];
int i,j,k,l,num,div,large,passes;
div=1;
num=0;
large=arr[0];
for(i=0 ; i<n ; i++)
{
if(arr[i] > large)
{
large = arr[i];
}
while(large > 0)
{
num++;
large = large/10;
}
for(passes=0 ; passes<num ; passes++){
for(k=0 ; k<10 ; k++){
buck[k] = 0;
}
for(i=0 ; i<n ;i++)
{
l = ((arr[i]/div)%10);
bucket[l][buck[l]++] = arr[i];
}
i=0;
for(k=0 ; k<10 ; k++)
{
for(j=0 ; j<buck[k] ; j++)
{
arr[i++] = bucket[k][j];
}
}
div*=10;
}}}}

16.  If there is a fixed number p of bucket sort stages (six
stages in the case where the maximum value is
999999), then radix sort is O( n )
There are p bucket sort stages, each taking
O(n)time
 Strictly speaking, time complexity is
O( pn ), where p is the number of digits (note that p
= log10m, where m is the maximum value in the list)

17. Merge Sort
The merge sort algorithm comes in two parts: a sort function and a
merge function. The functions in pseudocode look like this:
function mergesort(m)
var list left, right, result
if length(m) ≤ 1
return m
else
var middle = length(m) / 2
for each x in m up to middle - 1
add x to left
for each x in m at and after middle
add x to right
left = mergesort(left)
right = mergesort(right)
if last(left) ≤ first(right)
append right to left
return left
result = merge(left, right)
return result

18. function merge(left,right)
var list result
while length(left) > 0 and length(right) > 0
if first(left) ≤ first(right)
append first(left) to result
left = rest(left)
else
append first(right) to result
right = rest(right)
if length(left) > 0
append rest(left) to result
if length(right) > 0
append rest(right) to result
return result

19. Shell Sort

20. Code
void ShellSort(int *array, int number_of_elements)
{ int i, j, increment, temp;
for(increment=number_of_elements/2; increment>0; increment/=2)
{ for(i=increment; i<number_of_elements; i++)
{ temp=array[i];
for(j=i; j>=increment; j-=increment)
{ if( temp<array[j-increment])
{ array[j]=array[j-increment];
}
else
{ break;
}
}
array[j]=temp;
}
}

22. Heap Sort
• Heapsort is an in-place sorting algorithm with worst case and average
complexity of O(nlog n).
Pseudocode :
function heapSort(a, count) is
input: an unordered array a of length count
(first place a in max-heap order)
heapify(a, count)
end := count - 1
while end > 0 do
{(swap the root(maximum value) of the heap with the last element of the
heap)
swap(a[end], a[0])
(decrement the size of the heap so that the previous max value will stay in its
proper place)
end := end - 1
(put the heap back in max-heap order)
shiftDown(a, 0, end)}

23. function heapify(a,count) is
(start is assigned the index in a of the last parent node)
start := (count - 2) / 2
while start ≥ 0 do
(shift down the node at index start to the proper place such that all nodes below the start index
are in heap order)
shiftDown(a, start, count-1)
start := start - 1
(after shifting down the root all nodes/elements are in heap order)
function shift Down(a, start, end) is (end represents the limit of how far down the heap to shift)
root := start
while root * 2 + 1 ≤ end do (While the root has at least one child)
child := root * 2 + 1 (root*2+1 points to the left child)
(If the child has a sibling and the child's value is less than its sibling's...)
if child + 1 ≤ end and a[child] < a[child + 1] then
child := child + 1 (... then point to the right child instead)
if a[root] < a[child] then (out of max-heap order)
swap(a[root], a[child])
root := child (repeat to continue shifting down the child now)
else
return

24. The underlying question- How fast
can we sort?

25. How fast can we sort?(contd.)
It all boils down to these practical choices:It all boils down to these practical choices:
1.1. When N is largeWhen N is large, use Quick Sort., use Quick Sort.
2.2. For small N(<20)For small N(<20), NLogN sorts are, NLogN sorts are
slower due to extra overhead in best caseslower due to extra overhead in best case
(larger constants in big-oh function)(larger constants in big-oh function)
3. For N<203. For N<20, use Insertion sort, use Insertion sort.

26. Practical Applications of Sorting in
our Modern Life
• Sorting represents fractals (Fractals are infinitely
complex patterns that are self-similar across
different scales. They are created by repeating a
simple process over and over in an ongoing
feedback loop. Driven by
recursion, fractals are images of dynamic
systems – the pictures of Chaos) which is a
basic part of symmetry & coordination & less
randomization.
Sorting is everywhere
knowingly and unknowingly!
Natural Fractal

27. All of them use many sorting techniques
And almost all other companies of the world,there aren’t really any limits or
boundaries! Sorting techniques are an essential part of our day to day life it has
made our life a lot more easier.

28. END OF PRESENTATION