void showstatus( ) ;
void allotlift ( int *, int, int, char ) ;

/* show current status, i.e. the floor no. on which the lifts are standing */
void showstatus ( int *lf )
{
int i ;

for ( i = 0 ; i < 5 ; i++ )
printf ( "Lift : %d is on %d floor\n", i, lf[i] ) ;
}

/* allot the lift to the user */
void allotlift ( int *lf, int flnos, int flnot, char d )
{
/* struct p to store the difference between 2 lifts */
struct p
{
int lfno[5] ;
int pos[5] ;
int diff[5] ;
} arr ;

int lno = -1 ; /* to store the lift no. that can be made available */
int i, j, k, t1, t2, t3 ;

/* initialize array */
for ( i = 0; i < 5; i++ )
{
arr.lfno[i] = i ;
arr.pos[i] = 0 ;
arr.diff[i] = 0 ;
}

while ( lno == -1 )
{
/* get the current position of a lift */
for ( i = 0 ; i < 5; i++ )
arr.pos[i] = lf[i] ;

for ( i = 0; i < 5; i++ )
{
/* get the diff. between floor on which lift is standing
and the floor on which the user is standing */
arr.diff[i] = abs ( arr.pos[i] - flnos ) ;
}

/* sort array */
for ( i = 0; i < 5; i++ )
{
for ( j = 0; j < 4; j++ )
{
if ( arr.diff[i] < arr.diff[j] )
{

t1 = arr.lfno[i] ;
t2 = arr.pos[i] ;
t3 = arr.diff[i] ;
arr.lfno[i] = arr.lfno[j] ;
arr.pos[i] = arr.pos[j] ;
arr.diff[i] = arr.diff[j] ;
arr.lfno[j] = t1 ;
arr.pos[j] = t2 ;
arr.diff[j] = t3 ;
}
}
}

/* check for the lift that can be alloted
depending on the direction */
for ( i = 0, k = 0; i < 5; i++ )
{
k = arr.lfno[i] ;

if ( ( d == 'u' ) && (
( lf[k] < flnos ) ||
( lf[k] == 0 ) ||
( lf[k] == flnos ) ) )
{
lno = k ;
break ;
}

if ( ( d == 'd' ) && (
( lf[k] > flnos ) ||
( lf[k] == 0 ) ||
( lf[k] == flnos ) ) )
{
lno = k ;
break ;
}
}

/* if none of the lift has been alloted */
j = 30 ;
if ( lno == -1 )
{
for ( i = 0; i < 5; i++ )
{
if ( j > arr.diff[i] )
{
j = arr.diff[i] ;
lno = i ;
}
}
}
}

printf ( “\nThe lift available to you would be: %d\n\n”, lno ) ;

lf[lno] = flnot ;
}

/* the main menu */
int showmenu( )
{
int c ;

printf ( ” ——————– Lift Program ——————– \n” ) ;
printf ( ” There are 5 lifts available for your service. \n” ) ;
printf ( ” Select 1 if you want to use a lift. \n” ) ;
printf ( ” Selecting 2 would show, for each of the 5 lifts, \n” ) ;
printf ( ” the floor no. on which the lift is currently standing. \n” ) ;
printf ( ” Select 3 to quit the program \n” ) ;
printf ( ” —————————————————— \n” ) ;
printf ( ” 1. Do you wish to use lift?\n” ) ;
printf ( ” 2. Show status of lift\n” ) ;
printf ( ” 3. Exit\n” ) ;
printf ( ” —————————————————— \n” ) ;
scanf ( “%d”, &c ) ;

return c ;
}

void validate ( int *fs, int *ft, char *d )
{
int flnos, flnot ;
char dir ;
int flag ;
unsigned char chr ;

flnos = flnot = -1 ;
flag = 0 ;

while ( flnos < 0 || flnos > 29 )
{
printf ( “Enter the floor no. where you are standing : ” ) ;
scanf ( “%d”, &flnos ) ;

if ( flnos < 0 || flnos > 29 )
{
printf ( “\nIncorrect floor no.! Enter floor no. in a range of 0 – 29 \n\n” ) ;
getch( ) ;
}
}

while ( flag == 0 )
{
dir = ‘j’ ;
while ( tolower ( dir ) != ‘u’ && tolower ( dir ) != ‘d’ )
{
printf ( “Do you wish to go up or down (up/down): ” ) ;
fflush ( stdin ) ;
scanf ( “%c”, &dir ) ;
printf ( “\n” ) ;

if ( dir != ‘u’ && dir != ‘d’ )
printf ( “Incorrect direction! Enter again\n” ) ;
}

if ( flnos == 0 && dir == ‘d’ )
{
printf ( “\nYou are already standing on ground floor.\n” ) ;
printf ( “Cannot go further down.\n” ) ;
getch( ) ;
flag = 0 ;
}
else
flag = 1 ;
}
flag = 0 ;

while ( flag == 0 )
{
printf ( “\nEnter the floor no. where you want to go: ” ) ;
scanf ( “%d”, &flnot ) ;

if ( ( flnos == 0 && flnot == 0 ) ||
( flnot < 0 || flnot > 29 ) ||
( flnos == flnot ) ||
( ( flnos != 0 ) && ( dir == ‘d’ && ( flnos – flnot < 0 ) ) ) ||
( ( flnos != 0 ) && ( dir == 'u' && ( flnot < flnos ) ) ) )
{
printf ( "\nIncorrect floor no. or trying to move to the same \n" ) ;
printf ( "floor where you are standing, or either the \n" ) ;
printf ( " direction given is incorrect or the floor number \n" ) ;
printf ( " is incorrect. Try again \n") ;
flag = 0 ;
}
else
flag = 1 ;
}

*fs = flnos ;
*d = dir ;
*ft = flnot ;
}

void main( )
{
int ch ; /* stores the no. entered as a choice for the menu */
int flnos ; /* to store floor no. where the user stands */
int flnot ; /* to store the target floor no. */
char dir ; /* to store the direction */
char chr[20] ; /* a temporary variable */
int lf[5] = { 0, 0, 0, 0, 0 } ;

void validate ( int *, int *, char * ) ;

flnos = flnot = -1 ;

clrscr( ) ;

while ( 1 )
{
/* display main menu */
ch = showmenu( ) ;

/* switch-case for menu options to be handled */
switch ( ch )
{
case 1 :

/* actual logic behind the c program */

printf ( “Allot lift: \n” ) ;
validate ( &flnos, &flnot, &dir ) ;
allotlift ( lf, flnos, flnot, dir ) ;
break ;

case 2 :

/* getstaus */
printf ( “Current status of lifts: \n” ) ;
showstatus ( lf ) ;
break ;

case 3 :

/* exit program */
exit ( 0 ) ;
break ;

default :

/* wrong choice */
printf ( “Incorrect choice! try again!” ) ;
}

printf ( “\n\n” ) ;
printf ( “Press key to continue…” ) ;
fflush ( stdin ) ;
scanf ( “%c”, &chr ) ;
}

#include < stdio.h >

#include < conio.h >

void main( )

{
struct emp

{

char empid[7] ;

char name[25] ;

int age ;

float sal ;

} ;

int i, j ;

struct emp e[5] ;

char id[5][7], temp[7] ;

float ff ( float ) ;

clrscr( ) ;

printf ( “Enter empid, name, age and salary :-\n”) ;

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

{

scanf ( "%s %s %d %f", e[i].empid, e[i].name, &e[i].age, &e[i].sal ) ;

strcpy ( id[i], e[i].empid ) ;

}

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

{

for ( j = 0 ; j < = 3 - i ; j++ )

{

if ( strcmp ( id[j], id[j + 1] ) > 0 )

{
strcpy ( temp, id[j] ) ;

strcpy ( id[j], id[j + 1] ) ;

strcpy ( id[j + 1], temp ) ;

}

}

}

printf ( “\nRecords after sorting”) ;

printf ( “\nName, age and salary after sorting :-\n”) ;

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

{

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

{

if ( strcmp( id[i], e[j].empid ) == 0 )

printf ( “%s %s %d %f\n”, e[j].empid, e[j].name, e[j].age,

e[j].sal ) ;

}

}

getch( ) ;
}

float ff ( float f )

{
float *f1 = &f ;

return *f1 ;

}

#include < stdio.h >

#include < conio.h >

#include < alloc.h >

#define MAX1 5

#define MAX2 7

int *arr ;

int* create ( int ) ;

void sort ( int *, int ) ;

void display ( int *, int ) ;

int* merge ( int *, int * ) ;

void main( )

{
int *a, *b, *c ;

clrscr( ) ;

printf ( “\nEnter elements for first array: \n\n” ) ;

a = create ( MAX1 ) ;

printf ( “\nEnter elements for second array: \n\n” ) ;

b = create ( MAX2 ) ;

sort ( a, MAX1 ) ;

sort ( b, MAX2 ) ;

printf ( “\nFirst array: \n” ) ;

display ( a, MAX1 ) ;

printf ( “\n\nSecond array: \n” ) ;

display ( b, MAX2 ) ;

printf ( “\n\nAfter Merging: \n” ) ;

c = merge ( a, b ) ;

display ( c, MAX1 + MAX2 ) ;

getch( ) ;
}

/* creates array of given size, dynamically */

int* create ( int size )

{
int *arr, i ;

arr = ( int * ) malloc ( sizeof ( int ) * size ) ;

for ( i = 0 ; i < size ; i++ )
{
printf ( "Enter the element no. %d: ", i + 1 ) ;

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

}

return arr ;

}

/* sorts array in ascending order */

void sort ( int *arr, int size )

{

int i, temp, j ;

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

{

for ( j = i + 1 ; j < size ; j++ )

{

if ( arr[i] > arr[j] )

{

temp = arr[i] ;

arr[i] = arr[j] ;

arr[j] = temp ;
}

}

}

}

/* displays the contents of array */

void display ( int *arr, int size )

{

int i ;

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

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

}

/* merges two arrays of different size */

int* merge ( int *a, int *b )

{
int *arr ;

int i, k, j ;

int size = MAX1 + MAX2 ;

arr = ( int * ) malloc ( sizeof ( int ) * ( size ) ) ;

for ( k = 0, j = 0, i = 0 ; i < = size ; i++ )

{

if ( a[k] < b[j] )

{

arr[i] = a[k] ;

k++ ;

if ( k > = MAX1 )

{

for ( i++ ; j < MAX2 ; j++, i++ )

arr[i] = b[j] ;

}

}

else

{

arr[i] = b[j] ;

j++ ;

if ( j > = MAX2 )

{

for ( i++ ; k < MAX1 ; k++, i++ )

arr[i] = a[k] ;

}

}

}

return arr ;

}

C Program to find files with duplicate names using binary search tree

#include < stdio.h >
#include < conio.h >
#include < dos.h >
#include < dir.h >
#include < string.h >
#include < alloc.h >

struct btreenode
{
struct btreenode *leftchild ;

char data[13] ; /* file name */

char *loc ; /* location of filename */

struct btreenode *rightchild ;

} *bt = NULL ;

void disktree( ) ;

int insert ( struct btreenode **, char*, char* ) ;

void main( )

{
char current_dir[32] ;

clrscr( ) ;

getcwd ( current_dir, 32 ) ;

chdir ( “\\” ) ;

disktree( ) ;

chdir ( current_dir ) ;

getch( ) ;
}

void disktree( )
{
struct ffblk file ;

int flag ;

char loc[80] ;

getcwd ( loc, 80 ) ;
flag = findfirst ( “*.*”, &file, FA_NORMAL | FA_RDONLY | FA_HIDDEN |

FA_SYSTEM | FA_LABEL | FA_DIREC | FA_ARCH ) ;

while ( flag == 0 )

{

if ( file.ff_name[0] != ‘.’ )

{

if ( file.ff_attrib == FA_DIREC && file.ff_fsize == 0 )
{
chdir ( file.ff_name ) ;

disktree( ) ;

chdir ( loc ) ;
}
else
insert ( &bt, loc, file.ff_name ) ;
}
flag = findnext ( &file ) ;
}
}

/* inserts a new node in a binary search tree */

int insert ( struct btreenode **sr, char* l, char* f )
{
char *p ;

int flag ;

if ( *sr == NULL )
{
*sr = ( struct btreenode * ) malloc ( sizeof ( struct btreenode ) ) ;

if ( *sr == NULL )
{
printf ( “\nOut of memory.” ) ;

exit ( 1 ) ;
}

( *sr ) – > leftchild = NULL ;

( *sr ) – > rightchild = NULL ;

strcpy ( ( *sr ) – > data, f ) ;

p = ( char * ) malloc ( ( strlen ( l ) + 1 ) ) ;

if ( p == NULL )
{
printf ( “\nOut of memory.” ) ;

exit ( 1 ) ;
}

strcpy ( p, l ) ;

( *sr ) – > loc = p ;
}
else
{
flag = strcmp ( ( *sr ) – > data, f ) ;

if ( flag == 0 )
{
printf ( “org: %s”, ( *sr ) – > loc ) ;

if ( strlen ( ( *sr ) – > loc ) > 4 )

printf ( “\\” ) ;

printf ( “%s\n”, ( *sr ) – > data ) ;

printf (“dup: %s”, l ) ;

if ( strlen ( l ) > 4 )

printf ( “\\” ) ;

printf ( “%s\n\n”, f ) ;
}

else if ( flag < 0 )

insert ( &( ( *sr ) - > leftchild ), l, f ) ;

else

insert ( &( ( *sr ) – > rightchild ), l, f ) ;

}

return ;
}

#include < conio.h >

#include < alloc.h >

#define MAX 10

struct dqueue

{
int arr[MAX] ;

int front, rear ;
} ;

void initdqueue ( struct dqueue * ) ;

void addqatend ( struct dqueue *, int item ) ;

int delqatbeg ( struct dqueue * ) ;

int delqatend ( struct dqueue * ) ;

void display ( struct dqueue ) ;

int count ( struct dqueue ) ;

void main( )

{
struct dqueue dq ;

int i, n ;

clrscr( ) ;

initdqueue ( &dq ) ;

addqatend ( &dq, 11 ) ;

addqatend ( &dq, 12 ) ;

addqatend ( &dq, 13 ) ;

addqatend ( &dq, 14 ) ;

addqatend ( &dq, 15 ) ;

addqatend ( &dq, 16 ) ;

addqatend ( &dq, 17 ) ;

addqatend ( &dq, 18 ) ;

addqatend ( &dq, 19 ) ;

addqatend ( &dq, 20 ) ;

display ( dq ) ;

n = count ( dq ) ;

printf ( “\nTotal elements: %d”, n ) ;

i = delqatbeg ( &dq ) ;

printf ( “\nItem extracted = %d”, i ) ;

i = delqatbeg ( &dq ) ;

printf ( “\nItem extracted = %d”, i ) ;

i = delqatend ( &dq ) ;

printf ( “\nItem extracted = %d”, i ) ;

i = delqatend ( &dq ) ;

printf ( “\nItem extracted = %d”, i ) ;

n = count ( dq ) ;

printf ( “\nElements Left: %d”, n ) ;

display ( dq ) ;

addqatend ( &dq, 19 ) ;

addqatend ( &dq, 20 ) ;

addqatend ( &dq, 21 ) ;

addqatend ( &dq, 22 ) ;

addqatend ( &dq, 23 ) ;

addqatend ( &dq, 24 ) ;

display ( dq ) ;

getch( ) ;
}

/* initializes elements of structure */

void initdqueue ( struct dqueue *p )

{
int i ;

p – > front = p – > rear = -1 ;

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

p - > arr[i] = 0 ;
}

/* adds item at the end of dqueue */

void addqatend ( struct dqueue *p, int item )
{
int i, k ;

if ( p – > front == 0 && p – > rear == MAX )
{
printf ( “\nQueue is full.\n” ) ;
return ;
}

if ( p – > rear == -1 && p – > front == -1 )
{
p – > rear = p – > front = 0 ;

p – > arr[p - > rear] = item ;

( p – > rear )++ ;

return ;
}

if ( p – > rear == MAX )
{
for ( i = k = p – > front – 1 ; i < p - > rear ; i++ )
{
k = i ;
if ( k == MAX – 1 )
p – > arr[k] = 0 ;
else
p – > arr[k] = p – > arr[i + 1] ;
}
( p – > rear )– ;
( p – > front )– ;
}
p – > arr[p - > rear] = item ;
( p – > rear )++ ;
}

/* deletes item from beginning of dequeue */

int delqatbeg ( struct dqueue *p )
{
int item ;

if ( p – > front == -1 && p – > rear == -1 )
{
printf ( “\nQueue is empty.\n” ) ;
return 0 ;
}

item = p – > arr[p - > front] ;
p – > arr[p - > front] = 0 ;
( p – > front )++ ;

if ( p – > front == MAX )
p – > front = -1 ;

return item ;
}

/* deletes item from end of dqueue */

int delqatend ( struct dqueue *p )

{
int item ;

if ( p – > front == -1 && p – > rear == -1 )

{
printf ( “\nQueue is empty.\n” ) ;

return 0 ;
}

( p – > rear )– ;

item = p – > arr[p - > rear] ;

p – > arr[p - > rear] = 0 ;

if ( p – > rear == 0 )

p – > rear = -1 ;

return item ;
}

/* displays the queue */

void display ( struct dqueue dq )

{
int i ;

printf ( “\n front – > ” ) ;

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

printf ( "%d\t", dq.arr[i] ) ;

printf ( " < - rear" ) ;
}

/* counts the number of items in dqueue */

int count ( struct dqueue dq )
{
int c, i ;

for ( i = c = 0 ; i < MAX ; i++ )

{
if ( dq.arr[i] != 0 )

c++ ;

}

return c ;
}

#include < conio.h >

#include < alloc.h >

#define MAX 10

struct dqueue
{
int arr[MAX] ;

int front, rear ;
} ;

void initdqueue ( struct dqueue * ) ;

void addqatbeg ( struct dqueue *, int ) ;

void addqatend ( struct dqueue *, int ) ;

int delqatend ( struct dqueue * ) ;

void display ( struct dqueue ) ;

int count ( struct dqueue ) ;

void main( )

{

struct dqueue dq ;

int i, n ;

clrscr( ) ;

initdqueue ( &dq ) ;

addqatend ( &dq, 11 ) ;

addqatbeg ( &dq, 10 ) ;

addqatend ( &dq, 12 ) ;

addqatbeg ( &dq, 9 ) ;

addqatend ( &dq, 13 ) ;

addqatbeg ( &dq, 8 ) ;

addqatend ( &dq, 14 ) ;

addqatbeg ( &dq, 7 ) ;

addqatend ( &dq, 15 ) ;

addqatbeg ( &dq, 6 ) ;

addqatend ( &dq, 16 ) ;

addqatbeg ( &dq, 5 ) ;

display ( dq ) ;

n = count ( dq ) ;

printf ( “\nTotal elements: %d”, n ) ;

i = delqatend ( &dq ) ;

printf ( “\nItem extracted = %d”, i ) ;

i = delqatend ( &dq ) ;

printf ( “\nItem extracted = %d”, i ) ;

i = delqatend ( &dq ) ;

printf ( “\nItem extracted = %d”, i ) ;

i = delqatend ( &dq ) ;

printf ( “\nItem extracted = %d”, i ) ;

n = count ( dq ) ;

printf ( “\nElements Left: %d”, n ) ;

display ( dq ) ;

addqatbeg ( &dq, 5 ) ;

addqatbeg ( &dq, 4 ) ;

addqatbeg ( &dq, 3 ) ;

addqatbeg ( &dq, 2 ) ;

display ( dq ) ;

getch( ) ;
}

/* initializes elements of structure */

void initdqueue ( struct dqueue *p )
{
int i ;

p – > front = p – > rear = -1 ;

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

p - > arr[i] = 0 ;
}

/* adds item at begining of dqueue */

void addqatbeg ( struct dqueue *p, int item )
{
int c, i, k ;

if ( p – > front == 0 && p – > rear == MAX )

{

printf ( “\nQueue is full.\n” ) ;

return ;

}

if ( p – > front == -1 && p – > rear == -1 )

{

p – > front = p – > rear = 0 ;

p – > arr[p - > front] = item ;

return ;
}

if ( p – > rear != MAX )

{

c = count ( *p ) ;

k = p – > rear ;

for ( i = 1 ; i < = c ; i++ )

{
p - > arr[k] = p – > arr[k - 1] ;

k– ;
}

p – > arr[k] = item ;

p – > front = k ;

( p – > rear )++ ;

}

else

{

( p – > front )– ;

p – > arr[p - > front] = item ;

}

}

/* adds item at the end of dqueue */

void addqatend ( struct dqueue *p, int item )

{
int i, k ;

if ( p – > front == 0 && p – > rear == MAX )

{

printf ( “\nQueue is full.\n” ) ;

return ;

}

if ( p – > rear == -1 && p – > front == -1 )

{
p – > rear = p – > front = 0 ;

p – > arr[p - > rear] = item ;

( p – > rear )++ ;

return ;

}

if ( p – > rear == MAX )

{
k = p – > front – 1 ;

for ( i = p – > front – 1 ; i < p - > rear ; i++ )

{
k = i ;

if ( k == MAX – 1 )

p – > arr[k] = 0 ;

else

p – > arr[k] = p – > arr[i + 1] ;

}

( p – > rear )– ;

( p – > front )– ;

}

p – > arr[p - > rear] = item ;

( p – > rear )++ ;

}

/* deletes item from end of dqueue */

int delqatend( struct dqueue *p )

{

int item ;

if ( p – > front == -1 && p – > rear == -1 )

{

printf ( “\nQueue is empty.\n” ) ;

return 0 ;

}

( p – > rear )– ;

item = p – > arr[p - > rear] ;

p – > arr[p - > rear] = 0 ;

if ( p – > rear == 0 )

p – > rear = -1 ;

return item ;
}

/* displays the queue */

void display( struct dqueue dq )

{
int i ;

printf ( “\n front – > ” ) ;

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

printf ( "\t%d", dq.arr[i] ) ;

printf ( " < - rear " ) ;
}

/* counts the number of items in dqueue */

int count( struct dqueue dq )

{
int c, i ;

for ( i = c = 0 ; i < MAX ; i++ )

{

if ( dq.arr[i] != 0 )

c++ ;
}

return c ;
}

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

void main( )
{
int arr[10] = { 1, 2, 3, 9, 11, 13, 17, 25, 57, 90 } ;
int mid, lower = 0 , upper = 9, num, flag = 1 ;

clrscr( ) ;

printf ( “Enter number to search: ” ) ;
scanf ( “%d”, &num ) ;

for ( mid = ( lower + upper ) / 2 ; lower < = upper ;
mid = ( lower + upper ) / 2 )
{
if ( arr[mid] == num )
{
printf ( "The number is at position %d in the array.", mid ) ;
flag = 0 ;
break ;
}
if ( arr[mid] > num )
upper = mid – 1 ;
else
lower = mid + 1 ;
}

if ( flag )
printf ( “Element is not present in the array.” ) ;

getch( ) ;
}

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

void main( )
{
int arr[10] = { 1, 2, 3, 9, 11, 13, 17, 25, 57, 90 } ;
int i, num ;

clrscr( ) ;

printf ( “Enter number to search: ” ) ;
scanf ( “%d”, &num ) ;

for ( i = 0 ; i < = 9 ; i++ )
{
if ( arr[9] < num || arr[i] > = num )
{
if ( arr[i] == num )
printf ( “The number is at position %d in the array.”, i ) ;
else
printf ( “Number is not present in the array.” ) ;
break ;
}
}

getch( ) ;
}