ANALYSIS OF IN-PLACE SORTING ALGORITHM

1.SELECTION SORTING ALGORITHM

Introduction

The selection sort algorithm sorts an array by repeatedly finding the minimum element
(considering ascending order) from unsorted part and putting it at the beginning. The algorithm
maintains two sub-arrays in a given array.

1) The sub-array which is already sorted.

2) Remaining sub-array which is unsorted.
In every iteration of selection sort, the minimum element (considering ascending order) from the
unsorted sub-array is picked and moved to the sorted sub-array.

The proposed paper covers the Selection sorting Algorithm as :-

SELECTION_SORT(A) [4]
1. for N=1 to length[A]-1 (finding minimum value for pass)
2. min=A [N]
3. for K=N+1 to length[A](for comparison)
4. if (min>A [N])
5. min=A [K], Loc=K [End if] [End of inner loop]
6. Swap (A [Loc],A[N])[End of OUTER loop]
7. Exit

Analysis
 If an array contains (n) elements then (n-1) comparisons are required to sort the array.
 Here, The outer loop will make (n) turn of call making value of pivot index from (0 to n-1)
and for each call of outer loop, the inner loop makes (i+1 to n-1) call

The number of swaps in Selection Sort are as follows:

 Worst case: O(N)
 Average Case: O(N)
 Best Case: O(1)

Time & Space Complexity of Selection Sort

 Worst Case Time Complexity is: O(N2)
 Average Case Time Complexity is: O(N2)
 Best Case Time Complexity is: O(N2)
 Space Complexity: O(1)

Improved Selection sorting Algorithm

Proposed Algorithm
We propose the improvement of selection sort as follow :-
  While finding minimum element we should find the maximum element too.
 The array should be considered as three virtual sub arrays e.g. two sorted sub arrays at
each end and one unsorted sub-array in between.
 After each call the minimum element will be put at left sorted sub array and maximum
element should be put at right sorted sub array and the size of unsorted sub array will
decrease by two.
 After completion of passes the array will be sorted

Algorithm

SELECTION_SORT(A) [4]
1. for (N=1,P=length[A];N!=P;N++,P--) until (finding minimum and maximum value for pass)
2. min=A [N],max=A[P]
3. for K=N+1 to P (for comparison)
4. if (min>A [N])
5. min=A [K], Loc=K [End if] [End of first inner loop]
6. Swap (A [Loc],A[N])
7.for L=P-1 to N
7.if(max<A[p])
8. max=A [L], Loc=L [End if] [End of Second inner loop]
9. Swap (A [Loc],A[N])
[End of OUTER loop]
7. Exit
Analysis of Proposed Selection sort
 As two elements are sorted on every pass so total pass will be (N/2) where (N) is size of
array
 Here, the outer loop will make an (N/2) turns and for each turn two inner loops will make
(N/2) turns

The number of swaps in Selection Sort are as follows:

 Worst case: O(N/2)
 Average Case: O(N/2)
 Best Case: O(1)
Time & Space Complexity of Selection Sort
 Worst Case Time Complexity is: O(N2/4)
 Average Case Time Complexity is: O(N2/4)
 Best Case Time Complexity is: O(N2/4)
 Space Complexity: O(1)

Conclusion
This paper suggests how the selection sort can be more efficiently used based on the traditional
algorithm. So, It can be used to improve the action of selection sort and make Program easier.
2.INSERTION SORTING ALGORITHM

Introduction
It is simply building a sorted array or list by sorting elements one by one. The IS algorithm begins at
the first element of the array and inserts each element encountered into its correct position
(index), after determining and locating a suitable position. This process is repeated for the next
element until it reaches the last element in the dataset

The proposed paper covers the Insertion sorting Algorithm as :-

INSERTION-SORT(A)

for i = 1 to n
key ← A [i]
j←i–1
while j > = 0 and A[j] > key
A[j+1] ← A[j]
j←j–1
End while
A[j+1] ← key
End for

Analysis
 Run time of this algorithm is very much dependent on the given input.
 If the given numbers are sorted, this algorithm runs in O(n) time. If the given numbers are in
reverse order, the algorithm runs in O(n2) time.
 Insertion sort is used when number of elements is small. It can also be useful when input array is
almost sorted, only few elements are misplaced in complete big array.

Time & Space Complexity of Insertion Sort

 Worst Case Time Complexity is: O(N2)
 Average Case Time Complexity is: O(N2)
 Best Case Time Complexity is: O(N)
 Space Complexity: O(1)

Improved Insertion sorting Algorithm

Proposed Algorithm
We propose the improvement of insertion sort as follow :-
 One area to improve this implementation is the inner loop, where we sequentially comparing each element
with the selected element by the outer loop. Since we are doing this in the sorted section of the collection,
we could replace this search by a binary search method.

Algorithm

Insertion_SORT(Array)
function binarySearch(Array, N, key)
L=0
R=N
 while L < R:
mid = (L + R)/2
if Array[mid] <= key:
L = mid + 1
else:
R = mid
return L
end function

function InsertionSort(Array)
for i = 1 to length(Array) do:
key = Array[i]
pos = binarySearch(Array, key, 0, i-1)
j=i
while j > pos
Array[j] = Array[j-1]
j = j-1
Array[pos] = key
end for
end function

Analysis of Proposed Insertion sort

 We can use binary search to reduce the number of comparisons in normal insertion sort. Sort uses binary
search to find the proper location to insert the selected item at each iteration .

Time & Space Complexity of Proposed Insertion Sort

 Worst Case Time Complexity is: O(N log N)
 Average Case Time Complexity is: O(N log N)
 Best Case Time Complexity is: O(N)
 Space Complexity: O(1)

Conclusion
This paper suggests how the selection sort can be more efficiently used based on the traditional
algorithm. So, It can be used to improve the action of insertion sort and make Program easier.

3.QUICKSORT ALGORITHM

Introduction

In Quick Sort algorithm picks an element as pivot, and then it partitions the given array around the
picked pivot element. In quick sort, a large array is divided into two arrays in which one holds
values that are smaller than the specified value (Pivot), and another array holds the values that are
greater than the pivot.
The proposed paper covers the Quick sorting Algorithm as :-
QUICKSORT(A, p, r)
1 if p < r
2 q = PARTITION(A, p, r)
3 QUICKSORT(A, p, q -1)
4 QUICKSORT(A, q + 1, r)

PARTITION(A, p, r)
1 x = A[r]
2i=p–1
3 for j = p to r – 1
4 if A[j] <= x
5 i=i+1
6 exchange A[i] with A[j]
7 exchange A[i + 1] with A[r]
8 return i + 1

Analysis
• Run time of this algorithm is very much dependent on the pivot element selection.
• The running time and space of taken by the algorithm is depends on whether the
partitioning is balance or unbalance.
• If the partition are balanced then the algorithm run as fast as the Merge Sort Algorithm.
• If the partition is unbalanced then the algorithm run as slowly as the insertion sort.

Time & Space Complexity of Quick Sort

Case Time Complexity

Best Case O(n*logn)
Average Case O(n*logn)
Worst Case O(n2)

Space Complexity

Space Complexity - O(n*logn)

Stable - NO

Improved Quick sort Algorithm

To make sure at most O(log(n)) space is used, recur first into the partition’s smaller side, then use a
tail call to recur into the other. As such, we successfully sort the array in a way that minimizes the
recursive depth.
TailRecursiveQuicksort(A, p, r)
1 while (p < r)
2 pivot = PARTITION(A, p, r)
3 if (pivot – p < r – pivot) // recur on the smaller sub-array
4 TailRecursiveQuicksort(A, p, pivot – 1)
5 p = pivot + 1
6 else
7 TailRecursiveQuicksort(arr, pivot + 1, r)
8 r = pivot – 1;

Analysis of Proposed Quick sort

• When the pivot is always the smallest value of the segment to be partitioned, the
depth of recursion is linear in the size of the array, so the space required is linear in
the size of the array.
• The first step in changing this is to sort the smaller of the two partitions created by
the partition algorithm first, as shown in the algorithm on the right.
• This means that the largest partition is sorted last and that nothing else is done in
the method after the largest partition is sorted.

Time & Space Complexity of Proposed Insertion Sort

 Worst Case Time Complexity is: O(n2)

 Average Case Time Complexity is: O(n*logn)
 Best Case Time Complexity is: O(n*logn)
 Space Complexity: O(log(n))

Conclusion
This paper show that how the Quick sort can be more efficient by recurring smaller sub-arrays first
because at the and the larger part of the array is already sorted and reduce the space complexity
of the algorithm.