Successfully reported this slideshow.
Upcoming SlideShare
×

# Data Structures - Searching & sorting

8,952 views

Published on

It is a presentation on some Searching and Sorting Techniques for Computer Science.
It consists of the following techniques:
Sequential Search
Binary Search
Selection Sort
Bubble Sort
Insertion Sort

Published in: Technology
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

### Data Structures - Searching & sorting

1. 1. SEARCHING & SORTING TECHNIQUES By Kaushal Shah
2. 2. LINEAR/SEQUENTIAL SEARCH  The simplest technique for searching an unordered array for a particular element is to scan each entry in the array in a sequential manner until the desired element is found.
3. 3. ALGORITHM: SEQSEARCH (K, N, X) – Given an unordered array K of N elements, this algorithm searches the array for a particular element having value X. The given algorithm returns the index (position) of the required element if the search is successful, and returns 0 otherwise.   1. [Initialize search] I  1 2. [Search the array] Repeat while K[I] ≠ X I  I + 1 3. [Is the search successful?] if I > N then Write (‘UNSUCCESSFUL SEARCH’) Return (0) else Write (‘SUCCESSFUL SEARCH’) Return (I)
4. 4. BINARY SEARCH  In this method, the main requirement is that the array should be arranged in ascending order.  Here, the approximate middle element of the array is located, and its value is examined. If its value is too high, then the value of the middle element of the first half of the array is examined and the procedure is repeated to the first half until the required item is found. If the value is too low, then the value of the middle element of the second half of the array is checked and the procedure is repeated.
5. 5. BINARYSEARCH (K, N, X) – Given an array K of size N arranged in ascending order, this algorithm searches the array for a given element whose value is given by X. The variables LOW, MIDDLE and HIGH denote the lower, middle and upper limits of the search interval, respectively.  1. [Initialize] LOW  1 HIGH  N 2. [Perform search] Repeat thru step 4 while LOW <= HIGH 3. [Obtain index of midpoint of interval] MIDDLE  (LOW + HIGH) / 2 4. [Compare] If X < K [MIDDLE] then HIGH  MIDDLE – 1 else if X > K[MIDDLE] then LOW  MIDDLE + 1 else Write (‘SUCCESSFUL SEARCH’) Return (MIDDLE) 5. [Unsuccessful Search] Write (‘UNSUCCESSFUL SEARCH’) Return (0)
6. 6. BINARY SEARCH: TRACING A trace of binary search algorithm for the sample array:  75, 151, 203, 275, 318, 489, 524, 591, 647, and 727  is given below for X = 275 and X = 727… Search for X = 275 Iteration LOW HIGH MIDDLE 1 1 10 5 2 1 4 2 3 3 4 3 4 4 4 4 Search for X = 727 Iteration LOW HIGH MIDDLE 1 1 10 5 2 6 10 8 3 9 10 9 4 10 10 10
7. 7. SELECTION SORT  One of the easiest ways to sort an array is by selection.  In this technique, the smallest element is interchanged with the first element of the array.  Then the second smallest element is interchanged with the second element of the array.  This process of searching the next smallest element and placing it in its proper position continues until all records have been sorted in ascending order.
8. 8. TRACIN G  Here a pass is defined as the search for the next smallest element. To perform the sort operation, this technique will require n-1 passes.  In the above figure, each “encircled” entry denotes the record with the smallest element selected in a particular pass. The elements above the “double underline” for a given pass are those elements that have been placed in order.
9. 9. SELECTIONSORT (K, N) – Given an array K of size N, this procedure rearranges the elements of array in ascending order. The variable PASS represents the pass index and the position of the first element in the array which is to be examined during a particular pass. The variable MIN_INDEX shows the position of the smallest element encountered till now in a particular pass. The variable I is used to index elements from PASS to N in a given pass.  1. [Create a loop for n-1 passes] Repeat thru step 4 for PASS = 1, 2, …, N - 1 2. [Initialize MIN_INDEX to first element of each pass] MIN_INDEX  PASS 3. [Make a pass and obtain element with smallest value] Repeat for I = PASS + 1, PASS + 2, …, N If K[I[ < K[MIN_INDEX] Then MIN_INDEX  I 4. [Exchange smallest element with first element of each pass] If MIN_INDEX ≠ PASS Then K[PASS] ↔ K[MIN_INDEX] (Interchange) 5. [Finished] Return
10. 10. BUBBLE SORT  In this technique, two elements of an array are interchanged immediately upon discovering that they are out of order.  During the first pass, the first and second elements are compared, say R1 and R2, and if they are out of order (i.e. R1>R2), then they are interchanged; this process is repeated for second and third elements (R2 and R3), then for third and fourth element (R3 and R4), and so on.  After first pass, the largest element will be in the last position.  This process of comparing consecutive elements continues until the whole array is sorted.
11. 11.  Note: The whole process requires at the most n-1 passes. After each pass through the array, a check can be made to determine whether any interchange was made during that pass. If no interchange occurred in a particular pass, then the array must be sorted and no further passes are required. TRACIN G
12. 12. BUBBLESORT (K, N) – Given an array K of size N, this procedure rearranges the elements of array in ascending order. PASS and LAST variables are used for the pass counter and position of the last unsorted element, respectively. The variable I is used to index the elements of array. The variable EXCHS is used to count the number of interchanges made on any pass. 1. [Initialize] LAST  N 2. [Create a loop for the passes] Repeat thru step 5 for PASS = 1, 2, …, N - 1 3. [Initialize counter for no of interchanges for this pass] EXCHS  0 4. [Perform pair-wise comparisons on unsorted consecutive elements] Repeat for I = 1, 2, … LAST-1 If K[I[ > K[I+1] Then K[I] ↔ K[I+1] (Interchange elements) EXCHS  EXCHS + 1 5. [Check if any interchange was made on this pass] If EXCHS = 0 Then Return (Array Sorted; Return early) Else LAST  LAST – 1 (Reduce size of unsorted list) 6. [Finished] Return
13. 13. INSERTION SORT  Insertion sort is a simple sorting algorithm: a comparison sort in which the sorted array (or list) is built one entry at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, or merge sort.  Every repetition of insertion sort removes an element from the input data, inserting it into the correct position in the already-sorted list, until no input elements remain.
14. 14.  Sorting is typically done in-place. The resulting array after k iterations has the property where the first k + 1 entries are sorted. In each iteration the first remaining entry of the input is removed, inserted into the result at the correct position, thus extending the result: BEFORE AFTER
15. 15. InsSort(A[1…N]) – For i = 2 to N { temp = A[i] j = i-1 while(j>0 and temp<A[j]) { A[j+1] = A[j] j = j-1 } A[j+1] = temp } ALGORITHM:
16. 16. Unsorted Array: 3, 7, 4, 9, 5, 2, 6, 1 i temp j 1 7 0 3 7 4 9 5 2 6 1 2 4 1 3 7 7 9 5 2 6 1 3 4 7 9 5 2 6 10 3 9 2 3 4 7 9 5 2 6 1 4 5 3 3 4 7 9 9 2 6 1 3 4 7 7 9 2 6 1 3 4 5 7 9 2 6 1 2 1 5 2 4 3 4 5 7 9 9 6 1 3 4 5 7 7 9 6 1 3 4 5 5 7 9 6 1 3 4 4 5 7 9 6 1 3 3 4 5 7 9 6 1 2 3 4 5 7 9 6 1 3 2 1 0 -1 6 6 5 2 3 4 5 7 9 9 1 2 3 4 5 7 7 9 1 2 3 4 5 6 7 9 1 4 3 7 1 6 2 3 4 5 6 7 9 9 2 3 4 5 6 7 7 9 2 3 4 5 6 6 7 9 2 3 4 5 5 6 7 9 2 3 4 4 5 6 7 9 2 3 3 4 5 6 7 9 2 2 3 4 5 6 7 9 5 4 3 2 1 0 -1