Searching Algorithm:
Searching algorithm is the process of finding the existence of a specific element, within
an array, list, or tree. It is a fundamental operation which is used to retrieve data efficiently.
Types of Searching Algorithms
1. Linear Search 2. Binary Search
1. Linear Search : Linear Search is a basic searching algorithm that checks each element
of the data structure sequentially until the desired element is found.
Working of Linear Search :
i) Start from the first element.
ii) Compare each element with the key.
iii) If a match is found, return its position.
iv) If no match is found after checking all elements, return "Not Found".
Time Complexity :
• Best Case: O(1) → if key is the first element
• Worst Case: O(n) → if key is the last element or not present
• Space Complexity: O(1)
Prog.
#include <stdio.h>
void linearSearch(int arr[], int n, int key) {
int i;
for (i = 0; i < n; i++) {
if (arr[i] == key) {
printf("Element found at index %d (position %d).\n", i, i + 1);
return;
}
}
// If element is not found
printf("Element not found in the array.\n");
}
void main() {
int n, key, i;
// Input the number of elements
printf("Enter the number of elements in the array: ");
scanf("%d", &n);
int arr[n];
// Input elements of the array
printf("Enter %d elements:\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// Input the element to search
printf("Enter the element to search: ");
scanf("%d", &key);
// Call the linear search function
linearSearch(arr, n, key);
}
2. Binary Search : Binary Search is an efficient searching algorithm that finds the
position of a target value in a sorted array by repeatedly dividing the search interval
in half.
Note : It works only on arrays that are sorted in ascending or descending order.
Working of Binary Search :
Start with a sorted array.
Binary search only works on data that is already in ascending or descending order.
Initialize two variables:
low = 0 (start index)
high = n - 1 (end index)
Repeat while low <= high:
a. Calculate the middle index:
mid = (low + high) / 2
b. Compare the middle element arr[mid] with the key:
If arr[mid] == key:
→ Element is found at index mid
If arr[mid] < key:
→ Search in the right half by setting low = mid + 1
If arr[mid] > key:
→ Search in the left half by setting high = mid - 1
If the loop ends without finding the element:
→ The element is not present in the array.
Example:
Array: 10, 20, 30, 40, 50
Search Key: 30
• Step 1: low = 0, high = 4, mid = 2
• Step 2: arr[2] = 30 → Element found!
Time Complexity of Binary Search :
Binary Search reduces the search space by half with each step. So, for an array of n elements,
it will take at most log₂(n) steps.
Time Complexities
Case Time Complexity Explanation
Best O(1) If the element is found at the first middle check
Average O(log n) Each comparison cuts the array in half
Worst O(log n) Element is at the end or not present at all
Prog.
#include <stdio.h>
void binarySearch(int arr[], int n, int key) {
int low = 0;
int high = n - 1;
int mid;
while (low <= high) {
mid = (low + high) / 2;
if (arr[mid] == key) {
printf("Element found at index %d (position %d).\n", mid, mid + 1);
return;
} else if (arr[mid] < key) {
low = mid + 1;
} else {
high = mid - 1;
}
}
// If not found
printf("Element not found in the array.\n");
}
void main() {
int n, key;
// Input array size
printf("Enter the number of elements in the array: ");
scanf("%d", &n);
int arr[n];
// Input sorted array elements
printf("Enter %d sorted elements (ascending order):\n", n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// Input key to search
printf("Enter the element to search: ");
scanf("%d", &key);
// Call binary search
binarySearch(arr, n, key);
}
Sorting Algorithms:
Sorting algorithms are methods used to arrange the elements of a list or array in a specific
order — typically ascending or descending.
Sorting helps in organizing data and makes searching and other operations more efficient.
Types of Sorting Algorithms :
Sorting algorithms can be classified based on technique, complexity, and stability. Here's a
basic list of common types:
1. Bubble Sort 2. Selection Sort 3. Insertion Sort
4. Merge Sort 5. Quick Sort 6. Heap Sort
1. Bubble Sort : Bubble Sort is a simple sorting algorithm that works by repeatedly
swapping adjacent elements if they are in the wrong order.
It continues doing this until the entire array is sorted.
Working Process of Bubble Sort :
Start from the beginning of the array.
Compare the first and second elements:
o If the first is greater than the second, swap them.
Move to the next pair, compare and swap if needed.
Repeat this process for all elements.
After each full pass, the largest unsorted element "bubbles up" to its correct
position.
Repeat the passes until the array is sorted.
Example
Array: 5 3 8 4 2
• Pass 1: 3 5 4 2 8
• Pass 2: 3 4 2 5 8
• Pass 3: 3 2 4 5 8
• Pass 4: 2 3 4 5 8 =➔Sorted!
Time Complexity
Case Time Complexity
Best O(n) (if already sorted)
Average O(n²)
Worst O(n²)
Prog.
#include <stdio.h>
void bubbleSort(int arr[], int n) {
int i, j, temp;
for (i = 0; i < n - 1; i++) {
// Flag to check if any swapping happened
int swapped = 0;
for (j = 0; j < n - i - 1; j++) {
// Compare adjacent elements
if (arr[j] > arr[j + 1]) {
// Swap if elements are in wrong order
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = 1;
}
}
// If no two elements were swapped, the array is already sorted
if (swapped == 0) {
break;
}
}
}
void main() {
int n, i;
// Input number of elements
printf("Enter the number of elements: ");
scanf("%d", &n);
int arr[n];
// Input array elements
printf("Enter %d elements:\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// Call the bubble sort function
bubbleSort(arr, n);
// Print sorted array
printf("Sorted array in ascending order:\n");
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
}
2. Selection Sort : Selection Sort is a simple sorting algorithm that works by repeatedly
finding the smallest (or largest) element from the unsorted part of the array and swapping it
with the first unsorted element.
It divides the array into two parts:
• Sorted part (built from the front)
• Unsorted part (remaining elements)
Working Process of Selection Sort :
Start with the first element.
Find the smallest element in the unsorted part of the array.
Swap it with the first unsorted element.
Move to the next position and repeat the process until the array is fully sorted
Example
Array: 29, 10, 14, 37, 14
• Pass 1: Find minimum → 10 → Swap with 29 → 10, 29, 14, 37, 14
• Pass 2: Min is 14 → Swap with 29 → 10, 14, 29, 37, 14
• Pass 3: Min is 14 → Swap with 29 → 10, 14, 14, 37, 29
• Pass 4: Min is 29 → Swap with 37 → 10, 14, 14, 29, 37 ➔ Sorted
Time Complexity :
Case Time Complexity
Best O(n²)
Average O(n²)
Worst O(n²)
Prog.
#include <stdio.h>
void selectionSort(int arr[], int n) {
int i, j, minIndex, temp;
for (i = 0; i < n - 1; i++) {
minIndex = i;
// Find the index of the smallest element in the unsorted part
for (j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
// Swap the found minimum element with the first unsorted element
if (minIndex != i) {
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
void main() {
int n, i;
// Input array size
printf("Enter the number of elements: ");
scanf("%d", &n);
int arr[n];
// Input array elements
printf("Enter %d elements:\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// Sort the array using Selection Sort
selectionSort(arr, n);
// Print sorted array
printf("Sorted array in ascending order:\n");
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
}
3. Insertion Sort : Insertion Sort is a sorting algorithm in which elements are picked
one by one and inserted into their correct position in the already sorted part of the
array.
It maintains a sorted subarray on the left side and gradually inserts each new element
into its correct place.
Working Process of Insertion Sort :
Assume the first element is already sorted.
Take the next element and compare it with the elements in the sorted part.
Shift elements to the right until the correct position is found.
Insert the current element into that position.
Repeat for all remaining elements.
Example
Array: 5, 3, 4, 1
• Pass 1: 3 inserted before 5 → 3, 5, 4, 1
• Pass 2: 4 inserted between 3 and 5 → 3, 4, 5, 1
• Pass 3: 1 inserted at the beginning → 1, 3, 4, 5 ➔ Sorted
Time Complexity
Case Time Complexity
O(n) (already
Best
sorted)
Average O(n²)
Worst O(n²)
#include <stdio.h>
void insertionSort(int arr[], int n) {
int i, j, key;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;
// Move elements that are greater than key
// to one position ahead of their current position
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
// Insert the key into its correct position
arr[j + 1] = key;
}
}
void main() {
int n, i;
// Input number of elements
printf("Enter the number of elements: ");
scanf("%d", &n);
int arr[n];
// Input elements
printf("Enter %d elements:\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// Sort the array using Insertion Sort
insertionSort(arr, n);
// Print sorted array
printf("Sorted array in ascending order:\n");
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
}
4. Merge Sort : Merge Sort is a divide and conquer sorting algorithm that divides the
array into two halves, sorts them recursively, and then merges the sorted halves to get
the final sorted array.
Working Process of Merge Sort :
Divide the array into two halves.
Recursively sort both halves.
Merge the two sorted halves into one sorted array.
Example
Array: 6, 3, 8, 2
1. Divide: [6, 3] and [8, 2]
2. Divide again: [6] [3] [8] [2]
3. Merge: [3, 6] and [2, 8]
4. Final merge: [2, 3, 6, 8] ➔ Sorted
Time Complexity :
Time
Case
Complexity
Best O(n log n)
Average O(n log n)
Worst O(n log n)
Prog.
#include <stdio.h>
// Merge two halves of the array
void merge(int arr[], int left, int mid, int right) {
int i, j, k;
int n1 = mid - left + 1; // Size of left half
int n2 = right - mid; // Size of right half
// Temporary arrays
int L[n1], R[n2];
// Copy data to temp arrays
for (i = 0; i < n1; i++)
L[i] = arr[left + i];
for (j = 0; j < n2; j++)
R[j] = arr[mid + 1 + j];
// Merge the temp arrays back into arr[]
i = 0;
j = 0;
k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
// Copy remaining elements of L[]
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
// Copy remaining elements of R[]
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
// Recursive merge sort function
void mergeSort(int arr[], int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
// Sort first and second halves
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
// Merge the sorted halves
merge(arr, left, mid, right);
}
}
void main() {
int n, i;
printf("Enter the number of elements: ");
scanf("%d", &n);
int arr[n];
printf("Enter %d elements:\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// Call merge sort
mergeSort(arr, 0, n - 1);
// Print sorted array
printf("Sorted array in ascending order:\n");
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
}
5. Quick Sort : Quick Sort is a fast and efficient divide and conquer sorting algorithm
that works by selecting a pivot element, partitioning the array around the pivot, and
then recursively sorting the left and right subarrays.
Working Process of Quick Sort :
Choose a pivot element from the array (commonly first, last, or middle element).
Partition the array:
Place elements smaller than pivot on the left,
Place elements greater than pivot on the right.
Recursively apply Quick Sort on the left and right parts.
The array becomes sorted after all partitions are complete.
Example
Array: 5, 3, 8, 4, 2
• Choose pivot = 2
→ Partition: [2] | [3, 8, 4, 5]
• Choose pivot = 3
→ Partition: [2, 3] | [4, 8, 5]
• Continue recursively
→ Final sorted: [2, 3, 4, 5, 8]
Time Complexity
Case Time Complexity
Best O(n log n)
Average O(n log n)
Worst O(n²) → happens when array is already sorted and poor pivot is chosen
#include <stdio.h>
// Function to swap two elements
void swap(int arr[], int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// Partition function using last element as pivot
int partition(int arr[], int low, int high) {
int pivot = arr[high]; // Pivot is the last element
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] < pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, high); // Place pivot in correct position
return i + 1;
}
// Quick Sort function
void quickSort(int arr[], int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1); // Sort left part
quickSort(arr, pi + 1, high); // Sort right part
}
}
void main() {
int n;
printf("Enter the number of elements: ");
scanf("%d", &n);
int arr[n];
printf("Enter %d elements:\n", n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// Call Quick Sort
quickSort(arr, 0, n - 1);
// Print sorted array
printf("Sorted array in ascending order:\n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
}
6. Heap Sort : Heap Sort is a comparison-based sorting algorithm that uses a binary heap
data structure (usually a max heap) to sort elements.
It builds a heap from the input data, then repeatedly removes the maximum element from the
heap and places it at the end of the array.
Q. What is a Heap?
Ans : A heap is a special binary tree:
o Max Heap: Each parent node is greater than or equal to its children.
o Min Heap: Each parent node is less than or equal to its children.
• In Heap Sort, we use a Max Heap to get the largest element at the root.
Working Process of Heap Sort :
Build a Max Heap from the array.
The largest element is now at the root (index 0).
Swap it with the last element of the array.
Reduce the heap size by 1 (ignore the last sorted element).
Heapify the root again to maintain the heap property.
Repeat steps 3–5 until the entire array is sorted.
Example (Array):
Input: 4, 10, 3, 5, 1
1. Build Max Heap → 10, 5, 3, 4, 1
2. Swap 10 with 1 → 1, 5, 3, 4, 10
3. Heapify again → 5, 4, 3, 1, 10
4. Repeat...
Final sorted array: 1, 3, 4, 5, 10
Time Complexity
Time
Case
Complexity
Best O(n log n)
Average O(n log n)
Worst O(n log n)
Prog .
#include <stdio.h>
// Function to heapify a subtree rooted at index i
void heapify(int arr[], int n, int i) {
int largest = i; // Initialize largest as root
int left = 2 * i + 1; // left child
int right = 2 * i + 2; // right child
// If left child is larger than root
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
// If right child is larger than largest so far
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
// If largest is not root
if (largest != i) {
// Swap arr[i] and arr[largest]
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
// Recursively heapify the affected sub-tree
heapify(arr, n, largest);
}
}
// Main function to do heap sort
void heapSort(int arr[], int n) {
// Build a max heap
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
// One by one extract elements from heap
for (int i = n - 1; i >= 0; i--) {
// Move current root to end
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// call max heapify on the reduced heap
heapify(arr, i, 0);
}
}
void main() {
int n;
printf("Enter number of elements: ");
scanf("%d", &n);
int arr[n];
printf("Enter %d elements:\n", n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// Perform heap sort
heapSort(arr, n);
// Print sorted array
printf("Sorted array in ascending order:\n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
}
