UNIT-III

1)What is Search?
Search is a process of finding a value in a list of values. In other words, searching is
the process of locating given value position in a list of values.

Linear Search Algorithm (Sequential Search Algorithm)

Linear search algorithm finds a given element in a list of elements with O(n) time
complexity where n is total number of elements in the list. This search process
starts comparing search element with the first element in the list. If both are
matched then result is element found otherwise search element is compared with
the next element in the list. Repeat the same until search element is compared with
the last element in the list, if that last element also doesn't match, then the result is
"Element not found in the list". That means, the search element is compared with
element by element in list.

Linear search is implemented using following steps...

• Step 1 - Read the search element from the user.

• Step 2 - Compare the search element with the first element in the list.
• Step 3 - If both are matched, then display "Given element is found!!!" and
terminate the function
• Step 4 - If both are not matched, then compare search element with the next
element in the list.
• Step 5 - Repeat steps 3 and 4 until search element is compared with last
element in the list.
• Step 6 - If last element in the list also doesn't match, then display "Element is
not found!!!" and terminate the function.

Example
Consider the following list of elements and the element to be searched is 41.
Implementation of Linear Search Algorithm using C Programming Language:
#include<stdio.h>
#include<conio.h>

void main(){
int list[20],size,i,sElement;

printf("Enter size of the list: ");

scanf("%d",&size);
 printf("Enter any %d integer values: ",size);
for(i = 0; i < size; i++)
scanf("%d",&list[i]);

printf("Enter the element to be Search: ");

scanf("%d",&sElement);

// Linear Search Logic

for(i = 0; i < size; i++)
{
if(sElement == list[i])
{
printf("Element is found at %d index", i);
break;
}
}
if(i == size)
printf("Given element is not found in the list!!!");
getch();
}

Binary Search Algorithm:

Binary search algorithm finds a given element in a list of elements with O(log n)
time complexity where n is total number of elements in the list. The binary search
algorithm can be used with only a sorted list of elements. That means the binary
search is used only with a list of elements that are already arranged in an order. The
binary search can not be used for a list of elements arranged in random order. This
search process starts comparing the search element with the middle element in the
list. If both are matched, then the result is "element found". Otherwise, we check
whether the search element is smaller or larger than the middle element in the list. If
the search element is smaller, then we repeat the same process for the left sublist of
the middle element. If the search element is larger, then we repeat the same process
for the right sublist of the middle element. We repeat this process until we find the
search element in the list or until we left with a sublist of only one element. And if
that element also doesn't match with the search element, then the result is "Element
not found in the list".

Binary search is implemented using following steps...

Step 1 - Read the search element from the user.

Step 2 - Find the middle element in the sorted list.
Step 3 - Compare the search element with the middle element in the sorted list.
Step 4 - If both are matched, then display "Given element is found!!!" and terminate
the function.
Step 5 - If both are not matched, then check whether the search element is smaller
or larger than the middle element.
Step 6 - If the search element is smaller than middle element, repeat steps 2, 3, 4 and
5 for the left sublist of the middle element.
Step 7 - If the search element is larger than middle element, repeat steps 2, 3, 4 and
5 for the right sublist of the middle element.
Step 8 - Repeat the same process until we find the search element in the list or until
sublist contains only one element.
Step 9 - If that element also doesn't match with the search element, then display
"Element is not found in the list!!!" and terminate the function.

Implementation of Binary Search Algorithm using C Programming Language:

#include<stdio.h>
#include<conio.h>

void main()
{
int first, last, middle, size, i, sElement, list[100];
clrscr();

printf("Enter the size of the list: ");

 scanf("%d",&size);

printf("Enter %d integer values in Assending order\n", size);

for (i = 0; i < size; i++)

scanf("%d",&list[i]);

printf("Enter value to be search: ");

scanf("%d", &sElement);

first = 0;
last = size - 1;
middle = (first+last)/2;

while (first <= last) {

if (list[middle] < sElement)
first = middle + 1;
else if (list[middle] == sElement) {
printf("Element found at index %d.\n",middle);
break;
}
else
last = middle - 1;

middle = (first + last)/2;

}
if (first > last)
printf("Element Not found in the list.");
getch();
}

2)Sorting:
a)Bubble Sort Algorithm:
Bubble Sort is a simple algorithm which is used to sort a given set of n elements
provided in form of an array with n number of elements. Bubble Sort compares all
the element one by one and sort them based on their values.

If the given array has to be sorted in ascending order, then bubble sort will start by
comparing the first element of the array with the second element, if the first element
is greater than the second element, it will swap both the elements, and then move on
to compare the second and the third element, and so on.

If we have total n elements, then we need to repeat this process for n-1 times.

It is known as bubble sort, because with every complete iteration the largest element
in the given array, bubbles up towards the last place or the highest index, just like a
water bubble rises up to the water surface.

Sorting takes place by stepping through all the elements one-by-one and comparing
it with the adjacent element and swapping them if required.

Implementing Bubble Sort Algorithm

Following are the steps involved in bubble sort(for sorting a given array in ascending
order):

Starting with the first element(index = 0), compare the current element with the next
element of the array.
If the current element is greater than the next element of the array, swap them.
If the current element is less than the next element, move to the next element. Repeat
Step 1.
Let's consider an array with values {5, 1, 6, 2, 4, 3}

Below, we have a pictorial representation of how bubble sort will sort the given
array.
So as we can see in the representation above, after the first iteration, 6 is placed at
the last index, which is the correct position for it.

Similarly after the second iteration, 5 will be at the second last index, and so on.

Code for bubble sort:

// below we have a simple C program for bubble sort

#include <stdio.h>
void bubbleSort(int arr[], int n)
{
int i, j, temp;
for(i = 0; i < n; i++)
{
for(j = 0; j < n-i-1; j++)
{
if( arr[j] > arr[j+1])
{
// swap the elements
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}

// print the sorted array

printf("Sorted Array: ");
for(i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
}

int main()
{
int arr[100], i, n, step, temp;
// ask user for number of elements to be sorted
printf("Enter the number of elements to be sorted: ");
scanf("%d", &n);
// input elements if the array
for(i = 0; i < n; i++)
{
 printf("Enter element no. %d: ", i+1);
scanf("%d", &arr[i]);
}
// call the function bubbleSort
bubbleSort(arr, n);

return 0;
}

Complexity Analysis of Bubble Sort

In Bubble Sort, n-1 comparisons will be done in the 1st pass, n-2 in 2nd pass, n-3 in
3rd pass and so on. So the total number of comparisons will be,

(n-1) + (n-2) + (n-3) + ..... + 3 + 2 + 1

Sum = n(n-1)/2

i.e O(n2)

Hence the time complexity of Bubble Sort is O(n2).

The main advantage of Bubble Sort is the simplicity of the algorithm.

The space complexity for Bubble Sort is O(1), because only a single additional
memory space is required i.e. for temp variable.

Also, the best case time complexity will be O(n), it is when the list is already
sorted.

Following are the Time and Space complexity for the Bubble Sort algorithm.

• Worst Case Time Complexity [ Big-O ]: O(n2)

• Best Case Time Complexity [Big-omega]: O(n)

 • Average Time Complexity [Big-theta]: O(n2)

• Space Complexity: O(1)

b)Insertion Sort Algorithm

Consider you have 10 cards out of a deck of cards in your hand. And they are sorted,
or arranged in the ascending order of their numbers.

If I give you another card, and ask you to insert the card in just the right position,
so that the cards in your hand are still sorted. What will you do?

Well, you will have to go through each card from the starting or the back and find
the right position for the new card, comparing it's value with each card. Once you
find the right position, you will insert the card there.

Similarly, if more new cards are provided to you, you can easily repeat the same
process and insert the new cards and keep the cards sorted too.

This is exactly how insertion sort works. It starts from the index 1(not 0), and each
index starting from index 1 is like a new card, that you have to place at the right
position in the sorted subarray on the left.

Following are some of the important characteristics of Insertion Sort:

1. It is efficient for smaller data sets, but very inefficient for larger lists.

2. Insertion Sort is adaptive, that means it reduces its total number of steps if a
partially sorted array is provided as input, making it efficient.

3. It is better than Selection Sort and Bubble Sort algorithms.

4. Its space complexity is less. Like bubble Sort, insertion sort also requires a
single additional memory space.

5. It is a stable sorting technique, as it does not change the relative order of

elements which are equal.
How Insertion Sort Works?
Following are the steps involved in insertion sort:

We start by making the second element of the given array, i.e. element at index 1,
the key. The key element here is the new card that we need to add to our existing
sorted set of cards(remember the example with cards above).
We compare the key element with the element(s) before it, in this case, element at
index 0:
If the key element is less than the first element, we insert the key element before the
first element.
If the key element is greater than the first element, then we insert it after the first
element.
Then, we make the third element of the array as key and will compare it with
elements to it's left and insert it at the right position.
And we go on repeating this, until the array is sorted.
Let's consider an array with values {5, 1, 6, 2, 4, 3}

Below, we have a pictorial representation of how bubble sort will sort the given
array.
 As you can see in the diagram above, after picking a key, we start iterating
over the elements to the left of the key.

We continue to move towards left if the elements are greater than the key element
and stop when we find the element which is less than the key element.

And, insert the key element after the element which is less than the key element.

Note: You can learn the program for insertion sort which I have given in the
class.
Program:
#include <stdio.h>

void insertionSort(int arr[], int n) {

for (int step = 1; step < n; step++) {
int x = arr[step];
int j = step - 1;
while (x < arr[j] && j >= 0) {
arr[j + 1] = arr[j];
--j;
}
arr[j + 1] = x;
}
}

void printArray(int arr[], int size) {

for (int i = 0; i < size; ++i) {
printf("%d ", arr[i]);
}
printf("\n");
}

int main() {
int arr[10000];
int n;
 printf("Enter size of the array: ");
scanf("%d", &n);
printf("Enter the array elements: ");
for(int i = 0; i < n; i++)
scanf("%d", &arr[i]);
insertionSort(arr, n);
printf("After sorting, the array is: ");
printArray(arr, n);
}
Complexity Analysis of Insertion Sort:
Worst Case Time Complexity [ Big-O ]: O(n2)

Best Case Time Complexity [Big-omega]: O(n)

Average Time Complexity [Big-theta]: O(n2)

Space Complexity: O(1)

c)Selection Sort Algorithm:

Selection sort is conceptually the most simplest sorting algorithm. This algorithm
will first find the smallest element in the array and swap it with the element in the
first position, then it will find the second smallest element and swap it with the
element in the second position, and it will keep on doing this until the entire array is
sorted.

It is called selection sort because it repeatedly selects the next-smallest element and
swaps it into the right place.

Step by Step Process:

The selection sort algorithm is performed using the following steps...

Step 1 - Select the first element of the list (i.e., Element at first position in the list).
Step 2: Compare the selected element with all the other elements in the list.
Step 3: In every comparision, if any element is found smaller than the selected
element (for Ascending order), then both are swapped.
Step 4: Repeat the same procedure with element in the next position in the list till
the entire list is sorted.
Selection Sort Logic:

//Selection sort logic

for(i=0; i<size; i++){

for(j=i+1; j<size; j++){
if(list[i] > list[j])
{
temp=list[i];
list[i]=list[j];
list[j]=temp;
}
}
}
Example:
#include<stdio.h>
#include<conio.h>

void main(){

int size,i,j,temp,list[100];
clrscr();

printf("Enter the size of the List: ");

scanf("%d",&size);

printf("Enter %d integer values: ",size);

for(i=0; i<size; i++)
scanf("%d",&list[i]);
 //Selection sort logic

for(i=0; i<size; i++){

for(j=i+1; j<size; j++){
if(list[i] > list[j])
{
temp=list[i];
list[i]=list[j];
list[j]=temp;
}
}
}

printf("List after sorting is: ");

for(i=0; i<size; i++)
printf(" %d",list[i]);

getch();
}

Complexity Analysis of Selection Sort:

Time Complexity: The time complexity of Selection Sort is O(N 2) as there are two
nested loops:
• One loop to select an element of Array one by one = O(N)
• Another loop to compare that element with every other Array element = O(N)
Therefore overall complexity = O(N)*O(N) = O(N*N) = O(N 2)
Auxiliary Space: O(1) as the only extra memory used is for temporary variable
while swapping two values in Array. The good thing about selection sort is it never
makes more than O(n) swaps and can be useful when memory write is a costly
operation.

d)QuickSort:
Quick sort is a fast sorting algorithm used to sort a list of elements. Quick sort
algorithm is invented by C. A. R. Hoare.
The quick sort algorithm attempts to separate the list of elements into two parts and
then sort each part recursively. That means it use divide and conquer strategy. In
quick sort, the partition of the list is performed based on the element called pivot.
Here pivot element is one of the elements in the list.
The list is divided into two partitions such that "all elements to the left of pivot are
smaller than the pivot and all elements to the right of pivot are greater than or equal
to the pivot".

Step by Step Process (Algorithm for quick Sort):

In Quick sort algorithm, partitioning of the list is performed using following steps...

Step 1 - Consider the first element of the list as pivot (i.e., Element at first position
in the list).
Step 2 - Define two variables i and j. Set i and j to first and last elements of the list
respectively.
Step 3 - Increment i until list[i] > pivot then stop.
Step 4 - Decrement j until list[j] < pivot then stop.
Step 5 - If i < j then exchange list[i] and list[j].
Step 6 - Repeat steps 3,4 & 5 until i > j.
Step 7 - Exchange the pivot element with list[j] element.

Complexity of the Quick Sort Algorithm

To sort an unsorted list with 'n' number of elements, we need to make ((n-1)+(n-
2)+(n-3)+......+1) = (n (n-1))/2 number of comparisions in the worst case. If the list
is already sorted, then it requires 'n' number of comparisions.

Worst Case : O(n2)

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

e)Mergesort:
In Merge Sort, the given unsorted array with n elements, is divided into n subarrays,
each having one element, because a single element is always sorted in itself. Then,
it repeatedly merges these subarrays, to produce new sorted subarrays, and in the
end, one complete sorted array is produced.

The concept of Divide and Conquer involves three steps:

1. Divide the problem into multiple small problems.

2. Conquer the subproblems by solving them. The idea is to break down the
problem into atomic subproblems, where they are actually solved.

3. Combine the solutions of the subproblems to find the solution of the actual
problem.

How Merge Sort Works?

As we have already discussed that merge sort utilizes divide-and-conquer rule to
break the problem into sub-problems, the problem in this case being, sorting a given
array.

In merge sort, we break the given array midway, for example if the original array
had 6 elements, then merge sort will break it down into two subarrays
with 3 elements each.

But breaking the orignal array into 2 smaller subarrays is not helping us in sorting
the array.

So we will break these subarrays into even smaller subarrays, until we have multiple
subarrays with single element in them. Now, the idea here is that an array with a
single element is already sorted, so once we break the original array into subarrays
which has only a single element, we have successfully broken down our problem
into base problems.

And then we have to merge all these sorted subarrays, step by step to form one single
sorted array.

Let's consider an array with values {14, 7, 3, 12, 9, 11, 6, 12}

Below, we have a pictorial representation of how merge sort will sort the given array.
In merge sort we follow the following steps:

1. We take a variable p and store the starting index of our array in this. And we
take another variable r and store the last index of array in it.

2. Then we find the middle of the array using the formula (p + r)/2 and mark the
middle index as q, and break the array into two subarrays, from p to q and
from q + 1 to r index.

3. Then we divide these 2 subarrays again, just like we divided our main array
and this continues.

4. Once we have divided the main array into subarrays with single elements, then
we start merging the subarrays.

MergeSort Program:

/*
a[] is the array, p is starting index, that is 0,
and r is the last index of array.
*/

#include <stdio.h>

// lets take a[5] = {32, 45, 67, 2, 7} as the array to be sorted.

// merge sort function

void mergeSort(int a[], int p, int r)
{
int q;
if(p < r)
{
q = (p + r) / 2;
 mergeSort(a, p, q);
mergeSort(a, q+1, r);
merge(a, p, q, r);
}
}

// function to merge the subarrays

void merge(int a[], int p, int q, int r)
{
int b[5]; //same size of a[]
int i, j, k;
k = 0;
i = p;
j = q + 1;
while(i <= q && j <= r)
{
if(a[i] < a[j])
{
b[k++] = a[i++]; // same as b[k]=a[i]; k++; i++;
}
else
{
b[k++] = a[j++];
}
}

while(i <= q)
{
b[k++] = a[i++];
}

while(j <= r)
{
b[k++] = a[j++];
}
 for(i=r; i >= p; i--)
{
a[i] = b[--k]; // copying back the sorted list to a[]
}
}

// function to print the array

void printArray(int a[], int size)
{
int i;
for (i=0; i < size; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}

int main()
{
int arr[] = {32, 45, 67, 2, 7};
int len = sizeof(arr)/sizeof(arr[0]);

printf("Given array: \n");

printArray(arr, len);

// calling merge sort

mergeSort(arr, 0, len - 1);

printf("\nSorted array: \n");

printArray(arr, len);
return 0;
}
Complexity Analysis of Merge Sort:

Merge Sort is quite fast, and has a time complexity of O(n*log n). It is also a stable
sort, which means the "equal" elements are ordered in the same order in the sorted
list.

In this section we will understand why the running time for merge sort is O(n*log
n).

As we have already learned in Binary Search that whenever we divide a number into
half in every step, it can be represented using a logarithmic function, which is log
n and the number of steps can be represented by log n + 1(at most)

Also, we perform a single step operation to find out the middle of any subarray,
i.e. O(1).

And to merge the subarrays, made by dividing the original array of n elements, a
running time of O(n) will be required.

Hence the total time for mergeSort function will become n(log n + 1), which gives
us a time complexity of O(n*log n).

Worst Case Time Complexity [ Big-O ]: O(n*log n)

Best Case Time Complexity [Big-omega]: O(n*log n)

Average Time Complexity [Big-theta]: O(n*log n)

Space Complexity: O(n)

• Time complexity of Merge Sort is O(n*Log n) in all the 3 cases (worst,

average and best) as merge sort always divides the array in two halves and
takes linear time to merge two halves.

• It requires equal amount of additional space as the unsorted array. Hence its
not at all recommended for searching large unsorted arrays.

• It is the best Sorting technique used for sorting Linked Lists.

f)Heap Sort Algorithm:

What is a Heap ?

Heap is a special tree-based data structure, that satisfies the following special heap
properties:

Shape Property: Heap data structure is always a Complete Binary Tree, which
means all levels of the tree are fully filled.

Heap Property: All nodes are either greater than or equal to or less than or
equal to each of its children. If the parent nodes are greater than their child
nodes, heap is called a Max-Heap, and if the parent nodes are smaller than their
child nodes, heap is called Min-Heap.
How Heap Sort Works?

Heap sort algorithm is divided into two basic parts:

• Creating a Heap of the unsorted list/array.

• Then a sorted array is created by repeatedly removing the largest/smallest

element from the heap, and inserting it into the array. The heap is
reconstructed after each removal.

Initially on receiving an unsorted list, the first step in heap sort is to create a Heap
data structure(Max-Heap or Min-Heap). Once heap is built, the first element of the
Heap is either largest or smallest(depending upon Max-Heap or Min-Heap), so we
put the first element of the heap in our array. Then we again make heap using the
remaining elements, to again pick the first element of the heap and put it into the
array. We keep on doing the same repeatedly untill we have the complete sorted list
in our array.
In the below algorithm, initially heapsort() function is called, which
calls heapify() to build the heap.

#include <stdio.h>
void heapify(int arr[],int n,int i);
void heapsort(int arr[],int n);
int main() {
int arr[15], i, n;
printf("Enter array size : ");
scanf("%d", &n);
printf("Enter %d elements : ", n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
printf("Before sorting the elements are : ");
for (i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
heapsort(arr,n);
printf("After sorting the elements are : ");
for (i = 0; i < n; i++)
{
printf("%d ",arr[i]);
}
return 0;
}

void heapify(int arr[],int n,int i) {

int largest=i;
int l=2*i+1;
int r=2*i+2;
int temp;
if (l<n && arr[l]>arr[largest])
largest=l;
 if(r<n && arr[r]>arr[largest])
largest=r;
if (largest!=i) {
temp=arr[i];
arr[i]=arr[largest];
arr[largest]=temp;
heapify(arr,n,largest);
}
}

void heapsort(int arr[],int n)

{
int i,temp;
for (i=n/2-1;i>=0;i--)
{
heapify(arr,n,i);
}
for (i=n-1;i>=0;i--)
{
temp=arr[0];
arr[0]=arr[i];
arr[i]=temp;
heapify(arr,i,0);
}
}

Complexity Analysis of Heap Sort:

Worst Case Time Complexity: O(n*log n)

Best Case Time Complexity: O(n*log n)

Average Time Complexity: O(n*log n)

Space Complexity : O(1)

• Heap sort is not a Stable sort, and requires a constant space for sorting a list.

• Heap Sort is very fast and is widely used for sorting.