1

C DSA Assignment

Topic: DSA using C Assignment

Course code: CSIT 124

Course Title: Data Structure Using C

Student Name: Manish Kumar

Enrollment No: A35705223056

Program: B-Tech (CSE)

Section: A

Semester: 𝟑𝒓𝒅

Batch: 2023 - 2027

Signature of the student with date

 2

Content

S.No Topic Page No.

1. Linear Search Code 3

2. Binary Search Code 5
3. Bubble Sort Code 7
4. Insertion Sort Code 9
5. Selection Sort Code 11
6. Merge Sort Code 13
7. Quick Sort Code 16
8. Stack Code 18
9. Stack using Structure Code 20
10. Queue Code 22
11. Singly Linked List Code 24
12. Doubly Linked List Code 27
13. Stack Using Linked List Code 30
 3

// Linear Search Code

#include <stdio.h>
int linearsearch(int a[], int b, int k) {
for (int i = 0; i < b; i++) {
if (a[i] == k) {
return i;
}
}
return -1;
}

int main() {
int arr[100], n = 0, key, ch = 0;

while (ch != 3) {
printf("\nLinear Search Menu:\n");
printf("1. Assemble Array\n");
printf("2. Search Element\n");
printf("3. Exit\n");
printf("Enter your Choice: ");
scanf("%d", &ch);

switch (ch) {
case 1:
printf("Enter the size of array: ");
scanf("%d", &n);
printf("Enter Elements: ");
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
break;

case 2:
if (n == 0) {
printf("Array not created! Please assemble the array first.\n");
} else {
printf("Enter the key to search: ");
scanf("%d", &key);
int p = linearsearch(arr, n, key);
if (p != -1) {
printf("%d is available at position %d\n", key, p + 1);
} else {
printf("%d is missing!\n", key);
}
}
break;

case 3:
printf("Exiting!!!\n");
break;
 4

default:
printf("Invalid choice!\n");
}
}

return 0;
}

// OUTPUT
 5

// Binary Search Code

#include <stdio.h>

int binarysearch(int a[], int b, int k) {

int s = 0;
int e = b - 1;
while (s <= e) {
int mid = s + (e - s) / 2;
if (a[mid] == k) {
return mid;
}
if (k > a[mid]) {
s = mid + 1;
} else {
e = mid - 1;
}
}
return -1;
}

int main() {
int arr[100], n = 0, key, ch = 0;

while (ch != 3) {
printf("\nBinary Search Menu:\n");
printf("1. Assemble Array\n");
printf("2. Search Element\n");
printf("3. Exit\n");
printf("Enter your Choice: ");
scanf("%d", &ch);

switch (ch) {
case 1: {
printf("Enter the size of Array: ");
scanf("%d", &n);
printf("\nEnter Elements:\n");
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
break;
}

case 2: {
if (n == 0) {
printf("Array not created!\n");
} else {
printf("Enter the key to search: ");
scanf("%d", &key);
int p = binarysearch(arr, n, key);
if (p != -1) {
printf("%d found at position %d.\n", key, p + 1);
} else {
printf("%d is missing!\n", key);
}
}
 6

break;
}

case 3:
printf("Exiting!!!\n");
break;

default:
printf("Enter correct choice.\n");
}
}

return 0;
}

// OUTPUT
 7

// Bubble Sort Code

#include <stdio.h>

void bubblesort(int a[], int n) {

for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}

int main() {
int arr[100], n = 0, ch = 0;

while (ch != 4) {
printf("\nBubble Sort Menu:\n");
printf("1. Assemble Array\n");
printf("2. See Original Array\n");
printf("3. See Sorted Array\n");
printf("4. Exit\n");
printf("Enter your choice: ");
scanf("%d", &ch);

switch (ch) {
case 1: {
printf("Enter the size of Array: ");
scanf("%d", &n);
printf("\nEnter the elements: ");
for (int i = 0; i < n; i++)
{
scanf("%d", &arr[i]);
}
break;
}
case 2: {
if (n == 0) {
printf("Array not Assembled!!!\n");
} else {
printf("Original Array: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
break;
}
case 3: {
if (n == 0) {
printf("Array not Assembled!!!\n");
} else {
printf("Sorted Array: ");
 8

bubblesort(arr, n);
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
break;
}
case 4: {
printf("Exiting!!!\n");
break;
}
default: {
printf("Enter correct choice!!!\n");
break;
}
}
}

return 0;
}

// OUTPUT
 9

// Insertion Sort Code

#include <stdio.h>

void insertionsort(int a[], int b) {

int i, j, key;
for (i = 1; i < b; i++) {
key = a[i];
j = i - 1;
while (j >= 0 && a[j] > key)
{
a[j + 1] = a[j];
j = j - 1;
}
a[j + 1] = key;
}
}

int main() {
int arr[100], n, ch = 0;

while (ch != 4) {
printf("\nInsertion Sort Menu:\n");
printf("1. Assemble Array\n");
printf("2. See Original Array\n");
printf("3. See Sorted Array\n");
printf("4. Exit\n");
printf("Enter your choice: ");
scanf("%d", &ch);

switch (ch) {
case 1: {
printf("Enter the size of Array: ");
scanf("%d", &n);
printf("Enter the elements: ");
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
break;
}
case 2: {
if (n <= 0)
{
printf("Array not Assembled!!!\n");
}
else
{
printf("Original Array: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
break;
}
case 3: {
if (n <= 0)
{
 10

printf("Array not Assembled!!!\n");

}
else
{
printf("Sorted Array: ");
insertionsort(arr, n);
for (int i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
break;
}
case 4:
{
printf("Exiting!!!\n");
break;
}
default: {
printf("Enter Correct Choice!!!\n");
break;
}
}
}

return 0;
}
// OUTPUT
 11

// Selection Sort Code

#include <stdio.h>

void selectionsort(int a[], int b) {

for (int i = 0; i < b; i++) {
int min = i;
for (int j = i + 1; j < b; j++) {
if (a[j] < a[min]) {
min = j;
}
}
int temp = a[min];
a[min] = a[i];
a[i] = temp;
}
}

int main() {
int arr[100], sort[100], n = 0, ch = 0;

while (ch != 4) {
printf("\nSelection Sort Menu\n");
printf("1. Assemble Array\n");
printf("2. Original Array\n");
printf("3. Sorted Array\n");
printf("4. Exit\n");
printf("Enter your choice: ");
scanf("%d", &ch);

switch (ch) {
case 1: {
printf("Enter the size of the array: ");
scanf("%d", &n);
printf("Enter the elements: ");
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
printf("Array Assembled Successfully!\n");
break;
}
case 2: {
if (n <= 0) {
printf("Array not Assembled.\n");
} else {
printf("\nOriginal Array: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
break;
}
case 3: {
if (n <= 0) {
printf("Array not Assembled.\n");
} else {
for (int i = 0; i < n; i++) {
 12

sort[i] = arr[i];
}
selectionsort(sort, n);
printf("\nSorted Array: ");
for (int i = 0; i < n; i++) {
printf("%d ", sort[i]);
}
printf("\n");
}
break;
}
case 4: {
printf("Exiting!!!\n");
break;
}
default: {
printf("Enter a valid choice.\n");
break;
}
}
}

return 0;
}
// OUTPUT
 13

// Merge Sort Code

#include <stdio.h>

void merge(int a[],int beg,int end,int mid)

{
int i = beg, j= mid + 1, index = beg,temp[100];

while(i<=mid && j<=end)

{
if(a[i]<=a[j])
{
temp[index] = a[i];
i++;
}
else
{
temp[index] = a[j];
j++;
}
index++;
}
while (i<=mid)
{
temp[index] = a[i];
i++;
index++;
}
while (j<=end)
{
temp[index] = a[j];
j++;
index++;
}
for(int i=beg;i<=end;i++)
{
a[i] = temp[i];
}
}

void mergesort(int a[],int beg,int end)

{
if(beg<end)
{
int mid = beg + (end - beg)/2;
mergesort(a,beg,mid);
mergesort(a,mid+1,end);
merge(a,beg,end,mid);
}
}

int main() {
int arr[100],sort[100],n=0,ch=0;
while(ch != 4)
{
printf("\nMerge Sort Menu:\n");
printf("1.Assemble Array\n");
 14

printf("2.Original Array\n");
printf("3.Sorted Array\n");
printf("4.Exit\n");
printf("Enter your choice: ");
scanf("%d",&ch);
switch (ch)
{
case 1:
{
printf("Enter the size of Array: ");
scanf("%d",&n);
printf("Enter the elements: ");
for(int i=0;i<n;i++)
{
scanf("%d",&arr[i]);
}
break;
}
case 2:
{
if(n<=0)
{
printf("Array not Assembled.");
}
else
{
printf("\nOriginal Array : ");
for(int i=0;i<n;i++)
{
printf("%d ",arr[i]);
}
}
break;
}
case 3:
{
if(n<=0)
{
printf("Array not Assembled.");
}
else
{
for(int i=0;i<n;i++)
{
sort[i] = arr[i];
}
mergesort(sort,0,n-1);
printf("\nSorted Array: ");
for(int i= 0;i<n;i++)
{
printf("%d ",sort[i]);
}
}
break;
}
case 4:
{
printf("Exiting!!!");
 15

break;
}

default:
{
printf("Enter Correct Choice.");
}
break;
}
}

return 0;
}

// OUTPUT
 16

// Quick Sort Code

#include <stdio.h>

void swap(int *x, int *y) {

int temp = *x;
*x = *y;
*y = temp;
}

int partition(int a[], int start, int end) {

int pivot = a[end];
int i = start - 1;
for (int j = start; j < end; j++) {
if (a[j] < pivot) {
i++;
swap(&a[i], &a[j]);
}
}
swap(&a[i + 1], &a[end]);
return i + 1;
}

void quicksort(int a[], int start, int end) {

if (start < end) {
int akshu = partition(a, start, end);
quicksort(a, start, akshu - 1);
quicksort(a, akshu + 1, end);
}
}

int main() {
int arr[100], sort[100], n = 0, ch = 0;

while (ch != 4) {
printf("\nQuick Sort Menu:\n");
printf("1. Assemble Array\n");
printf("2. Original Array\n");
printf("3. Sorted Array\n");
printf("4. Exit\n");
printf("Enter your choice: ");
scanf("%d", &ch);

switch (ch) {
case 1: {
printf("Enter the size of the Array: ");
scanf("%d", &n);
printf("Enter the elements: ");
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
break;
}
case 2: {
if (n <= 0) {
printf("Array not Assembled.\n");
} else {
printf("\nOriginal Array: ");
for (int i = 0; i < n; i++) {
 17

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

}
printf("\n");
}
break;}
case 3: {
if (n <= 0) {
printf("Array not Assembled.\n");
} else {
for (int i = 0; i < n; i++) {
sort[i] = arr[i]; }
quicksort(sort, 0, n - 1);
printf("\nSorted Array: ");
for (int i = 0; i < n; i++) {
printf("%d ", sort[i]); }
printf("\n");}
break; }
case 4: {
printf("Exiting!!!\n");
break;
}
default: {
printf("Enter Correct Choice.\n");
break;}}
}
return 0;
}
// OUTPUT
 18

// Stack Code
#include <stdio.h>
#include <stdlib.h>
#define MAX 5

int top = -1;

int arr[MAX];

void push(int has) {

if (top == MAX - 1) {
printf("Overflow!!!\n");
return;
}
top++;
arr[top] = has;
}

void pop() {
if (top == -1) {
printf("Underflow, Enter first!!!\n");
} else {
int him = arr[top];
top--;
printf("The Popped Element is %d\n", him);
}
}

void display() {
if (top == -1) {
printf("Underflow, Enter first!!!\n");
return;
}
printf("Pushed elements are: ");
for (int i = top; i >= 0; i--) {
printf("%d ", arr[i]);
}
printf("\n");
}

int main() {
int ch, n;
while (1) {
printf("\nSTACK Menu:\n");
printf("1. Push Element\n");
printf("2. Pop Element\n");
printf("3. Display\n");
printf("4. Exit\n");
printf("Enter your choice: ");
scanf("%d", &ch);

switch (ch) {
case 1: {
printf("Enter Element: ");
scanf("%d", &n);
push(n);
break;
}
 19

case 2: {
pop();
break;
}
case 3: {
display();
break;
}
case 4: {
printf("Exiting!!!\n");
exit(0);
}
default: {
printf("Enter a correct choice.\n");
break;
}
}
}

return 0;
}
// OUTPUT
 20

// Stack Using Structure Code

#include <stdio.h>
#include <stdlib.h>
#define MAX 10

struct stack {
int top;
int arr[MAX];
};
typedef struct stack s;

int isempty(s *a) {

return (a->top == -1);
}

int isfull(s *a) {

return (a->top == MAX - 1);
}

void push(s *a, int aks) {

if (isfull(a)) {
printf("\nOverflow\n");
return;
}
a->top++;
a->arr[a->top] = aks;
printf("\nElement %d pushed onto the stack.\n", aks);
}

void pop(s *a) {

if (isempty(a)) {
printf("\nUnderflow. Stack is empty.\n");
return;
}
int aks = a->arr[a->top];
a->top--;
printf("\nThe Popped Element is %d\n", aks);
}

void display(s *a) {

if (isempty(a)) {
printf("\nUnderflow. Stack is empty.\n");
return;
}
printf("\nPushed Elements are: ");
for (int i = a->top; i >= 0; i--) {
printf("%d ", a->arr[i]);
}
printf("\n");
}

int main() {
int ch, n;
s a;
a.top = -1;

while (1) {
printf("\nSTACK Menu:\n");
 21

printf("1. Push Element\n");

printf("2. Pop Element\n");
printf("3. Display\n");
printf("4. Exit\n");
printf("Enter your choice: ");
scanf("%d", &ch);

switch (ch) {
case 1: {
printf("Enter Element: ");
scanf("%d", &n);
push(&a, n);
break; }
case 2: {
pop(&a);
break; }
case 3: {
display(&a);
break; }
case 4: {
printf("\nExiting!!!\n");
exit(0); }
default: {
printf("\nEnter a correct choice.\n");
break;}} }
return 0;
}
// OUTPUT
 22

// Queue Code
#include <stdio.h>
#include <stdlib.h>
#define MAX 10
typedef struct queue {
int f, r;
int q[MAX];
} q;
void initialize(q *queue) {
queue->f = -1;queue->r = -1;}
int isEmpty(q *queue) {
return (queue->f == -1);}
int isFull(q *queue) {
return ((queue->r + 1) % MAX == queue->f);}
void enqueue(q *queue, int val) {
if (isFull(queue)) {
printf("\nQueue Overflow.\n"); return; }
if (queue->f == -1) {
queue->f = 0; }
queue->r = (queue->r + 1) % MAX;
queue->q[queue->r] = val;
printf("\nElement %d enqueued.\n", val);}
void dequeue(q *queue) {
if (isEmpty(queue)) {
printf("\nQueue Underflow.\n");
return; }
int val = queue->q[queue->f];
if (queue->f == queue->r) {
queue->f = queue->r = -1; // Reset queue when it's empty.
} else {
queue->f = (queue->f + 1) % MAX; }
printf("\nElement %d dequeued.\n", val);}
void front(q *queue) {
if (isEmpty(queue)) {
printf("\nQueue is empty.\n");
return; }
printf("\nFront element is: %d\n", queue->q[queue->f]);}
void display(q *queue) {
if (isEmpty(queue)) {
printf("\nQueue is empty.\n");
return;}
printf("\nQueue elements: ");
int i = queue->f;
while (1) {
printf("%d ", queue->q[i]);
if (i == queue->r) break;
i = (i + 1) % MAX; }
printf("\n");}
int main() {
int ch, n;
q queue;
initialize(&queue);
while (1) {
 23

printf("\nQueue Menu:\n");
printf("1. Enqueue Element\n");
printf("2. Dequeue Element\n");
printf("3. Front Element\n");
printf("4. Display Queue\n");
printf("5. Exit\n");
printf("Enter your choice: ");
scanf("%d", &ch);
switch (ch) {
case 1: {
printf("Enter Element: ");
scanf("%d", &n);
enqueue(&queue, n);
break; }
case 2: {
dequeue(&queue);
break; }
case 3: {
front(&queue);
break; }
case 4: {
display(&queue);
break; }
case 5: {
printf("\nExiting...\n");
exit(0); }
default: {
printf("\nEnter a valid choice.\n");
break;}}}
return 0;}
// OUTPUT
 24

// Singly Linked List Code

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {

int d;
struct Node *nxt;
} Node;

Node* create(int d) {
Node *new = (Node *)malloc(sizeof(Node));
new->d = d;
new->nxt = NULL;
return new;
}

void display(Node *start) {

if (start == NULL) {
printf("List is empty!\n");
return;
}
while (start != NULL) {
printf("%d -> ", start->d);
start = start->nxt;
}
printf("NULL\n");
}

void ins(Node **start, int d) {

Node *new = create(d);
new->nxt = *start;
*start = new;
}

void del(Node **start, int pos) {

if (*start == NULL) {
printf("List is empty!\n");
return;
}
if (pos < 1) {
printf("Invalid pos!\n");
return;
}
Node *temp = *start;
if (pos == 1) {
*start = temp->nxt;
free(temp);
return;
}
Node *prev = NULL;
int cnt = 1;
while (cnt < pos && temp != NULL) {
prev = temp;
temp = temp->nxt;
cnt++;
}
 25

if (temp == NULL) {
printf("Out of bounds.\n");
return;
}
prev->nxt = temp->nxt;
free(temp);
}

void search(Node *start, int key) {

int pos = 1;
while (start != NULL) {
if (start->d == key) {
printf("%d found at pos %d.\n", key, pos);
return;
}
start = start->nxt;
pos++;
}
printf("%d not found.\n", key);
}

int main() {
Node *start = NULL;
int ch, d, pos;

while (1) {
printf("\n1. Create List\n2. Display\n3. Insert Elements\n4. Delete\n5. Search\n6. Exit\n");
printf("Enter choice: ");
scanf("%d", &ch);

switch (ch) {
case 1:
if (start != NULL) {
printf("List already created!\n");
break;
}
printf("Enter data: ");
scanf("%d", &d);
start = create(d);
break;
case 2:
display(start);
break;
case 3:
printf("Enter data: ");
scanf("%d", &d);
ins(&start, d);
break;
case 4:
printf("Enter position to delete: ");
scanf("%d", &pos);
del(&start, pos);
break;
case 5:
printf("Enter key to search: ");
scanf("%d", &d);
search(start, d);
break;
 26

case 6:
return 0;
default:
printf("Invalid choice!\n");
}
}
}

// OUTPUT
 27

// Doubly Linked List

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {

int d;
struct Node *prev;
struct Node *next;
} Node;

Node* create(int d) {
Node *new = (Node *)malloc(sizeof(Node));
new->d = d;
new->prev = NULL;
new->next = NULL;
return new;
}

void display(Node *start) {

if (start == NULL) {
printf("List is empty!\n");
return;
}
while (start != NULL) {
printf("%d <-> ", start->d);
start = start->next;
}
printf("NULL\n");
}

void ins(Node **start, int d) {

Node *new = create(d);
new->next = *start;
if (*start != NULL) {
(*start)->prev = new;
}
*start = new;
}

void del(Node **start, int pos) {

if (*start == NULL) {
printf("List is empty!\n");
return;
}
if (pos < 1) {
printf("Invalid pos!\n");
return;
}
Node *temp = *start;
if (pos == 1) {
*start = temp->next;
if (*start != NULL) {
(*start)->prev = NULL;
}
free(temp);
return;
}
int cnt = 1;
 28

while (cnt < pos && temp != NULL) {

temp = temp->next;
cnt++;
}
if (temp == NULL) {
printf("Out of bounds.\n");
return;
}
if (temp->next != NULL) {
temp->next->prev = temp->prev;
}
if (temp->prev != NULL) {
temp->prev->next = temp->next;
}
free(temp);
}

void search(Node *start, int key) {

int pos = 1;
while (start != NULL) {
if (start->d == key) {
printf("%d found at pos %d.\n", key, pos);
return;
}
start = start->next;
pos++;
}
printf("%d not found.\n", key);
}

int main() {
Node *start = NULL;
int ch, d, pos;

while (1) {
printf("\n1. Create List\n2. Display\n3. Insert\n4. Delete\n5. Search\n6. Exit\n");
printf("Enter choice: ");
scanf("%d", &ch);

switch (ch) {
case 1:
if (start != NULL) {
printf("List already created!\n");
break;
}
printf("Enter data: ");
scanf("%d", &d);
start = create(d);
break;
case 2:
display(start);
break;
case 3:
printf("Enter data: ");
scanf("%d", &d);
ins(&start, d);
break;
case 4:
 29

printf("Enter position to delete: ");

scanf("%d", &pos);
del(&start, pos);
break;
case 5:
printf("Enter key to search: ");
scanf("%d", &d);
search(start, d);
break;
case 6:
return 0;
default:
printf("Invalid choice!\n");
}
}
}

// OUTPUT
 30

// Stack using Linked List Code

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {

int d;
struct Node *nxt;
} Node;

int isEmpty(Node *top) {

return top == NULL;
}

void push(Node **top, int d) {

Node *new = (Node *)malloc(sizeof(Node));
if (!new) {
printf("Overflow!\n");
return;
}
new->d = d;
new->nxt = *top;
*top = new;
printf("%d pushed onto stack.\n", d);
}

void pop(Node **top) {

if (isEmpty(*top)) {
printf("Underflow! Stack is empty.\n");
return;
}
Node *temp = *top;
*top = temp->nxt;
printf("%d popped from stack.\n", temp->d);
free(temp);
}

void display(Node *top) {

if (isEmpty(top)) {
printf("Stack is empty!\n");
return;
}
printf("Stack elements: ");
while (top != NULL) {
printf("%d ", top->d);
top = top->nxt;
}
printf("\n");
}

int main() {
Node *top = NULL;
int ch, d;

while (1) {
printf("\n1. Push\n2. Pop\n3. Display\n4. Exit\n");
printf("Enter choice: ");
scanf("%d", &ch);
 31

switch (ch) {
case 1:
printf("Enter data to push: ");
scanf("%d", &d);
push(&top, d);
break;
case 2:
pop(&top);
break;
case 3:
display(top);
break;
case 4:
return 0;
default:
printf("Invalid choice!\n");
}
}
}

// OUTPUT