DSA LAB USING C
Program 1 :WAP to find maximum AND MINIMUM FROM LIST OF NUMBERS
#include <stdio.h>
int main()
{
int n,i;
printf("Enter the number of elements: ");
scanf("%d", &n);
int numbers[n];
printf("Enter %d numbers:\n", n);
for (i = 0; i < n; i++)
{
scanf("%d", &numbers[i]);
}
int max = numbers[0];
int min = numbers[0];
for ( i = 1; i < n; i++)
{
if (numbers[i] > max)
{
max = numbers[i];
}
if (numbers[i] < min)
{
min = numbers[i];
}
}
printf("Maximum: %d\n", max);
printf("Minimum: %d\n", min);
return 0;
}
Output :
**************************************************************************************
Program 2 : WAP TO SEARCH A NUMBER IN AN ARRAY AND RETURN ITS LOCATION( Linear
Search )
#include <stdio.h>
int find(int arr[], int size, int target)
{
int i;
for (i = 0; i < size; i++)
{
if (arr[i] == target)
{
return i;
}
}
return -1;
}
int main()
{
int size, target ,arr[20], index,i;
printf("Enter the size of the array: ");
scanf("%d", &size);
printf("Enter the elements of the array:\n");
for (i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
printf("Enter the element you want to find: ");
scanf("%d", &target);
index = find(arr, size, target);
if (index != -1)
{
printf("Element %d found at index %d\n", target, index);
}
else
{
printf("Element not found in the array\n");
}
return 0;
}
Output :
**************************************************************************************
Program 3 : WAP FOR DELETION OPERATION IN ARRAY
#include <stdio.h>
void dindex(int a[], int *m, int index)
{
printf("Deleted number: %d\n", a[index]);
for (int i = index; i < *m ; i++)
{
a[i] = a[i + 1];
}
(*m)--;
}
void display(int a[], int m)
{
for (int i = 0; i < m; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int main()
{
int a[5];
int i,n=0;
int x,index;
char ch;
printf("Enter numbers \n ");
for(i=0;i<5;i++)
{
scanf("%d", &a[i]);
n++;
}
display(a, n);
do
{
if(n==0)
{
printf("Array Empty\n");
break;
}
printf("Enter index to delete from (0-%d): ", n-1);
scanf("%d", &index);
dindex(a, &n, index);
display(a, n);
printf("Want to delete more[Y/N]");
scanf(" %c",&ch);
}
while(ch=='Y'||ch=='y');
return 0;
}
Output :
***************************************************************************************
Program 4 : WAP TO ADDITION OPERATION IN AN ARRAY
#include <stdio.h>
void add(int arr[], int *m, int pos, int data)
{
int i;
for (i = *m; i > pos; i--)
{
arr[i] = arr[i - 1];
}
arr[pos] = data;
(*m)++;
}
void display(int arr[],int m)
{
int i;
for(i=0;i<m;i++)
{
printf(" %d ", arr[i]);
}
}
int main()
{
int arr[10], n, i,x ,p,y;
char ch;
printf("Enter the size of the array: ");
scanf("%d", &n);
printf("Enter %d numbers:\n", n);
for (i = 0; i < n; i++)
{
scanf("%d", &arr[i]);
}
display(arr,n);
do
{
if(n==10)
{
printf("Array Full");
break;
}
printf("\nEnter the index from (0 to %d) to add: ", n-1);
scanf("%d", &p);
printf("\nEnter the number for index %d: ", p);
scanf("%d", &y);
add(arr, &n, p, y);
display(arr,n);
printf("\nWant to add more[Y/N]");
scanf(" %c", &ch);
}
while(ch=='Y'||ch=='y');
return 0;
}
Output :
*************************************************************************************
Program 5 : WAP for Binary Search
#include <stdio.h>
int binarysearch(int arr[], int n, int data)
{
int left = 0;
int right = n- 1;
while (left <= right)
{
int mid = (left + right) / 2;
if (arr[mid] == data)
{
return mid;
}
else
if (arr[mid] < data)
{
left = mid + 1;
}
else
{
right = mid - 1;
}
}
return -1;
}
int main()
{
int i,n, arr[100],data,index;
printf("Enter the size of the array: ");
scanf("%d", &n);
printf("Enter %d sorted numbers:\n", n);
for (i = 0; i < n; i++)
{
scanf("%d", &arr[i]);
}
printf("Enter the number to search: ");
scanf("%d", &data);
index = binarysearch(arr, n, data);
if (index != -1)
{
printf("Element %d found at index %d\n", data, index);
}
else
{
printf("Element %d not found in the array\n", data);
}
return 0;
}
Output :
*************************************************************************************
Program 6: WAP to implement Stack and its operation using array
#include <stdio.h>
#include <stdlib.h>
#define MAX 5
struct Stack
{
int arr[MAX];
int top;
};
void init(struct Stack *s)
{
s->top = -1;
}
int isempty(struct Stack *s)
{
return (s->top == -1);
}
int isfull(struct Stack *s)
{
return (s->top == MAX - 1);
}
void push(struct Stack *s, int value)
{
if (isfull(s))
{
printf("Stack Overflow!");
}
else
{
s->arr[++(s->top)] = value;
printf("%d pushed to stack\n", value);
}
}
void pop(struct Stack *s)
{
if (isempty(s))
{
printf("Stack Underflow! \n");
}
else
{
printf("Popped element: %d\n", s->arr[s->top--]);
}
}
void peek(struct Stack *s)
{
if (isempty(s))
{
printf("Stack is empty!\n");
}
else
{
printf("Top element: %d\n", s->arr[s->top]);
}
}
void display(struct Stack *s)
{
if (isempty(s))
{
printf("Stack is empty!\n");
}
else
{
printf("Stack elements: ");
for (int i = s->top; i >= 0; i--)
{
printf("%d ", s->arr[i]);
}
printf("\n");
}
}
int main()
{
struct Stack s;
init(&s);
int choice, x;
while (1)
{
printf("\n--- Stack Operations---\n");
printf("1. Push\n2. Pop\n3. Peek\n4. Display\n5. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice)
{
case 1:
printf("Enter value to push: ");
scanf("%d", &x);
push(&s, x);
break;
case 2:
pop(&s);
break;
case 3:
peek(&s);
break;
case 4:
display(&s);
break;
case 5:
exit(0);
default:
printf("Invalid choice! Try again.\n");
}
}
return 0;
}
***************************************************************************************
Program 7 : WAP to convert Infix Expression to Postfix Expression
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#define MAX 100
struct Stack
{
int top;
char arr[MAX];
};
void init(struct Stack *s)
{
s->top = -1;
}
int isEmpty(struct Stack *s)
{
return s->top == -1;
}
void push(struct Stack *s, char c)
{
if (s->top == MAX - 1)
{
printf("Stack Overflow!\n");
return;
}
s->arr[++(s->top)] = c;
}
char pop(struct Stack *s)
{
if (isEmpty(s))
{
return -1;
}
return s->arr[(s->top)--];
}
char peek(struct Stack *s)
{
if (isEmpty(s))
{
return -1;
}
return s->arr[s->top];
}
int precedence(char c)
{
switch (c)
{
case '^': return 3;
case '*': return 2;
case '/': return 2;
case '+': return 1;
case '-': return 1;
default: return -1;
}
}
void infixtopostfix(char infix[], char postfix[])
{
struct Stack s;
init(&s);
int k = 0;
for (int i = 0; infix[i] != '\0'; i++)
{
char c = infix[i];
if (isalnum(c))
{
postfix[k++] = c;
}
else
if (c == '(')
{
push(&s, c);
}
else
if (c == ')')
{
while (!isEmpty(&s) && peek(&s) != '(')
{
postfix[k++] = pop(&s);
}
pop(&s);
}
else
{
while (!isEmpty(&s) && precedence(peek(&s)) >= precedence(c))
{
postfix[k++] = pop(&s);
}
push(&s, c);
}
}
while (!isEmpty(&s))
{
postfix[k++] = pop(&s);
}
postfix[k] = '\0';
}
int main()
{
char infix[MAX], postfix[MAX];
printf("Enter Infix Expression: ");
scanf("%s", infix);
infixtopostfix(infix, postfix);
printf("Postfix Expression: %s\n", postfix);
return 0;
}
Output :
***************************************************************************************
Program 8 : WAP to evaluate Postfix Expression
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h> // for isdigit()
#define MAX 100
int stack[MAX];
int top = -1;
void push(int x)
{
if (top == MAX - 1)
{
printf("Stack Overflow\n");
exit(1);
}
stack[++top] = x;
}
int pop()
{
if (top == -1)
{
printf("Stack Underflow\n");
exit(1);
}
return stack[top--];
}
int evaluate(char exp[])
{
int i;
for (i = 0; exp[i] != '\0'; i++)
{
char ch = exp[i];
if (isdigit(ch))
{
push(ch - '0');
} else
{
int val2 = pop();
int val1 = pop();
int result;
switch (ch)
{
case '+': result = val1 + val2;
break;
case '-': result = val1 - val2;
break;
case '*': result = val1 * val2;
break;
case '/': result = val1 / val2;
break;
case '^':
{
result = 1;
for (int j = 0; j < val2; j++)
{
result *= val1;
}
break;
}
default:
printf("Invalid operator: %c\n", ch);
exit(1);
}
push(result);
}
}
return pop();
}
int main()
{
char exp[MAX];
printf("Enter a postfix expression (single-digit operands): ");
scanf("%s", exp);
int result = evaluate(exp);
printf("Result of Postfix Expression = %d\n", result);
return 0;
}
Output :
*************************************************************************************
