FaaDoOEngine

ers.com
Engaging Peers, Inspiring Careers!

Indias No.1 website for:

IIT-JEE/AIEEE preparation resources

Coaching centre packages
Engineering Major and Minor projects
Seminar reports
Paper presentations
EBOOKS
Resumes/CVs, and so much more

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
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);

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
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 Searching
Algorithm:
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.
Binary_Search (A [ ], U_bound, VAL)
Step 1 : set BEG = 0 , END = U_bound , POS = -1
Step 2 : Repeat while (BEG <= END )
Step 3 :
set MID = ( BEG + END ) / 2
Step 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 while
Step 5 : if POS = -1 then
print VAL is not present
End if
Step 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 );
}

Sorting
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.

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.

Types of Internal Sortings

Bubble Sort

Insertion Sort

Selection Sort

Quick Sort

Merge Sort

Bubble Sort
Bubbles up the highest

Sorted

Unsorted

10

54

54

54

54

54

47

10

47

47

47

47

12

47

10

23

23

23

54

12

23

10

19

19

19

23

12

19

10

12

23

19

19

12

12

10

After
Pass 2

After
Pass 3

After
Pass 4

After
Pass 5

Original After
List
Pass 1

Bubble_Sort ( A [ ] , N )
Step 1 : Repeat For P = 1 to N 1
Begin
Step 2 :
Repeat For J = 1 to N P
Begin
Step 3 :
If ( A [ J ] < A [ J 1 ] )
Swap ( A [ J ] , A [ J 1 ] )
End For
End For
Step 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 )

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[50],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 ]

Return

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

Insertion Sort

TEMP

78

23 45

32

36

23

78

45

32

36

23

45

78

32

36

23

45

78

32

36

23

45

32

23

32

45

78

36

23

32

36

45

78

36

Complexity of Insertion Sort

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

Insertion_Sort ( A [ ] , N )
Step 1 : Repeat For K = 1 to N 1
Begin
Step 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 While
Step 5 :
Set A [ J + 1 ] = Temp
End For
Step 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 ;
}
}

Selection Sort ( Select the smallest and Exchange )

Smallest

23

78 45

32

56

23

78

45

23

32

56

32

23

45

78

32

56

45

23

32

78

45

56

56

23

32

45

78

56

23

32

45

56

78

Complexity of Selection Sort

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

Selection_Sort ( A [ ] , N )
Step 1 : Repeat For K = 0 to N 2
Begin
Step 2 :
Set POS = K
Step 3 :
Repeat for J = K + 1 to N 1
Begin
If A[ J ] < A [ POS ]
Set POS = J
End For
Step 5 :
Swap A [ K ] with A [ POS ]
End For
Step 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 ;
}
}

Insertion sort

k = 1; k < n ; k++

temp = a [ k ]
j=k-1

Selection sort

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

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

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

a [ j + 1 ] = temp

pos = j

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

return
return

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

Original-list of 11 elements :

11 5

14 0

20

Set list [ 0 ] as pivot :

pivot

11 5

14 0

20

Rearrange ( partition ) the elements

into two sub lists :
pivot

Sub-list of
lesser elements

11 9

14 20

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.

Sub-list of
greater elements
Complexity of Quick Sort

Apply Quick-sort
recursively
on sub-list

Apply Quick-sort
recursively
on sub-list

Best Case : O ( n log n )

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

Partitioning for One Step of Quick Sort

Pivot

9
9
3

12

16

25 10

12

16

25 10

12

16

25 10

16

25 10 12

16

3
3

25 10 12
16 25 10 12

Quick Sort Program

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;
}

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 );
}

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

A
F

loc = left = beg

flag = 0, right = end
pivot = a [ loc ]

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

Flag == 0

loc == left

flag = 1

pivot <= a [ right ]

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

right = right - 1

return loc
F

loc == right

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

T
flag = 1

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

F

loc == left

loc = partition( a , beg , end )

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

quick_sort ( a , beg , end )

quick_sort ( a , beg , end )
return

Merge Sort ( Divide and conquer )

Divide the array

39 9
39 9
39 9
39

81 45 90 27 72 18

81 45

90 27 72 18

81 45

81

45

90 27
90

27

72 18
72

18

Merge the elements to sorted array

39

39
9

81

45

45 81

39 45 81
9

90

27

27 90

72

18

18 72

18 27 72 90

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 Algorithm
1. 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 complexity
Worst case - O(n log n)
Best case - O(nlogn) typical, O(n) natural variant
Average case - O( n log n )

Merge Sort - Program

void merge(int a[ ],int low,int high,int mid){
int i, j, k, c[50];
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);
}
}

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

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

Merge_Sort

i <= mid && j <= high

F

a[ i ] < a[ j ]

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

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

low < high

mid = ( low + high ) / 2

merge_sort (a, low, mid)

i <= mid
c[ k ] =a [ i ] ; k++ ; i++
j <= high

merge_sort (a, mid, high )

Merge (a, low,high , mid)

c[ k ] =a [ j ] ; k++ ; j++
i = low ; i < k ; i ++
a[ i ] = c [ i ]
return

Return

FaaDoOEngine
ers.com
Engaging Peers, Inspiring Careers!

Indias No.1 website for:

IIT-JEE/AIEEE preparation resources

Coaching centre packages
Engineering Major and Minor projects
Seminar reports
Paper presentations
EBOOKS
Resumes/CVs, and so much more