Experiment 1

1. Develop a program and measure the running time for Binary Search with Divide and
Conquer.

Aim: To develop a program and measure the running time for Binary Search with Divide and
Conquer.

Binary Search:

Searching is the process of finding some particular element in the list. If the element is present
in the list, then the process is called successful, and the process returns the location of that
element. Otherwise, the search is called unsuccessful.

Linear Search and Binary Search are the two popular searching techniques. Binary search is
the search technique that works efficiently on sorted lists. Hence, to search an element into
some list using the binary search technique, we must ensure that the list is sorted.

Binary search follows the divide and conquer approach in which the list is divided into two
halves, and the item is compared with the middle element of the list. If the match is found then,
the location of the middle element is returned. Otherwise, we search into either of the halves
depending upon the result produced through the match.

1. Time Complexity

Case Time Complexity

Average Case O(logn)

Worst Case O(logn)

2. Space Complexity

Space Complexity O(1)

o The space complexity of binary search is O(1).

PROGRAM CODE:

#include <stdio.h>

// Function to perform bubble sort

int i, j, temp;

for (i = 0; i < n - 1; i++) {

for (j = 0; j < n - i - 1; j++) {

if (a[j] > a[j + 1]) {

temp = a[j];

a[j] = a[j + 1];

a[j + 1] = temp;

int main() {

int i, low, high, mid, n, key, a[100];

printf("Enter number of elements: ");

scanf("%d", &n);

printf("Enter the elements of the array: ");

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

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

B_sort(a, n);

printf("The sorted array: ");

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

printf("%d ", a[i]);

printf("\n");

printf("Enter value to find: ");

scanf("%d", &key);

low = 0;
 high = n - 1;

mid = (low + high) / 2;

while (low <= high) {

if (a[mid] < key)

low = mid + 1;

else if (a[mid] == key) {

printf("%d found at location %d\n", key, mid + 1);

break;

} else

high = mid - 1;

mid = (low + high) / 2;

if (low > high)

printf("Not found! %d isn't present in the list.\n", key);

return 0;

OUTPUT:
Experiment 2
Develop a program and measure the running time for Merge Sort with Divide and Conquer
Aim: To Develop a program and measure the running time for Merge Sort with Divide
and Conquer

Description:

Merge Sort with Divide and Conquer

Merge Sort is a popular sorting algorithm that uses the divide and conquer strategy to
sort an array. It works by recursively dividing the array into smaller subarrays, sorting
those subarrays, and then merging them back together to form the sorted array.

Key Steps in Merge Sort:

1. Divide:

o Split the array into two halves, recursively continue to divide these halves
until each subarray has only one element.

2. Conquer:

o Sort the subarrays. Since each subarray now has only one element, they
are already sorted by default.

3. Combine:

o Merge the sorted subarrays back together to form the final sorted array.

1. Time Complexity

Case Time Complexity

Best Case O(n log n)

Average Case O(n log n)

Worst Case O(n log n)

2. Space Complexity

Space Complexity O(n)

// Function to merge two subarrays

void merge(int arr[], int left, int mid, int right) {

int n1 = mid - left + 1;

int n2 = right - mid;

int i, j, k;

int leftArray[n1], rightArray[n2];

// Copy data to temporary arrays

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

leftArray[i] = arr[left + i];

for (j = 0; j < n2; j++)

rightArray[j] = arr[mid + 1 + j];

i = 0;

j = 0;

k = left;

while (i < n1 && j < n2) {

if (leftArray[i] <= rightArray[j]) {

arr[k] = leftArray[i];

i++;

} else {

arr[k] = rightArray[j];

j++;

k++;

while (i < n1) {

arr[k] = leftArray[i];
 i++;

k++;

while (j < n2) {

arr[k] = rightArray[j];

j++;

k++;

// Function to perform merge sort

void mergeSort(int arr[], int left, int right) {

if (left < right) {

int mid = left + (right - left) / 2;

mergeSort(arr, left, mid);

mergeSort(arr, mid + 1, right);

merge(arr, left, mid, right);

// Function to print the array

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

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

printf("%d ", arr[i]);

printf("\n");

// Main function to test merge sort with user input

int main() {

int n;

printf("Enter number of elements: ");

int arr[n];

printf("Enter the elements of the array: ");

for (int i = 0; i < n; i++) {

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

printf("Given array is:\n");

printArray(arr, n);

mergeSort(arr, 0, n - 1);

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

printArray(arr, n);

return 0;

}
Experinment- 3: Develop a program and measure the running time for Quick Sort with Divide
and Conquer

Aim : Develop a program and measure the running time for Quick Sort with Divide and Conquer

Quick Sort is a highly efficient and widely used sorting algorithm that follows the divide and conquer
strategy. It works by selecting a "pivot" element from the array and partitioning the other elements
into two subarrays, according to whether they are less than or greater than the pivot. The subarrays are
then recursively sorted.

Key Steps in Quick Sort:

1. Choose a Pivot:

o Select a pivot element from the array. The choice of pivot can vary (first element, last
element, middle element, random element, etc.).

2. Partitioning:

o Rearrange the array so that all elements less than the pivot are on the left, and all
elements greater than the pivot are on the right. The pivot element is placed in its
correct position.

3. Recursively Sort:

o Apply the same process to the subarrays on the left and right of the pivot.

. Time Complexity

Case Time Complexity

Best Case O(n log n)

Average Case O(n log n)

Worst Case O(n2)

2. Space Complexity

Space Complexity O(log n)

#include <stdio.h>

// Function to swap two elements

void swap(int* a, int* b) {

*a = *b;

*b = temp;

// Function to partition the array

int partition(int arr[], int low, int high) {

int pivot = arr[high]; // pivot

int i = (low - 1); // Index of smaller element

for (int j = low; j <= high - 1; j++) {

// If current element is smaller than or equal to pivot

if (arr[j] <= pivot) {

i++; // increment index of smaller element

swap(&arr[i], &arr[j]);

swap(&arr[i + 1], &arr[high]);

return (i + 1);

// Function to implement Quick Sort

void quickSort(int arr[], int low, int high) {

if (low < high) {

// pi is partitioning index, arr[pi] is now at right place

int pi = partition(arr, low, high);

// Separately sort elements before and after partition

quickSort(arr, low, pi - 1);

quickSort(arr, pi + 1, high);

}
}

// Function to print the array

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

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

printf("%d ", arr[i]);

printf("\n");

// Main function to test Quick Sort with user input

int main() {

int n;

printf("Enter number of elements: ");

scanf("%d", &n);

int arr[n];

printf("Enter the elements of the array: ");

for (int i = 0; i < n; i++) {

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

printf("Given array is:\n");

printArray(arr, n);

quickSort(arr, 0, n - 1);

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

printArray(arr, n);

return 0;