Shreeram Polytechnic, Airoli

Seminar report on the topic of :-

Heap sort & Radix sort

Submitted by :-

1. Rishil .T. Vittal. (43)

2. Pankit .B. Panchal. (39)

Under the guidance / provision of :

Mr. Satish .Patel

For the subject of :-

Data Structure (DS)

In the academic year 2010-2011

This is the certificate that Mr. Rishil.Vittal & Pankit.Panchal have completed
their seminar work during diploma and the report embodies the result of
work, it is therefore recommended for submission

Name and signature of the guide:-

Department Information Technology

 Heap sort

Introduction:-

Heap sort is a much more efficient version of selection sort. It

also works by determining the largest (or smallest) element of the list,
placing that at the end (or beginning) of the list, then continuing with the
rest of the list, but accomplishes this task efficiently by using a data
structure called a heap, a special type of binary tree. Once the data list has
been made into a heap, the root node is guaranteed to be the largest (or
smallest) element. When it is removed and placed at the end of the list, the
heap is rearranged so the largest element remaining moves to the root.
Using the heap, finding the next largest element takes O(log n) time,
instead of O(n) for a linear scan as in simple selection sort. This allows
Heap sort to run in O(n log n) time, and this is also the worst case
complexity.

Heapsort No Selection

Heapsort
A run of the heapsort algorithm
sorting an array of randomly
permuted values. In the first stage
of the algorithm the array elements
are reordered to satisfy the heap
property. Before the actual sorting
takes place, the heap tree structure
is shown briefly for illustration.

Class:- Sorting algorithm

Data structure:- Array

Worst case O(nlogn)

performance:-

Best case O(nlogn)

performance:-

Average case O(nlogn)

performance:-

Worst case space O(n) total, O(1)auxiliary

complexity
Heapsort is a comparison-based sorting algorithm, and is part of the selection sort
family. Although somewhat slower in practice on most machines than a well
implemented quicksort, it has the advantage of a more favorable worst-case O(n log n)
runtime. Heapsort is an in-place algorithm, but is not a stable sort.

Overview
Heapsort begins by building a heap out of the data set, and then removing the largest
item and placing it at the end of the partially sorted array. After removing the largest
item, it reconstructs the heap, removes the largest remaining item, and places it in the
next open position from the end of the partially sorted array. This is repeated until there
are no items left in the heap and the sorted array is full. Elementary implementations
require two arrays - one to hold the heap and the other to hold the sorted elements.

Heapsort inserts the input list elements into a binary heap data structure. The largest
value (in a max-heap) or the smallest value (in a min-heap) are extracted until none
remain, the values having been extracted in sorted order. The heap's invariant is
preserved after each extraction, so the only cost is that of extraction.

During extraction, the only space required is that needed to store the heap. To achieve
constant space overhead, the heap is stored in the part of the input array not yet sorted.
(The storage of heaps as arrays is diagrammed at Binary heap #Heap implementation.)
Heapsort uses two heap operations: insertion and root deletion. Each extraction places
an element in the last empty location of the array. The remaining prefix of the array
stores the unsorted elements.

Variations

 The most important variation to the simple variant is an improvement by R. W.

Floyd that, in practice, gives about a 25% speed improvement by using only one
comparison in each sift up run, which must be followed by a sift down for the original
child. Moreover, it is more elegant to formulate. Heap sort's natural way of indexing
works on indices from 1 up to the number of items. Therefore the start address of
the data should be shifted such that this logic can be implemented avoiding
unnecessary +/- 1 offsets in the coded algorithm.
 Ternary heapsort uses a ternary heap instead of a binary heap; that is, each
element in the heap has three children. It is more complicated to program, but does
a constant number of times fewer swap and comparison operations. This is because
each step in the shift operation of a ternary heap requires three comparisons and
one swap, whereas in a binary heap two comparisons and one swap are required.
The ternary heap does two steps in less time than the binary heap requires for three
steps, which multiplies the index by a factor of 9 instead of the factor 8 of three
binary steps. Ternary heapsort is about 12% faster than the simple variant of binary
heapsort
 The smooth sort algorithm is a variation of heapsort developed by Edsger
Dijkstra in 1981. Like heapsort, smooth sort's upper bound is O(n log n). The
advantage of smooth sort is that it comes closer to O(n) time if the input is already
sorted to some degree, whereas heapsort averages O(n log n) regardless of the
initial sorted state. Due to its complexity, smooth sort is rarely used.
 Levcopoulos and Petersson[5] describe a variation of heapsort based on
a Cartesian tree that does not add an element to the heap until smaller values on
both sides of it have already been included in the sorted output. As they show, this
modification can allow the algorithm to sort more quickly than O(n log n) for inputs
that are already nearly sorted.
 Ingo Wegener describes a bottom up version of heapsort that replaces sift down
with an alternative that reduces the worst case from 2n log(n) to 1.5n log(n) and is
claimed to perform better than some versions of quicksort.

Comparison with other sorts

Heapsort primarily competes with quicksort, another very efficient general purpose
nearly-in-place comparison-based sort algorithm.

Quicksort is typically somewhat faster, due to better cache behavior and other factors,
but the worst-case running time for quicksort is O(n2), which is unacceptable for large
data sets and can be deliberately triggered given enough knowledge of the
implementation, creating a security risk. See quicksort for a detailed discussion of this
problem, and possible solutions.

Thus, because of the O(n log n) upper bound on heap sort's running time and constant
upper bound on its auxiliary storage, embedded systems with real-time constraints or
systems concerned with security often use heapsort.

Heapsort also competes with merge sort, which has the same time bounds, but requires
Ω(n) auxiliary space, whereas heapsort requires only a constant amount. Heapsort also
typically runs more quickly in practice on machines with small or slow data caches. On
the other hand, merge sort has several advantages over heapsort:

 Like quicksort, merge sort on arrays has considerably better data cache
performance, often outperforming heapsort on a modern desktop PC, because it
accesses the elements in order.
 Merge sort is a stable sort.
 Merge sort parallelizes better; the most trivial way of parallelizing merge sort
achieves close to linear speedup, while there is no obvious way to parallelize
heapsort at all.
 Merge sort can be easily adapted to operate on linked lists (with O(1) extra
space[7]) and very large lists stored on slow-to-access media such as disk
storage or network attached storage. Heapsort relies strongly on random access,
and its poor locality of reference makes it very slow on media with long access
times. (Note: Heapsort can also be applied to doubly linked lists with only O(1) extra
space overhead)
Intro sort is an interesting alternative to heapsort that combines quicksort and heapsort
to retain advantages of both: worst case speed of heapsort and average speed of
quicksort.
Pseudo code

The following is the "simple" way to implement the algorithm

in pseudo code. Arrays are zero based and swap is used to exchange two elements of
the array. Movement 'down' means from the root towards the leaves, or from lower
indices to higher. Note that during the sort, the smallest element is at the root of the
heap at a[0], while at the end of the sort, the largest element is in a[end].

function heap Sort(a, count) is

input: an unordered array a of length count

(first place a in max-heap order)

heapify(a, count)
 end := count-1 //in languages with zero-based arrays the
children are 2*i+1 and 2*i+2
while end > 0 do
(swap the root(maximum value) of the heap with the last
element of the heap)
swap(a[end], a[0])
(put the heap back in max-heap order)
Sift Down(a, 0, end-1)
(decrease the size of the heap by one so that the
previous max value will
stay in its proper placement)
end := end - 1

function heapify(a, count) is

(start is assigned the index in a of the last parent node)
start := count / 2 - 1

while start ≥ 0 do
(sift down the node at index start to the proper place
such that all nodes below
the start index are in heap order)
sift Down(a, start, count-1)
start := start - 1
(after sifting down the root all nodes/elements are in heap
order)

function sift Down(a, start, end) is

input: end represents the limit of how far down the heap
to sift.
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)
swap := root (keeps track of child to swap with)
(check if root is smaller than left child)
if a[swap] < a[child]
swap := child
(check if right child exists, and if it's bigger than
what we're currently swapping with)
if child < end and a[swap] < a[child+1]
swap := child + 1
(check if we need to swap at all)
if swap != root
swap(a[root], a[swap])
root := swap (repeat to continue sifting
down the child now)
else
return
The heapify function can be thought of as building a heap from the bottom up,
successively shifting downward to establish the heap property. An alternative version
(shown below) that builds the heap top-down and shifts upward is conceptually simpler
to grasp. This "sift Up" version can be visualized as starting with an empty heap and
successively inserting elements. However, it is asymptotically slower: the "sift Down"
version is O(n), and the "sift Up" version is O(n log n) in the worst case. The heapsort
algorithm is O(n log n) overall using either version of heapify.

function heapify(a, count) is

(end is assigned the index of the first (left) child of the
root)
end := 1

while end < count

(sift up the node at index end to the proper place such
that all nodes above
the end index are in heap order)
sift Up(a, 0, end)
end := end + 1
 (after sifting up the last node all nodes are in heap
order)

function sift Up(a, start, end) is

input: start represents the limit of how far up the heap
to sift.
end is the node to sift up.
child := end
while child > start
parent := floor((child - 1) ÷ 2)
if a[parent] < a[child] then (out of max-heap order)
swap(a[parent], a[child])
child := parent (repeat to continue sifting up the
parent now)
else
return

this is all we study about the heap sort from the above given
information.