Object Oriented Design And Programming

SUBMITTED BY:
PALLAVI GUPTA
INTROSORT
 CONTENTS

HISTORY
INTRODUCTION
INTROSORT V/S QUICKSORT
PSEUDOCODE FOR INTROSORT ALGORITHM
FUNCTION TO OPERATE INTROSORT
FUNCTION FOR PARTITIONING THE ARRAY
INSERTION SORT IN INTROSORT ALGORITHM
PERFORMANCE ANALYSIS OF THE ALGORITHMS 100%
TIME AND SPACE COMPLEXITY 90%

C++ CONSTRUCTS USED IN THE PROGRAM 80%

CONCLUSION 70%
60%
50%
40%
30%
20%
10%
0%
A1 A2 A3 A4
HISTORY Introsort was invented by David Musser in Musser (1997), in which
he also introduced intro select, a hybrid selection algorithm based on
quick select (a variant of quicksort), which falls back to median of
medians and thus provides worst-case linear complexity, which is
optimal. Both algorithms were introduced with the purpose of
providing generic algorithms for the C++ Standard Library which had
both fast average performance and optimal worst-case performance,
thus allowing the performance requirements to be tightened. Introsort
is in place and not stable. IntroSort is the algorithm used by swift to
sort a collection. The classic implementation of introsort expect a
recursive Quicksort with fallback to Heapsort in case the recursion
depth level reached a certain max. The maximum depends on the
number of elements in the collection and it is usually 2 * log(n). The
reason behind this “fallback” is that if Quicksort was not able to get
the solution after 2 * log(n) recursions for a branch, probably it hit its
worst case and it is degrading to complexity O( n^2 ). To optimize
even further this algorithm, the swift implementation introduce an
extra step in each recursion where the partition is sorted using
Insertion Sort if the count of the partition is less than 20. The number
20 is an empiric number obtained observing the behavior of Insertion
Sort with lists of this size.
 I
101001101001000010101
0011110111011011011010

NTRO
101000011100101011001
010100111010100010101
0001011010110110110100
010101110001010100010

DUCTION 1000101110101100010011
010011010010000101010
0111101110110110110101
010000111001010110010
Introsort or introspective sort is a hybrid sorting algorithm that provides 101001110101000101010
both fast average performance and (asymptotically) optimal worst-case 0010110101101101101001
performance. It begins with quicksort, it switches to heapsort when the
recursion depth exceeds a level based on (the logarithm of) the number of
elements being sorted and it switches to insertion sort when the number of
elements is below some threshold. This combines the good parts of the
three algorithms, with practical performance comparable to quicksort on
typical data sets and worst-case O(n log n) runtime due to the heap sort.
Since the three algorithms it uses are comparison sorts, it is also a
comparison sort.
INTROSORT Introsort(Introspective sort) is a
Class Sorting algorithm comparison based sort that
Data structure Array consists of three sorting phases.
Worst-case performance O(n log n) They are Quicksort, Heapsort, and
Average performance O(n log n) Insertion sort.
Why is it better than simple Quicksort or
Why the need of Introsort?

 Since Quicksort can have a worse case O()

time complexity and it also increases the

INTROSORT
recursion stack space (O(log n) if tail recursion
applied), so to avoid all these, we need to
switch the algorithm from Quicksort to another
if there is a chance of worse case. So Introsort
solves this problem by switching to Heapsort.
V/S
Also due to larger constant factor, quicksort
QUICKSORT
can perform even worse than O() sorting
algorithm when n is small enough. So it
switches to insertion sort to decrease the
running time of sorting.

Also if a bad pivot-selection is done then the

quicksort does no better than the bubble-sort.
Pseudocode for introsort algorithm
sort(A : array):
depth = 2xfloor(log(length(A)))
introsort(A, depth)

introsort(A, depth):
n = length(A)
if n<=16:
pseudocode insertionSort(A)
if depth == 0:
heapsort(A)
else:

// using quick sort, the

// partition point is found
p = partition(A)
introsort(A[0:p-1], depth - 1)
introsort(A[p+1:n], depth - 1)
FUNCTION TO PERFORM INTROSORT
ON THE ARRAY a[ ] USING C++

void introsort(int a[ ], int *begin, int *end, int maxdepth)

{
if ((end - begin) < 16) {
insertionsort(a, begin - a, end - a);
}
else if (maxdepth == 0) {
heapsort(begin, end + 1);
}
else {
int pivot = randPartition(a, begin - a, end - a);
introsort(a, begin, a + pivot - 1, maxdepth - 1);
introsort(a, a + pivot + 1, end, maxdepth - 1);
}
}
FUNCTIONS FOR PARTITIONING THE ARRAY USING C+
+
int partition(int a[], int low, int high)
{
int pivot = a[high];
int pIndex = low;
for (int i = low; i < high; i++)
{
if (a[i] <= pivot)
{
swap(a[i], a[pIndex]);
pIndex++;
}
}
swap (a[pIndex], a[high]);
return pIndex;
} int randPartition(int a[], int low, int high)
{
QUICKSORT int pivotIndex = rand() % (high - low + 1) +
RANDOMIZED PARTITION low;
swap(a[pivotIndex], a[high]);
return partition(a, low, high);
 INSERTION SORT IN INTROSORT ALGORITHM
USING C++
void insertionsort(int a[ ], int low, int high)
{
for (int i = low + 1; i <= high; i++)
{
int value = a[i];
int j = i;
while (j > low && a[j - 1] > value) HEAPSORT
{ IMPLEMENTATION
a[j] = a[j - 1];
j - -;
void heapsort(int *begin, int *end)
}
{
a[j] = value; make_heap(begin, end);
} sort_heap(begin, end);
} }
 Performance analysis of the algorithms

Performance of a program or an algorithm

is the amount of time or computer memory
.
needed to run the program/algorithm.

Comparing each algorithm in terms of the number of The algorithm is the best of both average and worst
comparisons performed and the running times when cases worlds, with a worst-case and average case
used for sorting arrays of integers that are already O(n log n) runtimes and practical performance
sorted, sorted in reverse order, and generated comparable to Quicksort on typical data sets.
randomly.
Figure 1 and figure 2 shows the running times for the sorting algorithms when used to sort arrays
of random numbers of different sizes.
Here Quicksort is faster than Introsort for data sizes between N= 9000 and N=262144, after which
the two algorithms are comparable.
In terms of the number of comparisons, Introsort had the best performance compared to the
Quicksort algorithms.

Running time for random data No. of comparisons for random data
For sorted data Quicksort exhibits faster Behaviour than Intro sort whereas Introsort
performed the smallest number of comparisons for N>=200,000 compared to Quick
sort .
Both the algorithms exhibited O(N log2 N) behaviour, see figure 6-2.

Running time for almost sorted data No. of comparisons for almost sorted data

introsort
TIME AND SPACE COMPLEXITY OF INTROSORT AND
QUICKSORT ALGORITHMS

TIME COMPLEXITY

COMPLEXITY/ BEST CASE AVERAGE CASE WORST CASE

ALGORITHM
INTROSORT n log(n) n log(n) n log(n)

QUICKSORT n log(n) n log(n)

SPACE COMPLEXITY

The overall space complexity of both the

algorithm is log(n) .
 C++ STREAMS PARAMETER PASSING USING
POINTER VARIABLE
C++ uses a convenient abstraction
called streams to perform input and output C++ allows you to pass a pointer to a
operations in sequential media such as the function. To do so, simply declare the
screen, the keyboard or a file. A stream is function parameter as a pointer type.
an entity where a program can either insert
or extract characters to/from.

PASSING ARRAYS TO RETURN ARRAYS FROM

FUNCTIONS FUNCTIONS

You can pass to the function a pointer

to an array by specifying the array's C++ allows a function to return an array .
name without an index.

C++ OTHER BASIC C++

CONSTRUCTS

CONSTRUCTS
Conditional Statements, loops,

USED IN THE functions are used in the program

 CONCLUSION
Quicksort has been The introsort results
identified to be a mimic quite
very good sorting Quicksort showed its faithfully those of
technique that is untrustworthiness. the optimized
very efficient on all This demonstrates quicksort (which is
classes of sorting that making a good to be expected since
problems. However, implementation of it uses a similar
it is inefficient in the quicksort is far from algorithm).
worst case situation. easy. The introsort
Introsort solves function
the problem of the demonstrates that it
inefficiency of is possible, though.
Quicksort for the
worst case scenario
through the concept
of introspection.
THANK YOU