Running head: REPORT 1

Report

Student Name

Course Name

Instructor Name

June 27, 2021

REPORT 2

Report

Algorithm Selected: Insertion sort is a simple sorting algorithm and which builds the final sorted array one item at one ti

me.

JVM Warmup:

For making the low latency application and analyse the result correctly we need to tune the JVM this is called JVM

warming up. For this we have run the sample benchmark sort for 250 times in order to avoid the problem of JVM warm-u

p.

A Big-Θ analysis of the two versions of the algorithm

Both implementation time complexity is O(N^2). Time complexity of both implementation remains the same. Only

difference is in the space complexity, which is O(N) in case of recursion implementation because of the space reserve for t

he array in the call stack while in case of iterative implementation space complexity is O(1). So both the implementation a

re not identical.

Pseudocode of the algorithms:

a. Recursive insertion sort

procedure: InsertionSort(Arr:array of items,n:size of array)

if n<1:

return

end if

InsertionSort(Arr,n-1)

declare variable value,position

value = Arr[n-1]

position=n-2

while position>0 and Arr[position]>value:

Arr[position+1]=Arr[position]

position=position-1

end while
REPORT 3

Arr[position]=value

end procedure

b. Iterative insertion sort

procedure: InsertionSort(Arr:array of items)

declare variable value,position

for i = 1 to length(Arr):

value = Arr[i]

position = i

while position>0 and A[position-1]>value:

Arr[position]=Arr[position-1]

position=position-1

end while

A[rrposition]=value

end for

end procedure

Comparison of two sorts

Iterative sort for various sizes

REPORT 4

Recursive sort for various sizes

Graph of comparison :

For iterative algorithm data:

REPORT 5

For recursive algorithm data:

From the graph also it appears that both the algorithm took same amount of time and we can say that the average ti

me is square times as of the size of the data.

Console Result

Summary

In this assignment I have selected insertion sort algorithm and wrote its iterative and recursive approach. For maki

ng the results accurate and avoid any latency we have using method to tune the JVM. In order to understand the big O tim

e complexity we have performed the experiment with different size of data for both the algorithm. For recursive and for ite

rative. Both the algorithm works similar .Only drawback of using the recursive approach is the use of additional space in t

he stack for storing the array of data.