1|Page

Program 1.
Write recursive programme which computes the nth Fibonacci number
#include <stdio.h>
int fibonacci(int n) {
if (n <= 1) {
return n;
}
else
{
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
int main() {
int n;
printf("Enter the value of n: ");
scanf("%d", &n);
if (n < 0) {
printf("Fibonacci numbers are only defined for non-negative integers.\n");
}
else {
int result = fibonacci(n);
printf("The %dth Fibonacci number is: %d\n", n, result);
}
return 0;
}

Output
2|Page

Program 2.
Write recursive programme which computes the factorial of a given number.

#include <stdio.h>
unsigned long long factorial(int n) {
if (n == 0 || n == 1) {
return 1;
}
else
{
return n * factorial(n - 1);
}
}
int main() {
int num;
printf("Enter a non-negative integer: ");
scanf_s("%d", &num);
if (num < 0) {
printf("Factorial is not defined for negative numbers.\n");
}
else {
unsigned long long result = factorial(num);
printf("Factorial of %d is %llu\n", num, result);
}
return 0;
}

Output
3|Page

Program 3.

Write a program to implement linear search using arrays

#include <stdio.h>
int main()
{
int array[100], search, c, n;
printf("Enter number of elements in array\n");
scanf("%d", &n);
printf("Enter %d integer(s)\n", n);
for (c = 0; c < n; c++)
scanf("%d", &array[c]);
printf("Enter a number to search\n");
scanf_s("%d", &search);
for (c = 0; c < n; c++)
{
if (array[c] == search)
{
printf("%d is present at location %d.\n", search, c + 1);
break;
}
}
if (c == n)
{
printf("%d isn't present in the array.\n", search);
}
return 0;
}

Output
4|Page

Program 4.
Write a program to implement binary search using arrays
#include <stdio.h>
int binarySearch(int a[], int beg, int end, int val)
{
int mid;
if(end >= beg)
{ mid = (beg + end)/2;
if(a[mid] == val)
{
return mid+1;
}
else if(a[mid] < val)
{
return binarySearch(a, mid+1, end, val);
}
else
{
return binarySearch(a, beg, mid-1, val);
}
}
return -1;
}
int main() {
int a[] = {11, 14, 25, 30, 40, 41, 52, 57, 70};
int val = 40;
int n = sizeof(a) / sizeof(a[0]);
int res = binarySearch(a, 0, n-1, val);
printf("The elements of the array are - ");
for (int i = 0; i < n; i++)
printf("%d ", a[i]);
printf("\nElement to be searched is - %d", val);
if (res == -1)
printf("\nElement is not present in the array");
else
printf("\nElement is present at %d position of array", res);
return 0;
}
Output
5|Page

Program 5.
Write c program to implement bubblesort, to sort a given list of integers in ascending
order.
#include<stdio.h>
void boubble_sort(int arr[],int n)
int i, j;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, n);
printf("Sorted array: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
Output
6|Page

Program 6.
Program to implement INSERTION SORT to sort a list of numbers
# include <stdio.h>
#define max 20
int main()
{
int arr[max], i, j, temp, len;
printf("Input numbers you want to input: ");
scanf_s("%d", &len);
printf("Input %d values to sort\n", len);
for (i = 0; i < len; i++)
scanf_s("%d", &arr[i]);
for (i = 1; i < len; i++)
{
for (j = i; j > 0; j--)
{
if (arr[j] < arr[j - 1])
{
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
printf("\nelements after sorting\n");
for (i = len; i >= 0; i--)
printf("%d\n", arr[i]);
return 0;
}
OUTPUT
7|Page

Program 7

Program to implement insertion sort to sort a given list of integers in ascending order
# include <stdio.h>
#define max 20
int main()
{
int arr[max], i, j, temp, len;
printf("Input numbers you want to input: ");
scanf_s("%d", &len);
printf("Input %d values to sort\n", len);
for (i = 0; i < len; i++)
scanf_s("%d", &arr[i]);
for (i = 1; i < len; i++)
{
for (j = i; j > 0; j--)
{
if (arr[j] < arr[j - 1])
{
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
printf("\nThe ascending order of the values:\n");
for (i = 0; i < len; i++)
printf("%d\n", arr[i]);
return 0;
}
OUTPUT
8|Page

PROGRAM 8
Write a C program that implement merge sort , to sort a given list of integers in ascending
order.
#include<stdio.h>
void merge(int arr[], int l , int mid, int r){
int n1=mid-l+1;
int n2=r-mid;
int a[n1];
int b[n2];
for(int i=0;i<n1;i++)
{
a[i]=arr[l+i];
}
for (int i=0;i<n2;i++)
{
b[i]=arr[mid+1+i];
}
int i=0;
int j=0;
int k=l;
while(i<n1 && j<n2)
{
if(a[i]<b[j])
{
arr[k]=a[i];
k++;i++;
}
else
{
arr[k]=b[j];
k++;j++;
}
}
while(i<n1)
{
arr[k]=a[i];
k++;i++;
}
while (j<n2){
arr[k]=b[j];
k++;j++;
}
}
void mergesort(int arr[], int l, int r)
{
if(l<r){
int mid = (l+r)/2;
mergesort(arr,l,mid);
mergesort(arr,mid+1,r);
9|Page

merge(arr,l,mid,r);
}
}
int main()
{
int arr[]= {5,2,6,4,8};
mergesort(arr,0,4);
printf("The sorted elements are :\n");
for(int i=0;i<5;i++)
{
printf(" %d",arr[i]);
}
return 0;
}
OUTPUT
10 | P a g e

PROGRAM 9.

Write a program to implement binary tree

#include <stdio.h>

struct Node {
int data;
struct Node* left;
struct Node* right;
};
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
struct Node* insertNode(struct Node* root, int data) {
if (root == NULL) {
return createNode(data);
}
if (data < root->data) {
root->left = insertNode(root->left, data);
}
else if (data > root->data) {
root->right = insertNode(root->right, data);
}
return root;
}
void inOrderTraversal(struct Node* root) {
if (root != NULL) {
inOrderTraversal(root->left);
printf("%d ", root->data);
inOrderTraversal(root->right);
}
}
int main() {
struct Node* root = NULL;
root = insertNode(root, 50);
insertNode(root, 30);
insertNode(root, 20);
insertNode(root, 40);
insertNode(root, 70);
insertNode(root, 60);
insertNode(root, 80);
printf("Binary tree: ");
inOrderTraversal(root);
return 0;
11 | P a g e

OUTPUT
12 | P a g e

PROGRAM 10
Write a program to implement heap sort using arrays

#include <stdio.h>
void heap(int arr[], int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest])
largest = left;
if (right < n && arr[right] > arr[largest])
largest = right;
if (largest != i) {
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
heap(arr, n, largest);
}
}
void heapSort(int arr[], int n) {
for (int i = n / 2 - 1; i >= 0; i--)
heap(arr, n, i);
for (int i = n - 1; i > 0; i--) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
heap(arr, i, 0);
}
}
void printArray(int arr[], int n) {
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main() {
int arr[] = { 12, 11, 13, 5, 6, 7 };
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: \n");
printArray(arr, n);
heapSort(arr, n);
printf("Sorted array: \n");
printArray(arr, n);
13 | P a g e

return 0;
}

OUTPUT