of 17 /17
Searching techniques Searching : It is a process to find whether a particular value with specified properties is present or not among a collection of items. If the value is present in the collection, then searching is said to be successful, and it returns the location of the value in the array. Otherwise, if the value is not present in the array, the searching process displays the appropriate message and in this case searching is said to be unsuccessful. 1) Linear or Sequential Searching 2) Binary Searching Linear_Search (A[ ], N, val , pos ) Step 1 : Set pos = -1 and k = 0 Step 2 : Repeat while k < N Begin Step 3 : if A[ k ] = val Set pos = k print pos Goto step 5 End while Step 4 : print “Value is not present” Step 5 : Exit int main( ) { int arr [ 50 ] , num , i , n , pos = -1; printf ("How many elements to sort : "); scanf ("%d", &n); printf ("\n Enter the elements : \n\n"); for( i = 0; i < n; i++ ) { printf (“arr [%d ] : “ , i ); scanf( "%d", &arr[ i ] ); } printf(“\nEnter the number to be searched : “); scanf(“%d”,&num); for(i=0;i<n;i++) if( arr [ i ] == num ) { pos = i ; break; } if ( pos == -1 ) printf(“ %d does not exist ”,num); else printf(“ %d is found at location : Searches -- for each item one by one in the list from the first, until the match is found. Efficiency of Linear search : -- Executes in O ( n ) times where n is the number of elements in the list.

# Unit6 jwfiles

mrecedu

• View
140

2

Tags:

Embed Size (px)

DESCRIPTION

### Text of Unit6 jwfiles Searching techniques

Searching : It is a process to find whether a particular value with specified properties is present or not among a collection of items. If the value is present in the collection, then searching is said to be successful, and it returns the location of the value in the array. Otherwise, if the value is not present in the array, the searching process displays the appropriate message and in this case searching is said to be unsuccessful. 1) Linear or Sequential Searching 2) Binary Searching

Linear_Search (A[ ], N, val , pos )Step 1 : Set pos = -1 and k = 0Step 2 : Repeat while k < N BeginStep 3 : if A[ k ] = val Set pos = k print pos Goto step 5 End whileStep 4 : print “Value is not present”Step 5 : Exit

int main( ) { int arr [ 50 ] , num , i , n , pos = -1; printf ("How many elements to sort : "); scanf ("%d", &n); printf ("\n Enter the elements : \n\n"); for( i = 0; i < n; i++ ) { printf (“arr [%d ] : “ , i ); scanf( "%d", &arr[ i ] ); } printf(“\nEnter the number to be searched : “); scanf(“%d”,&num); for(i=0;i<n;i++) if( arr [ i ] == num ) { pos = i ; break; } if ( pos == -1 ) printf(“ %d does not exist ”,num); else printf(“ %d is found at location : %d”, num , pos);

Searches-- for each item one by one in the list from the first, until the match is found.Efficiency of Linear search :-- Executes in O ( n ) times where n is the number of elements in the list. Binary_Search (A [ ], U_bound, VAL)Step 1 : set BEG = 0 , END = U_bound , POS = -1Step 2 : Repeat while (BEG <= END )Step 3 : set MID = ( BEG + END ) / 2Step 4 : if A [ MID ] == VAL then POS = MID print VAL “ is available at “, POS GoTo Step 6 End if if A [ MID ] > VAL then set END = MID – 1 Else set BEG = MID + 1 End if End whileStep 5 : if POS = -1 then print VAL “ is not present “ End ifStep 6 : EXIT

void binary_serch ( int a [], int n, int val ) { int end = n - 1, beg = 0, pos = -1; while( beg <= end ) { mid = ( beg + end ) / 2; if ( val == a [ mid ] ) { pos = mid; printf(“%d is available at %d”,val, pos ); break; } if ( a [ mid ] > val ) end = mid – 1; else beg = mid + 1; } if ( pos = - 1) printf( “%d does not exist “, val );}

Binary SearchingAlgorithm: • Before searching, the list of items should be sorted in ascending order.• We first compare the key value with the item in the position of the array. If there is a match, we can return immediately the position.• if the value is less than the element in middle location of the array, the required value is lie in the lower half of the array.• if the value is greater than the element in middle location of the array, the required value is lie in the upper half of the array.• We repeat the above procedure on the lower half or upper half of the array. Sorting is a technique to rearrange the elements of a list in ascending or descending order, which can be numerical, lexicographical, or any user-defined order. Ranking of students is the process of sorting in descending order. EMCET Ranking is an example for sorting with user-defined order. EMCET Ranking is done with the following priorities. i) First priority is marks obtained in EMCET. ii) If marks are same, the ranking will be done with comparing marks obtained in the Mathematics subject. iii) If marks in Mathematics subject are also same, then the date of births will be compared.

Sorting

Types of Internal Sortings

Bubble Sort

Insertion Sort

Selection Sort

Quick Sort

Merge Sort

Internal Sorting : If all the data that is to be sorted can be accommodated at a time in memory is called internal sorting.

External Sorting : It is applied to Huge amount of data that cannot be accommodated in memory all at a time. So data in disk or file is loaded into memory part by part. Each part that is loaded is sorted separately, and stored in an intermediate file and all parts are merged into one single sorted list. Bubble Sort

Unsorted Sorted

Bubbles up the highest

10

47

12

54

19

23

54

10

47

12

23

19

AfterPass 1

54

47

10

23

12

19

54

47

23

10

19

12

54

47

23

19

10

12

After Pass 2

AfterPass 3

AfterPass 4

54

47

23

19

12

10

AfterPass 5

Bubble_Sort ( A [ ] , N )Step 1 : Repeat For P = 1 to N – 1 BeginStep 2 : Repeat For J = 1 to N – P BeginStep 3 : If ( A [ J ] < A [ J – 1 ] ) Swap ( A [ J ] , A [ J – 1 ] ) End For End ForStep 4 : Exit

Complexity of Bubble_Sort The complexity of sorting algorithm is depends upon the number of comparisons that are made.Total comparisons in Bubble sort is n ( n – 1) / 2 ≈ n 2 – n Complexity = O ( n 2 )

OriginalList void print_array (int a[ ], int n) { int i; for (i=0;I < n ; i++) printf("%5d",a[ i ]);}void bubble_sort ( int arr [ ], int n) { int pass, current, temp; for ( pass=1;(pass < n) ;pass++) { for ( current=1;current <= n – pass ; current++) { if ( arr[ current - 1 ] > arr[ current ] ) {

temp = arr[ current - 1 ]; arr[ current - 1 ] = arr[ current ]; arr[ current ] = temp;

} } }}int main() { int count,num,i ; printf ("How many elements to be sorted : "); scanf ("%d", &count); printf("\n Enter the elements : \n\n"); for ( i = 0; i < count; i++) { printf ("num [%d] : ", i ); scanf( "%d", &num[ i ] ); } printf("\n Array Before Sorting : \n\n\n"); print_array ( num, count ); bubble_sort ( num, count); printf("\n\n\n Array After Sorting : \n\n\n"); print_array ( num, count );}

Bubble Sort

For pass = 1 to N - 1

For J = 1 to N - pass

A [ J – 1 ] > A [ J ]

Temp = A [ J – 1 ]A [ J – 1 ] = A [ J ]

A [ J ] = Temp

T

F

Return Insertion Sort

78 23 45 8 32 36

23 78 45 8 32 36

23

TEMP

23 45 78 8 32 36

8 23 45 78 32 36

8 23 32 45 78 36

45

8

8 23 32 36 45 78

32

36

Insertion_Sort ( A [ ] , N )Step 1 : Repeat For K = 1 to N – 1 BeginStep 2 : Set Temp = A [ K ]Step 3 : Set J = K – 1 Step 4 : Repeat while Temp < A [ J ] AND J >= 0 Begin Set A [ J + 1 ] = A [ J ] Set J = J - 1 End WhileStep 5 : Set A [ J + 1 ] = Temp End ForStep 4 : Exit

insertion_sort ( int A[ ] , int n ) { int k , j , temp ; for ( k = 1 ; k < n ; k++ ) { temp = A [ k ] ; j = k - 1; while ( ( temp < A [ j ] ) && ( j >= 0 ) ) { A [ j + 1 ] = A [ j ] ; j - - ; } A [ j + 1 ] = temp ; }}

Complexity of Insertion SortBest Case : O ( n )Average Case : O ( n2 )Worst Case : O ( n2 ) Selection Sort ( Select the smallest and Exchange )

23 78 45 8 32 56

8 78 45 23 32 56

8 23 45 78 32 56

8 23 32 78 45 56

8 23 32 45 78 56

8 23 32 45 56 78

8

Smallest

23

32

45

56

Selection_Sort ( A [ ] , N )Step 1 : Repeat For K = 0 to N – 2 BeginStep 2 : Set POS = K Step 3 : Repeat for J = K + 1 to N – 1 Begin If A[ J ] < A [ POS ] Set POS = J End ForStep 5 : Swap A [ K ] with A [ POS ] End ForStep 6 : Exit selection_sort ( int A[ ] , int n ) { int k , j , pos , temp ; for ( k = 0 ; k < n - 1 ; k++ ) { pos = k ; for ( j = k + 1 ; j <= n ; j ++ ) { if ( A [ j ] < A [ pos ] ) pos = j ; } temp = A [ k ] ; A [ k ] = A [ pos ] ; A [ pos ] = temp ; }}

Complexity of Selection SortBest Case : O ( n2 )Average Case : O ( n2 )Worst Case : O ( n2 ) Insertion sort

k = 1; k < n ; k++

temp = a [ k ] j = k - 1

temp < a [ j ] && j >= 0

a [ j + 1 ] = a [ j ] j = j - 1

a [ j + 1 ] = temp

return

Selection sort

k = 0; k < n - 1 ; k++

pos = k

j = k + 1 ; j < n ; j++

temp = a[ k ]a [ k ] = a [ pos ]a [ pos ] = temp

return

a[ j ] < a[ pos ]

pos = j Bubble sort – Insertion sort – Selection sort

Bubble Sort : -- very primitive algorithm like linear search, and least efficient . -- No of swappings are more compare with other sorting techniques. -- It is not capable of minimizing the travel through the array like insertion sort.Insertion Sort : -- sorted by considering one item at a time. -- efficient to use on small sets of data. -- twice as fast as the bubble sort. -- 40% faster than the selection sort. -- no swapping is required. -- It is said to be online sorting because it continues the sorting a list as and when it receives new elements. -- it does not change the relative order of elements with equal keys. -- reduces unnecessary travel through the array. -- requires low and constant amount of extra memory space. -- less efficient for larger lists.Selection sort : -- No of swappings will be minimized. i.e., one swap on one pass. -- generally used for sorting files with large objects and small keys. -- It is 60% more efficient than bubble sort and 40% less efficient than insertion sort. -- It is preferred over bubble sort for jumbled array as it requires less items to be exchanged. -- uses internal sorting that requires more memory space. -- It cannot recognize sorted list and carryout the sorting from the beginning, when new elements are added to the list. Quick Sort – A recursive process of sorting

Algorithm for Quick_Sort :

-- set the element A [ start_index ] as pivot.-- rearrange the array so that : -- all elements which are less than the pivot come left ( before ) to the pivot. -- all elements which are greater than the pivot come right ( after ) to the pivot.-- recursively apply quick-sort on the sub-list of lesser elements.

-- recursively apply quick-sort on the sub-list of greater elements.-- the base case of the recursion is lists of size zero or one, which are always sorted.

8 3 2 11 5 14 0 2 9 4 20

Original-list of 11 elements :

8 3 2 11 5 14 0 2 9 4 20

Set list [ 0 ] as pivot :

pivot

pivot

Rearrange ( partition ) the elements into two sub lists :

Sub-list of lesser elements

Sub-list of greater elements

Apply Quick-sort recursivelyon sub-list

Apply Quick-sort recursivelyon sub-list

Complexity of Quick Sort

Best Case : O ( n log n )Average Case : O ( n log n )Worst Case : O ( n2 )

4 3 2 2 5 0 8 11 9 14 20 9 12 8 16 1 25 10 39

12 8 16 1 25 10 3

3 12 8 16 1 25 10

3 8 16 1 25 10 12

3 1 8 16 25 10 12

3 1 8 16 25 10 12

Pivot

Partitioning for ‘ One Step of Quick Sort ’ Quick Sort – Program

void quick_sort(int a[ ] , int beg , int end ) { int loc; if ( beg < end ) { loc = partition( a , beg , end ); quick_sort ( a , beg , loc – 1 ); quick_sort ( a , loc + 1 , end ); }}void print_array (int a [ ],int n) { int i; for ( i = 0 ; I < n ; i++ ) printf( "%5d“ ,a [ i ] ) ;}int main () { int count , num[ 50 ] , i ; printf ("How many elements to sort : "); scanf ("%d", &count ); printf ("\n Enter the elements : \n\n"); for( i = 0; i < count; i++ ) { printf ("num [%d ] : “ , i ); scanf( "%d", &num[ i ] ); } printf (“ \n Array Before Sorting : \n\n\n“ ); print_array ( num , count ) ; quick_sort ( num ,0 , count-1) ; printf ( "\n\n\n Array After Sorting : \n\n\n“ ); print_array ( num , count );}

int partition ( int a [ ], int beg, int end ) { int left , right , loc , flag = 0, pivot ; loc = left = beg; right = end; pivot = a [ loc ] ; while ( flag == 0 ) { while( (pivot <= a [ right ] )&&( loc != right ) ) right - - ; if( loc == right ) flag = 1; else { a [ loc ] = a [ right ] ; left = loc + 1 ; loc = right; } while ( (pivot >= a [ left ] ) && ( loc != left ) ) left++; if( loc == left ) flag = 1; else { a [ loc ] = a [ left ] ; right = loc - 1; loc = left; } } a [ loc ] = pivot; return loc; } partition ( int a [ ], int beg, int end )

loc = left = beg flag = 0, right = end

pivot = a [ loc ]

Flag == 0

pivot <= a [ right ] && loc != right

right = right - 1

loc == right

a [ loc ] = a [ right ] left = loc + 1 ;

loc = right;

flag = 1

F T

BA

BA

pivot >= a [ left ]&&loc != left

left = left + 1

loc == left

a [ loc ] = a [ left ] right = loc - 1 ;

loc = left;

flag = 1

F T

a[ loc ] = pivot

return loc

quick_sort ( int a [ ], int beg, int end )

loc == leftT

loc = partition( a , beg , end )

quick_sort ( a , beg , end )

quick_sort ( a , beg , end )

F

return Merge Sort ( Divide and conquer )

39 9 81 45 90 27 72 18

Divide the array

39 9 81 45 90 27 72 18

39 9 81 45 90 27 72 18

39 9 81 45 90 27 72 18

Merge the elements to sorted array

39 9 81 45 90 27 72 18

9 39 45 81 27 90 18 72

9 39 45 81 18 27 72 90

9 18 27 39 45 72 81 90

-- Merge sort technique sorts a given set of values by combining two sorted arrays into one larger sorted arrays. -- A small list will take fewer steps to sort than a large list. -- Fewer steps are required to construct a sorted list from two sorted lists than two unsorted lists. -- You only have to traverse each list once if they're already sorted .

Merge_sort Algorithm1. If the list is of length 0 or 1, then it is already sorted. Otherwise:2. Divide the unsorted list into two sublists of about half the size.3. Sort each sublist recursively by re-applying

merge sort.4. Merge the two sublists back into one sorted list.

Time complexityWorst case - O(n log n) Best case - O(nlogn) typical, O(n) natural variant Average case - O( n log n ) void merge(int a[ ],int low,int high,int mid){ int i, j, k, c; i=low; j=mid+1; k=low; while( ( i<=mid )&&( j <= high ) ) { if( a[ i ]<a[ j ] ){ c[ k ]=a[ i ]; k++; i++; }else { c[ k ]=a[ j ]; k++; j++; } } while( i<=mid ) { c[k]=a[ i ]; k++; i++; } while(j<=high) { c[k]=a[ j ]; k++; j++; } for(i=low;i<k;i++) a[ i ]=c[ i ]; }

void merge_sort(int a[ ], int low, int high){ int mid; if( low < high) { mid=(low+high)/2; merge_sort (a, low, mid); merge_sort (a, mid+1 ,high); merge (a, low, high, mid); }}

Merge Sort - Program

void print_array (int a [ ],int n) { int i; for ( i = 0 ; I < n ; i++ ) printf( "%5d“ ,a [ i ] ) ;}int main () { int count , num[ 50 ] , i ; printf ("How many elements to sort : "); scanf ("%d", &count ); printf ("\n Enter the elements : \n\n"); for( i = 0; i < count; i++ ) { printf ("num [%d ] : “ , i ); scanf( "%d", &num[ i ] ); } printf (“ \n Array Before Sorting : \n\n\n“ ); print_array ( num , count ) ; merge_sort ( num ,0 , count-1) ; printf ( "\n\n\n Array After Sorting : \n\n\n“ ); print_array ( num , count );} Merge_Sort

low < high

mid = ( low + high ) / 2

merge_sort (a, low, mid)

merge_sort (a, mid, high )

Merge (a, low,high , mid)

Return

TF

merge

i =low ; j = mid+1;k = low

i <= mid && j <= high

a[ i ] < a[ j ]

c[ k ] =a [ i ] ; k++ ; i++

c[ k ] =a [ j ] ; k++ ; j++

i <= mid

c[ k ] =a [ i ] ; k++ ; i++

j <= high

c[ k ] =a [ j ] ; k++ ; j++

i = low ; i < k ; i ++

a[ i ] = c [ i ]

return

F T www.jntuworld.com

• For More Materials, Text Books, Previous Papers & Mobile updates of B.TECH, B.PHARMACY, MBA, MCA of JNTU-HYD,JNTU-KAKINADA & JNTU-ANANTAPUR visit www.jntuworld.com ##### Unit6-Day6-VDBctp.cm.utexas.edu/.../ch302/slides/Unit6-Day6-VDB.pdf · Unit6-Day6-VDB Tuesday, February 25, 2014 8:34 AM Unit6-Day6-VDB Page 1
Documents Documents