PERFORMANCE OF VARIOUS SORTING AND SEARCHING ALGORITHMS Aarushi Madan Aarusi Tuteja Bharti

Transcription

1 PERFORMANCE OF VARIOUS SORTING AND SEARCHING ALGORITHMS Aarushi Madan Aarusi Tuteja Bharti memory. So for the better performance of an algorithm, time complexity and space complexity has been considered. KEYWORDS: Searching. Linear Search. Binary Search. Sorting. Quick Sort. Shell Sort. Merge Sort. Insertion Sort. Selection Sort. 14 ABSTRACT: In the present scenario, the algorithm and data structures play an important role for the development of software or technology in our country. Searching and Sorting algorithms are the operations which arranges and searches all the elements in an array. In this paper, advantages, disadvantages, importance of Sorting and Searching has been explained. By Searching algorithm, we can find the element present in an array. Importance and Comparison of binary and linear search has been explained. Sorting algorithm is the operation by which the data is arranged in either increasing or decreasing order. Data is sorted in different forms i.e. Selection sort, Insertion sort, Shell sort, Merge sort and Quick sort. Quick sort has been considered as the best sort as it has complexity O (1). The efficiency of Sorting algorithm depends on how fast and accurately it sorts a list and also how much space it requires in the

2 SEARCHING: Search is an operation in which a given list is searched for a particular value. The location of a searched element is informed. There are many situations where we want to find out whether a particular item is present in a list or not. For example in a list of students, school authority can search whether the fee of a particular student is submitted or not. TYPES OF SEARCHING: Linear Search Binary Search BINARY SEARCH: Binary Search is based on a Divide and Conquer technique. If the list is already sorted then only the binary search takes place. This popular search technique searches the given item in minimum possible comparisons. In this the list is divided into two parts. The middle element is tested for the key element, if found, then its position is noted else the test is made. If we have to search the element which is less than the middle element then the element resides in the first half otherwise in the second half. Therefore, searching becomes easy for binary search. 15 N/2(middle) LINEAR SEARCH: Linear Search also known as sequential search, where each element is compared with the given element to be searched for. The searching starts from the beginning and continues till the end of the list. Algorithm for Linear Search: Step 1: Read array. Step 2: Read value. Step 3: Pos=-1 intialise pos to a non-existing position. Step 4: for (i=0;i<n;i++) if (value==array[i]) Pos =i; Step 5: if(pos!=-1) print Pos. Disadvantage: The linear search is slow and inefficient. If the element to be searched is the last element of the array, so many comparisons would take place therefore, it is time consuming.

3 Algorithm for Binary Search: Step 1: Low = 0 ; Step 2: High = N-1 ; SORTING: Where N is the number of element 16 Step 3: Pos = -1 ; Step 4: Flag = False ; Step 5: while(low<=high and Flag==False) middle =(Low +High)/2 if (array[middle]==value) Pos = middle ; Flag = True ; Break from the loop ; else if(array[middle] < value) Low = middle+1 ; else High = middle -1 ; Step 6 : if(flag == True) print The value found at ; write Pos; else print The value not found ; The desired value if found at middle then the flag is set to true and while loop terminates otherwise the stage arise when low becomes greater than the high. This will lead to the failure of the search. Thus, the variables Low and High keep the track of the lower and the upper bound of the array, respectively.

4 Sorting of an array means arranging the array elements in a predetermined order i.e. either ascending or descending order. For ascending order: List [i] <= List [i+1], 0< i <N-1 For descending order: List [i] >= List [i+1], 0< i <N-1 Properties of Sorting Algorithm: Time Complexity: Time complexity refers to how long the sorting program run. The number of commands which a program executes during its processing is called its time complexity. The time taken for processing of a program depends on the number of the strings to be sorted. Space Complexity: The memory allocations which an algorithm needs is space complexity. A good algorithm keeps space complexity as small as possible. When the data is transferred to a new list during sort, then the space complexity will be O (n). If a sorting algorithm requires a constant amount of additional space, then it is provided with O (1) extra space. Stability: If the items with the equal elements are guaranteed to remain in same order then the sort is stable. Big-Oh Notation : The big-oh notation defines that for a large number of inputs n, the growth rate of an algorithm T(n) is the order of a function g of n as indicated by the following relation : Step 2: The second pass identifies 2 as the smallest element in remaining unsorted array. Adding 2 also in the sorted part of the list at second position we have the following array: T(n) = O(g(n)) SELECTION SORT: It is a very simple and natural way of sorting a list. It finds the smallest element in the list and exchange it with the element present at the top of the list as shown in figure 1. Complexity : O (n 2 ) Step 1 : Consider the following unsorted array to be sorted using selection sort : Smallest Choose the smallest element from unsorted array which is 1 ; Put this smallest element in sorted part at first position. Now array becomes as follows : Sorted Unsorted

5 Step 3: In third pass, 3 is chosen as smallest and put at position 3 and our array becomes: Step 4: This time 4 is moved to sorted part at fourth position Step 5: Fifth pass adds 6 to the sorted part at the next position Step 6: Sixth pass adds 8 to the sorted list and the seventh pass adds 9 to the sorted list Step 7: Therefore after seven passes the array is sorted. Algorithm for Selection Sort: Step 1: for I = 1 to N-1 small = list [I] Pos = I; 18 Figure 1

6 BUBBLE SORT: In bubble sort we compare two adjacent values and exchange them if they are not in proper order. Complexity: O (n 2 ) For example, in the following figure an unsorted array is to be sorted in ascending order using bubble sort: Algorithm for Bubble Sort : Step 1 : Flag = false ; Figure 2 19 For J=I+1 to N If ( List [J] < small ) small = List[J]; Pos = J; Temp = List[I]; List[I] = List[Pos]; List[Pos] = Temp; Step 2: Print the sorted list.

7 Step 2 : while ( Flag == false ) Flag = true; For j=0 to N-2 if( List[J] > List[J+1]) temp = List[J] ; Step 3: Print the sorted list. Step 4: Stop. List[J] = Lisy[J+1] ; List[J+1] =temp ; Flag = false ; INSERTION SORT: Insertion operation requires following steps: Scan the sorted part to find the place where the element, from unsorted part, can be inserted. While scanning, shift the elements towards right to create space. Insert the element, from unsorted part, into the created space. Complexity: Best case: O (n) Worst Case: O (n 2 ) 20 Suppose an array A with n elements A[1],A[2], A[N] is in memory. The insertion sort algorithm examine the array i.e. A from A[1] to A[N], then insert every element A[K] at its appropriate position in the formerly sorted sub array i.e. A[1],A[2],A[K-1]. That is: Pass 1: A[1] is sorted automatically. Pass 2 : A[2] is inserted either before or after A[1] so that : A[1],A[2] is sorted. Pass 3 : A[3] is inserted into its correct place in A[1], A[2], that is, before A[1], between A[1] and A[2], or after A[2], so that : A[1], A[2],A[3] is sorted. Pass 4 : A[4] is inserted into its correct place in A[1], A[2], A[3] so that : A[1],A[2],A[3],A[4] is sorted. Pass N : A[N] is inserted into its correct place in A[1],A[2]..A[N-1] so that : A[1], A[2], A[N] is sorted.

8 Figure 3 MERGE SORT: Merging means combining elements of two arrays to form a new array. This method uses the following two concepts: If a list is empty or it contains only one element, then the list is already sorted. A list that contains only one element is called singleton. It uses the old proven technique of divide and conquer to recursively divide the list into subsists until it is left with either empty or singleton lists. 21 Algorithm for Insertion Sort: Step 1: For I = 2 to N Temp = List [I] ; J = I-1 ; While ( Temp <= List [J] AND J >=0) List[J+1] = List[J] ; J = J-1 ; List[J+1] = Temp ; Step 2: Print the List. Step 3: Stop.

9 Complexity: O (nlogn) 22 Figure 4 Algorithm for Merge Sort: Step 1: ptr 1 = lb ; Step 2: ptr 2 = mid ; Step 3: ptr 3 = lb ; Step 4: while ((ptr 1 < mid ) && ptr 2 <= ub) if ( List[ptr1] <= List[ptr2]) mergelist [ptr3] = List [ptr 1]; ptr1++; ptr3++; else mergelist [ptr3] = List [ptr 2] ; ptr2++ ;

10 ptr3++ ; Step 5: while( ptr1< mid ) merge List[ptr 3] = List[ptr1] ; ptr1++ ; ptr3++ ; 23 Step 6: while( ptr 2 <= ub ) mergelist [ptr3] = List [ptr2] ; ptr2++ ; ptr3++ ; Step 7: for(i=lb ; i<ptr3 ; i++) List[i] = mergelist[i] ; Step 8: Stop. QUICK SORT: This method also uses the technique of divide and conquer. On the basis of a pivot element from the list, it divides the rest of the list into two parts a sub list that contains elements less than the pivot and other sub list containing elements greater than the pivot. The algorithm is recursively applied to the sub lists until the size of each sub list becomes 1, indicating the whole list has become sorted. Complexity: Best Case: O (1) Average Case: O (nlogn) Worst Case: O (n 2 )

11 Figure 5 24 Algorithm for Quick Sort: Quicksort() Step 1: Lb = 0; Step 2: Ub = N-1 ; Step 3: Pivot = List [ lb ] ; Step 4: lb++ ; Step 5: Partition (pivot, List, lb, ub) ; Partition( pivot, List, lb, ub) Step 1: i=lb ; Step 2: j=ub ; Step 3: while(i<=j) while( List[i] <= pivot) i++; while(list[j] > pivot) j-- ;

12 if( i<= j ) temp = List [i]; List [i] = List [j] ; List [j] = temp ; Step 4: temp = List [j] ; Step 5: List [j] = List [lb-1] ; Step 6: List [lb-1] = temp ; Step 7: if ( j > lb )Step 8 : if ( j < ub ) Quicksort ( List, j+1, ub ) ; SHELL SORT: It is an improved form of insertion sort. In shell sort we arrange the order of data in a 2-D array and then sorting is done. In shell sort we calculate the distance k between the upper bound and lower bound according to the formula: k = UB+LB/2 Complexity: The complexity of shell sort depends upon k. Average case: O (n 1.25 ) Worst case: O (n 1.5 ) 25

13 Algorithm for Shell Sort: Step 1: Initialize the set dimstep to values 1,3,5 Step Journal 2: of Advance for(step Research in Computer Science & Engineering = 0 ; step <3 ; step++) k = dimstep [step] ; s = 0; for (i = s+k ; i <size ; i+ = k) Figure 6 Conclusion: From the above analysis we have concluded that quick sort is the fastest algorithm as it is easier to sort the complex arrays easily and consumes less time while in case of insertion sort it is 26 temp = List[i]; j = i-k ; while ((temp < List[j]) && (j >= 0)) List [j+k] = List [j] ; j = j-k ; List[j+k] = temp ; s++ ; Step 3: print the sorted list. Step 4: Stop.

14 difficult to sort complicated arrays one by one and is time consuming. In terms of swapping bubble sort performs the greatest number of swap because each element is compared with its adjacent element. Thus, it is slow. References: [1] Sorting and Searching Algorithms by Thomas Niemann. 27 [2] A.K.Sharma, Data Structures Using C, Second Edition, 2011, pp [3] Nidhi Chhajed, Imran Uddin, Simarjeet Singh Bhatia A Comparison Based Analysis of Four Different Types of Sorting Algorithms in Data Structures with Their Performances IJARCSSE Volume 3 Issue2. [4] [5] [6] S Arora, Computer Science with C++, Ninth Edition Volume 1, 1997, pp