Home » Placement Preparation » 100+ C Programs that are Frequently Asked in Campus Interviews

# 100+ C Programs that are Frequently Asked in Campus Interviews

Fibonacci Sequence /* A Fibonacci Sequence is defined as follows: the first and second terms in the sequence are 0 and 1. Subsequent terms are found by adding the preceding two terms in the sequence. Write a C program to generate the first n terms of the sequence. */

#include
void main()
{
int num1=0, num2=1,no,counter,fab;
clrscr();
printf(“<===========PROGRAM TO FIND THE FIBONACCI SERIES UP TO N NO. IN SERIES=========>”);
printf(“nnnttENTER LENGTH OF SERIES (N) : “);
scanf(“%d”,&no);
printf(“nnttt<—-fibonacci series—-=””>”);
printf(“nntt%d %d”,num1,num2);
//LOOP WILL RUN FOR 2 TIME LESS IN SERIES AS THESE WAS PRINTED IN ADVANCE
for(counter = 1; counter <= no-2; counter++)
{ fab=num1 + num2;
printf(” %d”,fab);
num1=num2;
num2=fab;
}
getch();
}

=========================================================================================

/*C program to generate all the prime numbers between 1 and n, where n is a value supplied by the user. */

#include
void main()
{
int no,counter,counter1,check;
clrscr();
printf(“<———————–PRIME NO. SERIES————————>”);
printf(“nnntttINPUT THE VALUE OF N: “);
scanf(“%d”,&no);
printf(“nnTHE PRIME NO. SERIES B/W 1 TO %d : nn”,no);
for(counter = 1; counter <= no; counter++)
{
check = 0;
//THIS LOOP WILL CHECK A NO TO BE PRIME NO. OR NOT.
for(counter1 = counter-1; counter1 > 1 ; counter1–)
if(counter%counter1 == 0)
{
check++; // INCREMENT CHECK IF NO. IS NOT A PRIME NO.
break;
}
if(check == 0)
printf(“%dt”,counter);
}
getch();
}
=========================================================================================

/*C program to find the sum of individual digits of a positive integer.*/

#include
#include
void main()
{
int num, k=1, sum=0;
clrscr();
printf(“Enter the number whose digits are to be added:”);
scanf(“%d”,&num);
while(num!=0)
{
k=num%10;
sum=sum+k;
k=num/10;
num=k;
}
printf(“Sum of the digits:%d”,sum);
getch();
}

/* C program to calculate the following Sum: Sum=1-x2/2! +x4/4!-x6/6!+x8/8!-x10/10! */

#include
#include
void main()
{
int counter,f_coun;
float sum=0,x,power,fact;
clrscr();
printf(“<———PROGRAM FOR SUM OF EQ. SERIES———–>”);
printf(“nntEQUATION SERIES : 1- X^2/2! + X^4/4! – X^6/6! + X^8/8! – X^10/10!”);
printf(“nnntENTER VALUE OF X : “);
scanf(“%f”,&x);
for(counter=0, power=0; power<=10; counter++,power=power+2)
{
fact=1;
//CALC FACTORIAL OF POWER VALUE
for(f_coun=power; f_coun>=1; f_coun–)
fact *= f_coun;
//EQ. FOR SUM SERIES
sum=sum+(pow(-1,counter)*(pow(x,power)/fact));
}
printf(“SUM : %f”,sum);
getch();
}
=========================================================================================

/*C program to find the roots of a quadratic equation. */

#include
#include
#include
void main()
{
float a,b,c,root1,root2;
clrscr();
printf(“n Enter values of a,b,c for finding roots of a quadratic eq:n”);
scanf(“%f%f%f”,&a,&b,&c);
/*checking condition*/
if(b*b>4*a*c)
{
root1=-b+sqrt(b*b-4*a*c)/2*a;
root2=-b-sqrt(b*b-4*a*c)/2*a;
printf(“n*****ROOTS ARE*****n”);
printf(“n root1=%fn root2=%f”,root1,root2);
}
else
printf(“n Imaginary Roots.”);
getch();
}
=========================================================================================

/* C programs that use both recursive and non-recursive functions To find the factorial of a given integer. */

#include
#include
unsigned int recr_factorial(int n);
unsigned int iter_factorial(int n);
void main()
{
int n,i;
long fact;
clrscr();
printf(“Enter the number: “);
scanf(“%d”,&n);
if(n==0)
printf(“Factorial of 0 is 1n”);
else
{
printf(“Factorial of %d Using Recursive Function is %dn”,n,recr_factorial(n));
printf(“Factorial of %d Using Non-Recursive Function is %dn”,n,iter_factorial(n));
}
getch();
}
/* Recursive Function*/
unsigned int recr_factorial(int n)
{ return n>=1 ? n * recr_factorial(n-1) : 1;
}
/* Non-Recursive Function*/
unsigned int iter_factorial(int n)
{
int accu = 1;
int i;
for(i = 1; i <= n; i++)
{
accu *= i;
}
return accu;
}
=========================================================================================

/*C programs that use both recursive and non-recursive functions To find the GCD (greatest common divisor) of two given integers. */

#include
#include
#include
unsigned int GcdRecursive(unsigned m, unsigned n);
unsigned int GcdNonRecursive(unsigned p,unsigned q);
int main(void)
{
int a,b,iGcd;
clrscr();
printf(“Enter the two numbers whose GCD is to be found: “);
scanf(“%d%d”,&a,&b);
printf(“GCD of %d and %d Using Recursive Function is %dn”,a,b,GcdRecursive(a,b));
printf(“GCD of %d and %d Using Non-Recursive Function is %dn”,a,b,GcdNonRecursive(a,b));
getch();
}
/* Recursive Function*/
unsigned int GcdRecursive(unsigned m, unsigned n)
{
if(n>m)
return GcdRecursive(n,m);
if(n==0)
return m;
else
return GcdRecursive(n,m%n);
}
/* Non-Recursive Function*/
unsigned int GcdNonRecursive(unsigned p,unsigned q)
{
unsigned remainder;
remainder = p-(p/q*q);
if(remainder==0)
return q;
else
GcdRecursive(q,remainder);
}
=========================================================================================

/* C program, which takes two integer operands and one operator form the user, performs the operation and then prints the result. (Consider the operators +,-,*, /, % and use Switch Statement) */

#include
#include
void main()
{
int a,b,res,ch;
clrscr();
printf(“t *********************”);
printf(“t********************”);
printf(“nt(2)SUBTRACTION”);
printf(“nt(3)MULTIPLICATION”);
printf(“nt(4)DIVISION”);
printf(“nt(5)REMAINDER”);
printf(“nt(0)EXIT”);
printf(“nt********************”);
scanf(“%d”,&ch);
if(ch<=5 & ch>0)
{
printf(“Enter two numbers:n”);
scanf(“%d%d”,&a,&b);
}
switch(ch)
{
case 1:
res=a+b;
break;
case 2:
res=a-b;
printf(“n Subtraction:%d”,res);
break;
case 3:
res=a*b;
printf(“n Multiplication:%d”,res);
break;
case 4:
res=a/b;
printf(“n Division:%d”,res);
break;
case 5:
res=a%b;
printf(“n Remainder:%d”,res);
break;
case 0:
printf(“n Choice Terminated”);
exit();
break;
default:
printf(“n Invalid Choice”);
}
getch();
}
=========================================================================================

/*The total distance travelled by vehicle in ‘t’ seconds is given by distance = ut+1/2at2 where ‘u’ and ‘a’ are the initial velocity (m/sec.) and acceleration (m/sec2). Write C program to find the distance travelled at regular intervals of time given the values of ‘u’ and ‘a’. The program should provide the flexibility to the user to select his own time intervals and repeat the calculations for different values of ‘u’ and ‘a’. */

#include
#include
void main()
{
int tim_intrval, counter,time;
float accl, distance=0, velos;
clrscr();
printf(“<===========PROGRAM FOR CALC TOTAL DISTANCE TRAVELED BY A VECHIAL===========>”);
printf(“nnntttNO OF TIME INTERVALS : “);
scanf(“%d”,&tim_intrval);
for(counter = 1; counter <= tim_intrval; counter++)
{
printf(“ntttAT T%d TIME(sec) : “,counter);
scanf(“%d”,&time);
printf(“tttVELOCITY AT %d sec (m/sec) : “,time);
scanf(“%f”,&velos);
printf(“tttACCLERATION AT %d sec (m/sec^2): “,time);
scanf(“%f”,&accl);
distance += (velos*time + (accl*pow(time,2))/2);
}
printf(“nnntTOTAL DISTANCE TRAVELLED BY VEHICLE IN %d INTERVALS OF TIME : %f”,tim_intrval,distance);
getch();
}
=========================================================================================

/* Write a C program to find both the largest and smallest number in a list of integers */

#include
#include
void main()
{
float largest(float a[ ], int n);
float value[4] = {2.5,-4.75,1.2,3.67};
printf(“%fn”, largest(value,4));
}
float largest(float a[], int n)
{
int i;
float max;
max = a[0];
for(i = 1; i < n; i++)
if(max < a[i])
max = a[i];
return(max);
}

=========================================================================================

/*Write a C program that uses functions to perform the following:
i) Addition of Two Matrices
ii) Multiplication of Two Matrices */

#include
void main()
{
int ch,i,j,m,n,p,q,k,r1,c1,a[10][10],b[10][10],c[10][10];
clrscr();
printf(“************************************”);
printf(“n**********************************”);
printf(“n[1]ADDITION OF TWO MATRICES”);
printf(“n[2]MULTIPLICATION OF TWO MATRICES”);
printf(“n[0]EXIT”);
printf(“n**********************************”);
scanf(“%d”,&ch);
if(ch<=2 & ch>0)
{
printf(“Valid Choicen”);
}
switch(ch)
{
case 1:
printf(“Input rows and columns of A & B Matrix:”);
scanf(“%d%d”,&r1,&c1);
printf(“Enter elements of matrix A:n”);
for(i=0;i {
for(j=0;j scanf(“%d”,&a[i][j]);
}
printf(“Enter elements of matrix B:n”);
for(i=0;i {
for(j=0;j scanf(“%d”,&b[i][j]);
}
for(i=0;i {
for(j=0;j printf(“%5d”,a[i][j]+b[i][j]);
printf(“n”);
}
break;
case 2:
printf(“Input rows and columns of A matrix:”);
scanf(“%d%d”,&m,&n);
printf(“Input rows and columns of B matrix:”);
scanf(“%d%d”,&p,&q);
if(n==p)
{
printf(“matrices can be multipliedn”);
printf(“resultant matrix is %d*%dn”,m,q);
printf(“Input A matrixn”);
printf(“Input B matrixn”);
/*Function call to read the matrix*/

/*Function for Multiplication of two matrices*/

printf(“n =====Matrix Multiplication=====n”);
for(i=0;i for(j=0;j {
c[i][j]=0;
for(k=0;k c[i][j]=c[i][j]+a[i][k]*b[k][j];
}
printf(“Resultant of two matrices:n”);
write_matrix(c,m,q);
}
/*end if*/
else
{
printf(“Matrices cannot be multiplied.”);
}
/*end else*/
break;
case 0:
printf(“n Choice Terminated”);
exit();
break;
default:
printf(“n Invalid Choice”);
}
getch();
}

int read_matrix(int a[10][10],int m,int n)
{
int i,j;
for(i=0;i for(j=0;j scanf(“%d”,&a[i][j]);
return 0;
}

/*Function to write the matrix*/
int write_matrix(int a[10][10],int m,int n)
{
int i,j;
for(i=0;i {
for(j=0;j printf(“%5d”,a[i][j]);
printf(“n”);
}
return 0;
}

=========================================================================================

/* C programs that use both recursive and non-recursive functions To find the factorial of a given integer. */

#include
#include
unsigned int recr_factorial(int n);
unsigned int iter_factorial(int n);
void main()
{
int n,i;
long fact;
clrscr();
printf(“Enter the number: “);
scanf(“%d”,&n);
if(n==0)
printf(“Factorial of 0 is 1n”);
else
{
printf(“Factorial of %d Using Recursive Function is %dn”,n,recr_factorial(n));
printf(“Factorial of %d Using Non-Recursive Function is %dn”,n,iter_factorial(n));
}
getch();
}
/* Recursive Function*/
unsigned int recr_factorial(int n)
{ return n>=1 ? n * recr_factorial(n-1) : 1;
}
/* Non-Recursive Function*/
unsigned int iter_factorial(int n)
{
int accu = 1;
int i;
for(i = 1; i <= n; i++)
{
accu *= i;
}
return accu;
}

=========================================================================================

/*C programs that use both recursive and non-recursive functions To find the GCD (greatest common divisor) of two given integers. */

#include
#include
#include
unsigned int GcdRecursive(unsigned m, unsigned n);
unsigned int GcdNonRecursive(unsigned p,unsigned q);
int main(void)
{
int a,b,iGcd;
clrscr();
printf(“Enter the two numbers whose GCD is to be found: “);
scanf(“%d%d”,&a,&b);
printf(“GCD of %d and %d Using Recursive Function is %dn”,a,b,GcdRecursive(a,b));
printf(“GCD of %d and %d Using Non-Recursive Function is %dn”,a,b,GcdNonRecursive(a,b));
getch();
}
/* Recursive Function*/
unsigned int GcdRecursive(unsigned m, unsigned n)
{
if(n>m)
return GcdRecursive(n,m);
if(n==0)
return m;
else
return GcdRecursive(n,m%n);
}
/* Non-Recursive Function*/
unsigned int GcdNonRecursive(unsigned p,unsigned q)
{
unsigned remainder;
remainder = p-(p/q*q);
if(remainder==0)
return q;
else
GcdRecursive(q,remainder);
}

=========================================================================================

/* C program to count the lines, words and characters in a given text. */

#include
main()
{
char line[81], ctr;
int i,c, ;
end = 0, characters = 0, words = 0, lines = 0;
printf(“KEY IN THE TEXT.n”);
printf(“GIVE ONE SPACE AFTER EACH WORD.n”);
printf(“WHEN COMPLETED, PRESS ‘RETURN’.nn”);
while( end == 0)
{
/* Reading a line of text */
c = 0;
while((ctr=getchar()) != ‘n’)
line[c++] = ctr;
line[c] = ”;
/* counting the words in a line */
if(line[0] == ”)
break ;
else
{
words++;
for(i=0; line[i] != ”;i++)
if(line[i] == ‘ ‘ || line[i] == ‘t’)
words++;
}
/* counting lines and characters */
lines = lines +1;
characters = characters + strlen(line);
}
printf (“n”);
printf(“Number of lines = %dn”, lines);
printf(“Number of words = %dn”, words);
printf(“Number of characters = %dn”, characters);
}
Output
KEY IN THE TEXT.
GIVE ONE SPACE AFTER EACH WORD.
WHEN COMPLETED, PRESS ‘RETURN’.
Admiration is a very short-lived passion.
Admiration involves a glorious obliquity of vision.
Always we like those who admire us but we do not
like those whom we admire.
Fools admire, but men of sense approve.
Number of lines = 5
Number of words = 36
Number of characters = 205

=========================================================================================

/*C program that displays the position or index in the string S where the string T begins, or – 1 if S doesn’t contain T */

#include
#include
#include
void main()
{
char s[30], t[20];
char *found;
clrscr();
/* Entering the main string */
puts(“Enter the first string: “);
gets(s);
/* Entering the string whose position or index to be displayed */
puts(“Enter the string to be searched: “);
gets(t);
/*Searching string t in string s */
found=strstr(s,t);
if(found)
printf(“Second String is found in the First String at %d position.n”,found-s);
else
printf(“-1”);
getch();
}

=========================================================================================

PASCAL Triangle /* C program to generate Pascal’s triangle */

#include
#include
void main()
{
int bin,p,q,r,x;
clrscr();
bin=1;
q=0;
printf(“Rows you want to input:”);
scanf(“%d”,&r);
printf(“nPascal’s Triangle:n”);
while(q {
for(p=40-3*q;p>0;–p)
printf(” “);
for(x=0;x<=q;++x)
{
if((x==0)||(q==0))
bin=1;
else
bin=(bin*(q-x+1))/x;
printf(“%6d”,bin);
}
printf(“n”);
++q;
}
getch();
}

=========================================================================================

/*C program to construct a pyramid of numbers. */

#include
#include
void main()
{
int num,i,y,x=35;
clrscr();
printf(“nEnter the number to generate the pyramid:n”);
scanf(“%d”,&num);
for(y=0;y<=num;y++)
{
/*(x-coordinate,y-coordinate)*/
gotoxy(x,y+1);
/*for displaying digits towards the left and right of zero*/
for(i=0-y;i<=y;i++)
printf(“%3d”,abs(i));
x=x-3;
}
getch();
}

=========================================================================================

/* Write a C program to read in two numbers, x and n, and then compute the sum of this geometric progression: 1+x+x2+x3+………….+xn For example: if n is 3 and x is 5, then the program computes 1+5+25+125. Print x, n, the sum Perform error checking. For example, the formula does not make sense for negative exponents – if n is less than 0. Have your program print an error message if n<0, then go back and read in the next pair of numbers of without computing the sum. Are any values of x also illegal ? If so, test for them too. */

#include
#include
#include
void main()
{
int s_sum,i,x,n;
clrscr();
printf(“Enter the values for x and n:”);
scanf(“%d %d”,&x,&n);
if(n<=0 || x<=0)
{
printf(“Value is not validn”);
}
else
{
printf(“Value is validn”);
s_sum=1;
for(i=1;i<=n;i++)
{
s_sum=s_sum+pow(x,i);
}
printf(“Sum of series=%dn”,s_sum);
}
getch();
}

=========================================================================================

/* 2’s complement of a number is obtained by scanning it from right to left and complementing all the bits after the first appearance of a 1. Thus 2’s complement of 11100 is 00100. Write a C program to find the 2’s complement of a binary number */

#include
#include
void complement (char *a);
void main()
{
char a[16];
int i;
clrscr();
printf(“Enter the binary number”);
gets(a);
for(i=0;a[i]!=”; i++)
{
if (a[i]!=’0′ && a[i]!=’1′)
{
printf(“The number entered is not a binary number. Enter the correct number”);
exit(0);
}
}
complement(a);
getch();
}
void complement (char *a)
{
int l, i, c=0;
char b[16];
l=strlen(a);
for (i=l-1; i>=0; i–)
{
if (a[i]==’0′)
b[i]=’1′;
else
b[i]=’0′;
}
for(i=l-1; i>=0; i–)
{
if(i==l-1)
{
if (b[i]==’0′)
b[i]=’1′;
else
{
b[i]=’0′;
c=1;
}
}
else
{
if(c==1 && b[i]==’0′)
{
b[i]=’1′;
c=0;
}
else if (c==1 && b[i]==’1′)
{
b[i]=’0′;
c=1;
}
}
}
b[l]=”;
printf(“The 2’s complement is %s”, b);
}

=========================================================================================

/*C program to convert a Roman numeral to its decimal equivalent.. */

#include
#include
#include
#include
void main()
{
int *a,len,i,j,k;
char *rom;
clrscr();
printf(“Enter the Roman Numeral:”);
scanf(“%s”,rom);
len=strlen(rom);
for(i=0;i {
if(rom[i]==’I’)
a[i]=1;
else if(rom[i]==’V’)
a[i]=5;
else if(rom[i]==’X’)
a[i]=10;
else if(rom[i]==’L’)
a[i]=50;
else if(rom[i]==’C’)
a[i]=100;
else if(rom[i]==’D’)
a[i]=500;
else if(rom[i]==’M’)
a[i]=1000;
else
{
printf(“nInvalid Value”);
getch();
exit(0);
}
}
k=a[len-1];
for(i=len-1;i>0;i–)
{
if(a[i]>a[i-1])
k=k-a[i-1];
else if(a[i]==a[i-1] || a[i] k=k+a[i-1];
}
printf(“nIts Decimal Equivalent is:”);
printf(“%d”,k);
getch();
}

=========================================================================================

/* Write a C program that uses functions to perform the following operations: i) Reading a complex number ii) Writing a complex number iii) Addition of two complex numbers iv) Multiplication of two complex numbers (Note: represent complex number using a structure */

#include
#include
void arithmetic(int opern);
struct comp
{
double realpart;
double imgpart;
};
void main()
{
int opern;
clrscr();
printf(“nn ttt***** MAIN MENU *****”);
printf(“nn Select your option: n 1 : ADDn 2 : MULTIPLYn 0 : EXIT nntt Enter your Option [ ]bb”);
scanf(“%d”,&opern);
switch(opern)
{
case 0:
exit(0);
case 1:
case 2:
arithmetic(opern);
default:
main();
}
}
void arithmetic(int opern)
{
struct comp w1, w2, w;
printf(“n Enter two Complex Numbers (x+iy):n Real Part of First Number:”);
scanf(“%lf”,&w1.realpart);
printf(“n Imaginary Part of First Number:”);
scanf(“%lf”,&w1.imgpart);
printf(“n Real Part of Second Number:”);
scanf(“%lf”,&w2.realpart);
printf(“n Imaginary Part of Second Number:”);
scanf(“%lf”,&w2.imgpart);
switch(opern)
{

/*addition of complex number*/
case 1:
w.realpart = w1.realpart+w2.realpart;
w.imgpart = w1.imgpart+w2.imgpart;
break;

/*multiplication of complex number*/
case 2:
w.realpart=(w1.realpart*w2.realpart)-(w1.imgpart*w2.imgpart);
w.imgpart=(w1.realpart*w2.imgpart)+(w1.imgpart*w2.realpart);
break;
}
if (w.imgpart>0)
printf(“n Answer = %lf+%lfi”,w.realpart,w.imgpart);
else
printf(“n Answer = %lf%lfi”,w.realpart,w.imgpart);
getch();
main();
}
=========================================================================================

/* C program which copies one file to another */

#include
#include
#include
void main(int argc, char *argv[])
{
FILE *fs,*ft;
char ch;
clrscr();
if(argc!=3)
{
puts(“Invalid number of arguments.”);
exit(0);
}
fs = fopen(argv[1],”r”);
if(fs==NULL)
{
puts(“Source file cannot be opened.”);
exit(0);
}
ft = fopen(argv[2],”w”);
if (ft==NULL)
{
puts(“Target file cannot be opened.”);
fclose(fs);
exit(0);
}
while(1)
{
ch=fgetc(fs);
if (ch==EOF)
break;
else
fputc(ch,ft);
}
fclose(fs);
fclose(ft);
getch();
}
=========================================================================================

/* Write a function for deleting an item from linked list */

{
node *find(node *p, int a);
int key; /* item to be deleted */
node *n1; /* pointer to node preceding key node */
node *p; /* temporary pointer */
printf(“n What is the item (number) to be deleted?”);
scanf(“%d”, &key);
if(head->number == key) /* first node to be deleted) */
{
p = head->next; /* pointer to 2nd node in list */
free(head); /* release space of key node */
head = p; /* make head to point to 1st node */
}
else
{
n1 = find(head, key);
if(n1 == NULL)
else /* delete key node */
{
p = n1->next->next; /* pointer to the node
following the keynode */
free(n1->next); /* free key node */
n1->next = p; /* establish link */
}
}
}
/* USE FUNCTION find() HERE */

=========================================================================================

/*Write a function for inserting an item into a linked list. */

{
node *find(node *p, int a);
node *new; /* pointer to new node */
node *n1; /* pointer to node preceding key node */
int key;
int x; /* new item (number) to be inserted */
printf(“Value of new item?”);
scanf(“%d”, &x);
printf(“Value of key item ? (type -999 if last) “);
scanf(“%d”, &key);
if(head->number == key) /* new node is first */
{
new = (node *)malloc(size of(node));
new->number = x;
}
else /* find key node and insert new node */
{ /* before the key node */
n1 = find(head, key); /* find key node */
if(n1 == NULL)
else /* insert new node */
{
new = (node *)malloc(sizeof(node));
new->number = x;
new->next = n1->next;
n1->next = new;
}
}
}
node *find(node *lists, int key)
{
if(list->next->number == key) /* key found */
return(list);
else
if(list->next->next == NULL) /* end */
return(NULL);
else
find(list->next, key);
}

=========================================================================================

/* C program that uses functions to perform the following operations on doubly linked list.: i) Creation ii) Insertion iii) Deletion iv) Traversal in both ways */

#include “stdio.h”
#include “alloc.h”
typedef struct dubll
{ int data;
}*DUBLL;
DUBLL high,temp_node,low,last,pntr;
int flag=0;
DUBLL NodeAlloc();
DUBLL Search(int,int);
void CreateItem();
void AppendItem();
void PrintItem();
void DeleteItem();
DUBLL Search(int item,int flag);
DUBLL NodeAlloc();
void InsertItem();
void main(void)
{
int choice,Item;
high=NULL;
while(1)
{
clrscr();
printf(“n ttt***** M A I N M E N U *****nn”);
printf(“n 1: Create Linked List n 2: Append a Node to the List n 3: Traverse the List n 4: Delete a Node from the List n 5: Search a Node n 6: Insert a Node to the List n 7: Close nntt Enter your Option [ ]bb”);
scanf(“%d”,&choice);
switch(choice)
{
case 1:
CreateItem();
puts(“nPress any key to go back to main menu.”);
getch();
break;
case 2:
AppendItem();
break;
case 3:
PrintItem();
puts(“nPress any key to go back to main menu.”);
getch();
break;
case 4:
DeleteItem();
break;
case 5:
printf(“Find an Item: “);
scanf(“%d”,&Item);
temp_node=Search(Item,0);
if(temp_node)
{
puts(“The item is available in the Linked List.”);
}
else
{
}
getch();
break;
case 6:
InsertItem();
break;
case 7:
exit();
default:
puts(“Invalid choice.”);
puts(“nPress any key to go back to main menu.”);
getch();
break;
}

}
}
/* Function to Create the list*/
void CreateItem()
{
if(high==NULL)

{
printf(“n –Creating the list–“);
temp_node=NodeAlloc();
printf(“n Enter starting data (as integer value) :”);
scanf(“%d”,&temp_node->data);
high=temp_node;
}
else{ printf(“n List already created @ %d with %d as data.”,high,high->data);}
}
/* Function to Append items to the list*/
void AppendItem()
{
low=high;
if(high==NULL)
{
CreateItem();
}
else
{
temp_node=NodeAlloc();
printf(“n Enter Item (in integer) :”);
scanf(“%d”,&temp_node->data);
}
}

/* Function to Traverse the list both ways and print the data*/
void PrintItem()
{ DUBLL temp_node;
if(high==NULL)
{
printf(“n List is not available. Please create a list first.”);
getch();
CreateItem();
}
temp_node=high;
printf(“n–Printing The List In Forward direction–n”);
while(temp_node!=NULL) //In forward direction
{
printf(“t %d”,temp_node->data);
}
printf(“n”);
printf(“n–Printing The List In Backward direction–n”);
temp_node=high;
while(last!=NULL) //In backward direction
{
printf(“t %d”,last->data);
}
}

/* Function to Delete items of the list*/
void DeleteItem()
{
int value;
DUBLL temp_node;
if(high==NULL)
{
printf(“n List is not available. Please create a list first.”);
getch();
CreateItem();
}
printf(“n Item to delete :”);
scanf(“%d”,&value);
pntr=Search(value,1);
temp_node=pntr;
free(temp_node);
}

/* Function to Search an item from the list*/ DUBLL Search(int item,int flag)
{
temp_node = high;
if(high==NULL)
{
printf(“n List is not available. Please create a list first.”);
getch();
CreateItem();
}
while(temp_node!=NULL)
{
if(temp_node->data==item )
{
if(flag==0)
{
return(1);
}
else
{ return(temp_node);
}
}
} }

/* Function to Allocate nodes*/
DUBLL NodeAlloc()
{
DUBLL tmep_node;
tmep_node=malloc(sizeof(struct dubll));
if(tmep_node==NULL)
{
printf(“n No memory available. Node allocation cannot be done.”);
}
return(tmep_node);
}

/* Function to Insert items in the middle of the list*/
void InsertItem()
{
int node;
DUBLL temp_node;
if(high==NULL)

{
printf(“n List is not available. Please create a list first.”);
getch();
CreateItem();
}
temp_node=NodeAlloc();
printf(“Position At which node to be inserted: ___ & New Item Value: ___ “);
scanf(“%d”,&node);
scanf(“%d”,&temp_node->data);
pntr=Search(node,1);
if(pntr->rightlink==NULL){printf(“n The operation is not possible.”); getch();return;}
printf(“n Item has been Inserted.”);
getch();
}
=========================================================================================

/* C programs that implement Queue (its operations) using i) Arrays */

#include
#include
#include
#define size 10
#define true 1
#define false 0
struct q_arr
{
int f,r;
int num;
int a[size];
};
void init(struct q_arr* queue);
int e_que(struct q_arr* queue);
int f_que(struct q_arr* queue);
int add_ele(struct q_arr* queue,int);
int rem_ele(struct q_arr* queue);
void display_ele(struct q_arr* queue);
/*main function*/
void main()
{
int ele,k;
int ch;
struct q_arr *queue = (struct q_arr*)malloc(sizeof(struct q_arr));
init(queue);
while(1)
{
clrscr();
printf(“nn****IMPLEMENTATION OF QUEUE USING ARRAYS****n”);
printf(“============================================”);
printf(“============================================”);
printf(“nt[1] To insert an element”);
printf(“nt[2] To remove an element”);
printf(“nt[3] To display all the elements”);
printf(“nt[4] Exit”);
printf(“nnt Enter your choice: “);
scanf(“%d”,&ch);
switch(ch)
{
case 1:
{
printf(“nElement to be inserted:”);
scanf(“%d”,&ele);
break;
}
case 2:
{
if(!e_que(queue))
{
k=rem_ele(queue);
printf(“n%d element is removedn”,k);
getch();
}
else
{
printf(“tQueue is Empty. No element can be removed.”);
getch();
}
break;
}
case 3:
{
display_ele(queue);
getch();
break;
}
case 4:
exit(0);
default:
printf(“tInvalid Choice.”);
getch();
break;
}
}
}
/*end main*/
void init(struct q_arr* queue)
{
queue->f = 0;
queue->r = -1;
queue->num = 0;
}
/* Function to check is the queue is empty*/
int e_que(struct q_arr* queue)
{
if(queue->num==0)
return true;
return false;
}
/* Function to check if the queue is full*/
int f_que(struct q_arr* queue)
{
if(queue->num == size)
return true;
return false;
}

/* Function to add an element to the queue*/
int add_ele(struct q_arr* queue,int j)
{
if(f_que(queue))
return false;
if(queue->r == size – 1)
queue->r = -1;
queue->a[++queue->r] = j;
queue->num++;
return true;
}

/* Function to remove an element of the queue*/
int rem_ele(struct q_arr* queue)
{
int j;
if(e_que(queue))
return -9999;
j = queue->a[queue->f++];
if(queue->f == size)
queue->f = 0;
queue->num–;
return j;
}

/* Function to display the queue*/
void display_ele(struct q_arr* queue)
{
int j;
if(e_que(queue))
{
printf(“Queue is Empty. No records to display.”);
return;
}
printf(“nElements present in the Queue are: “);
for(j=queue->f;j<=queue->r;j++)
printf(“%dt”,queue->a[j]);
printf(“n”);
}
=========================================================================================

/* Write a C program that uses functions to perform the following:
i) Creating a Binary Tree of integers
ii) Traversing the above binary tree in preorder, inorder and postorder. */

#include
#include
#include
struct treenode
{
int ele;
struct treenode *l_child, *r_child;
};
struct treenode *insert_node(struct treenode *t,int a);
void TraverseInorder(struct treenode *t);
void TraversePreorder(struct treenode *t);
void TraversePostorder(struct treenode *t);
/*main function*/
void main()
{
struct treenode *root_node = NULL;
int num,value;
int choice;
clrscr();
printf(“—————————————————-n”);
printf(“—————————————————–n”);
printf(“[1] Create a Binary Tree and Use Inorder Traversaln”);
printf(“[2] Create a Binary Tree and Use Preorder Traversaln”);
printf(“[3] Create a Binary Tree and Use Postorder Traversaln”);
printf(“—————————————————–n”);
scanf(“%d”,&choice);
if(choice>0 & choice<=3)
{
printf(“nEnter the number of nodes:”);
scanf(“%d”,&num);
while(num– > 0)
{
printf(“nnEnter the data value:”);
scanf(“%d”,&value);
root_node = insert_node(root_node,value);
}
switch(choice)
{
case 1:
printf(“nnBinary tree using Inorder Traversal : “);
TraverseInorder(root_node);
getch();
break;

case 2:
printf(“nnBinary tree using Preorder Traversal : “); TraversePreorder(root_node); getch(); break; case 3: printf(“nnBinary tree using Postorder Traversal : “);
TraversePostorder(root_node);
getch();
break;

default:
printf(“Invalid Choice”);
break;
}
}
}
/*end main*/

/* Function to create a Binary Tree of integers data */
struct treenode *insert_node(struct treenode *t,int a)
{
struct treenode *temp_node1,*temp_node2;
if(t == NULL)
{
t = (struct treenode *) malloc(sizeof(struct treenode));
if(t == NULL)
{
printf(“Value cannot be allocated.n”);
exit(0);
}
t->ele = a;
t->l_child=t->r_child=NULL;
}
else
{
temp_node1 = t;
while(temp_node1 != NULL)
{
temp_node2 = temp_node1;
if( temp_node1 ->ele > a)
temp_node1 = temp_node1->l_child;
else
temp_node1 = temp_node1->r_child;
}
if( temp_node2->ele > a)
{
temp_node2->l_child = (struct treenode*)malloc(sizeof(struct treenode));
temp_node2 = temp_node2->l_child;
if(temp_node2 == NULL)
{
printf(“Value cannot be allocated.n”);
exit(0);
}
temp_node2->ele = a;
temp_node2->l_child=temp_node2->r_child = NULL;
}
else
{
temp_node2->r_child = (struct treenode*)malloc(sizeof(struct treenode));
temp_node2 = temp_node2->r_child;
if(temp_node2 == NULL)
{
printf(“Value cannot be allocated.n”);
exit(0);
}
temp_node2->ele = a;
temp_node2->l_child=temp_node2->r_child = NULL;
}
}
return(t);
}

/* Function for Traversing the binary tree in inorder. */
void TraverseInorder(struct treenode *t)
{
if(t != NULL)
{
TraverseInorder(t->l_child);
printf(“%dt”,t->ele);
in_order(t->r_child);
}
}

/* Function for Traversing the binary tree in preorder. */
void TraversePreorder(struct treenode *t)
{
if(t != NULL)
{
printf(“%dt”,t->ele);
TraversePreorder(t->l_child);
TraversePreorder(t->r_child);
}
}

/* Function for Traversing the binary tree in postorder. */
void TraversePostorder(struct treenode *t)
{
if(t != NULL)
{
TraversePostorder(t->l_child);
TraversePostorder(t->r_child);
printf(“%dt”,t->ele);
}
}
=========================================================================================

/* Write C programs that use both recursive and non recursive functions to perform the following searching operations for a Key value in a given list of integers : ii) Binary search */

#include
#define MAX_LEN 10

/* Non-Recursive function*/
void b_search_nonrecursive(int l[],int num,int ele)
{
int l1,i,j, flag = 0;
l1 = 0;
i = num-1;
while(l1 <= i)
{
j = (l1+i)/2;
if( l[j] == ele)
{
printf(“nThe element %d is present at position %d in listn”,ele,j);
flag =1;
break;
}
else
if(l[j] < ele)
l1 = j+1;
else
i = j-1;
}
if( flag == 0)
printf(“nThe element %d is not present in the listn”,ele);
}

/* Recursive function*/
int b_search_recursive(int l[],int arrayStart,int arrayEnd,int a)
{
int m,pos;
if (arrayStart<=arrayEnd)
{
m=(arrayStart+arrayEnd)/2;
if (l[m]==a)
return m;
else if (a return b_search_recursive(l,arrayStart,m-1,a);
else
return b_search_recursive(l,m+1,arrayEnd,a);
}
return -1;
}
void read_list(int l[],int n)
{
int i;
printf(“nEnter the elements:n”);
for(i=0;i scanf(“%d”,&l[i]);
}
void print_list(int l[],int n)
{
int i;
for(i=0;i printf(“%dt”,l[i]);
}

/*main function*/
void main()
{
int l[MAX_LEN], num, ele,f,l1,a;
int ch,pos;
clrscr();
printf(“======================================================”);
printf(“n=====================================================”); printf(“n[1] Binary Search using Recursion method”);
printf(“n[2] Binary Search using Non-Recursion method”);
scanf(“%d”,&ch);

if(ch<=2 & ch>0)
{
printf(“nEnter the number of elements : “);
scanf(“%d”,&num);
printf(“nElements present in the list are:nn”);
print_list(l,num);
printf(“nnEnter the element you want to search:nn”);
scanf(“%d”,&ele);

switch(ch)
{
case 1:printf(“nRecursive method:n”);
pos=b_search_recursive(l,0,num,ele);
if(pos==-1)
{
}
else
{
printf(“Element is found at %d position”,pos);
}
getch();
break;
case 2:printf(“nNon-Recursive method:n”);
b_search_nonrecursive(l,num,ele);
getch();
break;
}
}
getch();
}

=========================================================================================

/* C programs that use both recursive and non recursive functions to perform the following searching operation for a Key value in a given list of integers : i) Linear search */

#include
#define MAX_LEN 10
void l_search_recursive(int l[],int num,int ele);
void l_search(int l[],int num,int ele);
void read_list(int l[],int num);
void print_list(int l[],int num);
void main()
{
int l[MAX_LEN], num, ele;
int ch;
clrscr();
printf(“======================================================”);
printf(“n=====================================================”);
printf(“n[1] Linary Search using Recursion method”);
printf(“n[2] Linary Search using Non-Recursion method”);
scanf(“%d”,&ch);
if(ch<=2 & ch>0)
{
printf(“Enter the number of elements :”);
scanf(“%d”,&num);
printf(“nElements present in the list are:nn”);
print_list(l,num);
printf(“nnElement you want to search:nn”);
scanf(“%d”,&ele);
switch(ch)
{
case 1:printf(“n** Recursion method**n”);
l_search_recursive(l,num,ele);
getch();
break;

case 2:printf(“n**Non-Recursion method**n”);
l_search_nonrecursive(l,num,ele);
getch();
break;
}
}
getch();
}
/*end main*/
/* Non-Recursive method*/
void l_search_nonrecursive(int l[],int num,int ele)
{
int j, f=0;
for(j=0;j if( l[j] == ele)
{
printf(“nTh e element %d is present at position %d in listn”,ele,j);
f=1;
break;
}
if(f==0)
printf(“nThe element is %d is not present in the listn”,ele);
}
/* Recursive method*/
void l_search_recursive(int l[],int num,int ele)
{
int f = 0;
if( l[num] == ele)
{
printf(“nThe element %d is present at position %d in listn”,ele,num);
f=1;
}
else
{
if((num==0) && (f==0))
{
}
else
{
l_search(l,num-1,ele);
}
}
getch();
}
void read_list(int l[],int num)
{
int j;
printf(“nEnter the elements:n”);
for(j=0;j scanf(“%d”,&l[j]);
}
void print_list(int l[],int num)
{
int j;
for(j=0;j printf(“%dt”,l[j]);
}

=========================================================================================

/* Write C program that implement the following sorting methods to sort a given list of integers in ascending order: ii) Quick sort */

#include
#define MAX 10
void swap(int *m,int *n)
{
int temp;
temp = *m;
*m = *n;
*n = temp;
}
int get_key_position(int x,int y )
{
return((x+y) /2);
}

// Function for Quick Sort
void quicksort(int list[],int m,int n)
{
int key,i,j,k;
if( m < n)
{
k = get_key_position(m,n);
swap(&list[m],&list[k]);
key = list[m];
i = m+1;
j = n;
while(i <= j)
{
while((i <= n) && (list[i] <= key))
i++;
while((j >= m) && (list[j] > key))
j–;
if( i < j)
swap(&list[i],&list[j]);
}
swap(&list[m],&list[j]);
quicksort(list,m,j-1);
quicksort(list,j+1,n);
}
}

// Function to read the data
void read_data(int list[],int n)
{
int j;
printf(“nnEnter the elements:n”);
for(j=0;j scanf(“%d”,&list[j]);
}

// Function to print the data
void print_data(int list[],int n)
{
int j;
for(j=0;j printf(“%dt”,list[j]);
}
void main()
{
int list[MAX], num;
clrscr();
printf(“n***** Enter the number of elements Maximum [10] *****n”);
scanf(“%d”,&num);
printf(“nnElements in the list before sorting are:n”);
print_data(list,num);
quicksort(list,0,num-1);
printf(“nnElements in the list after sorting are:n”);
print_data(list,num);
getch();
}

=========================================================================================

/* Write C program that implement the following sorting methods to sort a given list of integers in ascending order: i) Insertion sort */

#include
#include
void inst_sort(int []);

void main()
{
int num[5],count;
clrscr();
printf(“nEnter the Five Elements to sort:n”);
for (count=0;count<5;count++)
scanf(“%d”,&num[count]);
inst_sort(num);
printf(“nnElements after sorting: n”);
for(count=0;count<5;count++)
printf(“%dn”,num[count]);
getch();
}
// Function for Insertion Sorting
void inst_sort(int num[])
{
int i,j,k;
for(j=1;j<5;j++)
{
k=num[j];
for(i=j-1;i>=0 && k num[i+1]=num[i];
num[i+1]=k;
}
}
=========================================================================================