DSC Programs

GURUGRAM UNIVERSITY , GURUGRAM
PRACTICAL FILE
Data Structure using C
CSE – 102 P
Submitted To:- Submitted By:-

Dr. Manvi Breja ANKIT
Assistant Professor In B.TECH [2nd Sem]
Engineering & Technology Roll no. : 231031150009
Department
Program-1: Program in C to implement bubble sort.
#include<stdio.h>
void main()
int arr[30],n,i,j,temp;
printf("enter the size of an array = ");
scanf("%d",&n);
printf("enter the elements of an array\n");
for(i=0;i<n;i++) {
scanf("%d",&arr[i]);
printf("the elements of an array are:-\n");
for(i=0;i<n;i++) {
printf("%d\n",arr[i]);
temp=0;
printf("The sorted array are:-\n");
for(i=0;i<n;i++) {
for(j=0;j<n-i;j++) {
if(arr[j]>arr[j+1]) {
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
for(i=0;i<n;i++) {
}
Output :-
Program-2: Program in C to implement insertion sort.
#include<stdio.h>
void main()
int arr[30],i,j,temp,n;
temp=0;
printf("Enter the size of an array = ");
scanf("%d",&n);
printf("enter the elements of an array:-\n");
for(i=0;i<n;i++) {
scanf("%d",&arr[i]);
printf("The elements of the array are:-\n");
for(i=0;i<n;i++) {
printf("the sorted array is:-\n");
for(i=1;i<n;i++) {
temp=arr[i];
j=i-1;
while(temp<=arr[j]) {
arr[j+1]=arr[j];
j=j-1;
arr[j+1]=temp;
for(i=0;i<n;i++) {
}
Output :-
Program-3: Program in C to implement selection sort.
#include<stdio.h>
void selection_sort(int arr[], int n) {
int i,j,min_index;
for(i=0;i<n-1;i++) {
min_index=i;
for(j=i+1;j<n;j++) {
if(arr[j]<arr[min_index]) {
min_index=j; }
int temp=arr[i];
arr[i]=arr[min_index];
arr[min_index]=temp; }
void main() {
int i;
int my_array[]={37,21,49,11,52,5};
int n=6;
printf("The given array is:-\n");
for(i=0;i<n;i++) {
printf("%d\n",my_array[i]);
selection_sort(my_array,n);
printf("sorted array:\n");
for(i=0;i<n;i++) {
printf("%d\n",my_array[i]);
printf("\n");
}
Output :-
Program-4: Program in C to implement quick sort.
#include <stdio.h>
#define size 100
int partition(int a[], int beg, int end);
void quick_sort(int a[], int beg, int end);
int main() {
int arr[size], i, n;
printf("\n Enter the number of elements in the array: ");
scanf("%d", &n);
printf("\n Enter the elements of the array: ");
for(i=0;i<n;i++) {
scanf("%d", &arr[i]);
quick_sort(arr, 0, n-1);
printf("\n The sorted array is: \n");
for(i=0;i<n;i++) {
printf(" %d\t", arr[i]);
int partition(int a[], int beg, int end) {
int left, right, temp, loc, flag;
loc = left = beg;
right = end;
flag = 0;
while(flag != 1) {
while((a[loc] <= a[right]) && (loc!=right)) {
right--;
if(loc==right) {
flag =1;
}
else if(a[loc]>a[right]) {
temp = a[loc];
a[loc] = a[right];
a[right] = temp;
loc = right;
if(flag!=1) {
while((a[loc] >= a[left]) && (loc!=left)) {
left++;
if(loc==left) {
flag =1; }
else if(a[loc] <a[left]) {
temp = a[loc];
a[loc] = a[left];
a[left] = temp;
loc = left; }
} }
return loc;
void quick_sort(int a[], int beg, int end) {
int loc;
if(beg<end) {
loc = partition(a, beg, end);
quick_sort(a, beg, loc-1);
quick_sort(a, loc+1, end);
}
Output :-
Program-5: Program in C to implement merge sort.
#include <stdio.h>
#define size 100
void merge(int a[], int ARR, int BEG, int END);
void merge_sort(int a[],int, int);
int main() {
int arr[size], i, n;
printf("\n Enter the number of elements in the array : ");
scanf("%d", &n);
printf("\n Enter the elements of the array: ");
for(i=0;i<n;i++) {
scanf("%d", &arr[i]); }
merge_sort(arr, 0, n-1);
printf("\n The sorted array is: \n");
for(i=0;i<n;i++) {
printf(" %d\t", arr[i]); }
void merge(int arr[], int beg, int mid, int end) {
int i=beg, j=mid+1, index=beg, temp[size], k;
while((i<=mid) && (j<=end)) {
if(arr[i] < arr[j]) {
temp[index] = arr[i];
i++; }
else {
temp[index] = arr[j];
j++; }
index++;
if(i>mid) {
while(j<=end) {
int MERGE_SORT ;
int ARR ; int BEG ; int END ; int MID;
MERGE_SORT;
if (BEG < END) {
MID = (BEG + END)/2;
MERGE_SORT;
temp[index] = arr[j];
j++; }
index++;
else {
while(i<=mid) {
temp[index] = arr[i];
i++; }
index++;
for(k=beg;k<index;k++) {
arr[k] = temp[k];
void merge_sort(int arr[], int beg, int end) {
int mid;
if(beg<end) {
mid = (beg+end)/2;
merge_sort(arr, beg, mid);
merge_sort(arr, mid+1, end);
merge(arr, beg, mid, end);
}
Output :-
Program-1: To demonstrate the concept of one dimensional array finding the sum of array
elements .
#include <stdio.h>
#define MAX_SIZE 100
int main()
int arr[MAX_SIZE];
int i, n, sum=0;
printf("Enter size of the array: ");
scanf("%d", &n);
printf("Enter %d elements in the array: ", n);
for(i=0; i<n; i++)
for(i=0; i<n; i++)
sum = sum + arr[i];
printf("Sum of all elements of array = %d", sum);
return 0;
}
Output :-
Program-2: To insert an element in an array .
#include <stdio.h>
int main()
int i, n, num, pos, arr[10];
printf("\n Enter the number of elements in the array : ");
scanf("%d", &n);
for(i=0;i<n;i++)
printf("\n arr[%d] = ", i);
printf("\n Enter the number to be inserted : ");
scanf("%d", &num);
printf("\n Enter the position at which the number has to be added :");
scanf("%d", &pos);
for(i=n -1;i>=pos;i--)
arr[i+1] = arr[i];
arr[pos] = num;
n = n+1;
printf("\n The array after insertion of %d is : ", num);
for(i=0;i<n;i++)
printf("\n arr[%d] = %d", i, arr[i]);
return 0;
}
Output :-
Program-3: To perform addition and multiplication of two matrices.
#include <stdio.h>
void add_matrices (int rows, int cols, int matrix1[][cols], int matrix2[][cols], int result[][cols]) {
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
result[i][j] = matrix1[i][j] + matrix2[i][j];
void multiply_matrices(int rows1, int cols1, int cols2, int matrix1[][cols1], int matrix2[][cols2], int
result[][cols2]) {
int sum;
for (int i = 0; i < rows1; i++) {
for (int j = 0; j < cols2; j++) {
sum = 0;
for (int k = 0; k < cols1; k++) {
sum += matrix1[i][k] * matrix2[k][j]; }
result[i][j] = sum; }
void print_matrix(int rows, int cols, int matrix[][cols]) {
printf("%d\t", matrix[i][j]); }
printf("\n");
int main() {
int rows_a, cols_a, rows_b, cols_b;
printf("Enter the number of rows and columns for matrix A: ");

scanf("%d %d", &rows_a, &cols_a);
printf("Enter the number of rows and columns for matrix B: ");
scanf("%d %d", &rows_b, &cols_b);
if (cols_a != rows_b) {
printf("Number of columns in matrix A must be equal to the number of rows in matrix B for
multiplication.");
return 1;
int matrix_a[rows_a][cols_a], matrix_b[rows_b][cols_b], result_addition[rows_a][cols_a],

result_multiplication[rows_a][cols_b];
printf("Enter elements of matrix A:\n");
for (int i = 0; i < rows_a; i++) {
for (int j = 0; j < cols_a; j++) {
scanf("%d", &matrix_a[i][j]);
printf("Enter elements of matrix B:\n");
for (int i = 0; i < rows_b; i++) {
for (int j = 0; j < cols_b; j++) {
scanf("%d", &matrix_b[i][j]); }
// Addition
printf("Matrix Addition:\n");
add_matrices(rows_a, cols_a, matrix_a, matrix_b, result_addition);
print_matrix(rows_a, cols_a, result_addition);
// Multiplication
printf("\nMatrix Multiplication:\n");
multiply_matrices(rows_a, cols_a, cols_b, matrix_a, matrix_b, result_multiplication);
print_matrix(rows_a, cols_b, result_multiplication);
return 0;
}
Output :-
Program-4: To perform transpose of a matrices.
#include <stdio.h>
void transpose(int rows, int cols, int matrix[][cols], int result[][rows]) {
result[j][i] = matrix[i][j]; }
void print_matrix(int rows, int cols, int matrix[][cols]) {
printf("%d\t", matrix[i][j]); }
printf("\n"); }
int main() {
int rows, cols;
printf("Enter the number of rows and columns of the matrix: ");
scanf("%d %d", &rows, &cols);
int matrix[rows][cols], result[cols][rows];
printf("Enter the elements of the matrix:\n");
scanf("%d", &matrix[i][j]); } }
printf("Original Matrix:\n");
print_matrix(rows, cols, matrix);
transpose(rows, cols, matrix, result);
printf("\nTranspose Matrix:\n");
print_matrix(cols, rows, result);
return 0;
}
Output :-
Program-1: Program to implement stack operations using array.
#include <stdio.h>
#include <stdbool.h>
// Structure to represent a stack
struct Stack {
int items[MAX_SIZE];
int top; };
// Initialize the stack
void initialize(struct Stack *s) {
s->top = -1; }
// Check if the stack is empty
bool isEmpty(struct Stack *s) {
return s->top == -1;
// Check if the stack is full
bool isFull(struct Stack *s) {
return s->top == MAX_SIZE - 1; }
// Push an element onto the stack
void push(struct Stack *s, int value) {
if (isFull(s)) {
printf("Stack Overflow! Cannot push element.\n");
return; }
s->items[++s->top] = value;
printf("%d pushed to stack.\n", value); }
// Pop an element from the stack
int pop(struct Stack *s) {
if (isEmpty(s)) {
printf("Stack Underflow! Cannot pop element.\n");
return -1; }
return s->items[s->top--];
int main() {
struct Stack stack;
initialize(&stack);
int choice, value;
while (1) {
printf("\nStack Operations:\n");
printf("1. Push\n");
printf("2. Pop\n");
printf("3. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("Enter the value to push: ");
scanf("%d", &value);
push(&stack, value);
break;
case 2:
printf("Popped element: %d\n", pop(&stack));
break;
case 3:
printf("Exiting program.\n");
return 0;
default:
printf("Invalid choice! Please enter a valid option.\n"); }
return 0;
}
Output :-
Program-2: Program to evaluate postfix expression using stack.
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
// Structure to represent a stack
struct Stack {
int top; };
void initialize(struct Stack *s) {
s->top = -1; }
int isEmpty(struct Stack *s) {
return s->top == -1; }
int isFull(struct Stack *s) {
return s->top == MAX_SIZE - 1; }
void push(struct Stack *s, int value) {
if (isFull(s)) {
printf("Stack Overflow! Cannot push element.\n");
exit(EXIT_FAILURE); }
s->items[++s->top] = value; }
int pop(struct Stack *s) {
if (isEmpty(s)) {
printf("Stack Underflow! Cannot pop element.\n");
exit(EXIT_FAILURE); }
return s->items[s->top--]; }
// Evaluate postfix expression
int evaluatePostfix(char *exp) {
struct Stack stack;
initialize(&stack);
for (int i = 0; exp[i]; ++i) {

if (isdigit(exp[i])) {
push(&stack, exp[i] - '0'); }
else {
int val1 = pop(&stack);
int val2 = pop(&stack);
switch (exp[i]) {
case '+':
push(&stack, val2 + val1);
break;
case '-':
push(&stack, val2 - val1);
break;
case '*':
push(&stack, val2 * val1);
break;
case '/':
push(&stack, val2 / val1);
break; }
return pop(&stack);
int main() {
char exp[MAX_SIZE];
printf("Enter postfix expression: ");
fgets(exp, sizeof(exp), stdin);
int result = evaluatePostfix(exp);
printf("Result: %d\n", result);
return 0;
}
Output :-
Program-3: Program to perform infix to postfix conversion using stack.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
char stack[MAX_SIZE];
int top = -1;
void push(char item) {
if (top == MAX_SIZE - 1) {
printf("Stack Overflow\n");
return; }
stack[++top] = item; }
char pop() {
if (top == -1) {
printf("Stack Underflow\n");
exit(1); }
return stack[top--]; }
int isOperator(char symbol) {
if (symbol == '^' || symbol == '*' || symbol == '/' || symbol == '+' || symbol == '-') {
return 1; }
return 0; }
int precedence(char symbol) {
if (symbol == '^') {
return 3; }
else if (symbol == '*' || symbol == '/') {
return 2; }
else if (symbol == '+' || symbol == '-') {
return 1; }
else {
return 0; } }
void infixToPostfix(char infix[], char postfix[]) {
int i, j = 0; char symbol;
for (i = 0; infix[i] != '\0'; i++) {
symbol = infix[i];
if (isalnum(symbol)) {
postfix[j++] = symbol;}
else if (symbol == '(') {
push(symbol); }
else if (symbol == ')') {
while (top != -1 && stack[top] != '(') {
postfix[j++] = pop(); }
if (top == -1) {
printf("Invalid expression\n");
exit(1); }
pop(); }
else if (isOperator(symbol)) {
while (top != -1 && precedence(stack[top]) >= precedence(symbol)) {
push(symbol); } }
while (top != -1) {
if (stack[top] == '(') {
printf("Invalid expression\n");
exit(1); }
postfix[j] = '\0'; }
int main() {
char infix[MAX_SIZE], postfix[MAX_SIZE];
printf("Enter an infix expression: ");
fgets(infix, MAX_SIZE, stdin);

infix[strlen(infix) - 1] = '\0'; // removing newline character
infixToPostfix(infix, postfix);
printf("Postfix expression: %s\n", postfix);
return 0; }
Output :-
Program-1: Program to implement queue operations using array.
#include <stdio.h>
struct Queue {
int front;
int rear;};
void createQueue(struct Queue* queue) {
queue->front = -1;
queue->rear = -1;}
int isFull(struct Queue* queue) {
return queue->rear == MAX_SIZE - 1;}
int isEmpty(struct Queue* queue) {
return queue->front == -1;}
void enqueue(struct Queue* queue, int value) {
if (isFull(queue)) {
printf("Queue is full!\n");
return; }
if (isEmpty(queue)) {
queue->front = 0;}
queue->rear++;
queue->items[queue->rear] = value;}
int dequeue(struct Queue* queue) {
printf("Queue is empty!\n");
return -1;}
int removedItem = queue->items[queue->front];
if (queue->front >= queue->rear) {
queue->front = -1;
queue->rear = -1; }
else {
queue->front++;}
return removedItem;}
void display(struct Queue* queue) {
return;}
printf("Queue elements: ");
for (int i = queue->front; i <= queue->rear; i++) {
printf("%d ", queue->items[i]);}
printf("\n");}
int main() {
struct Queue queue;
createQueue(&queue);
int choice, element;
do {printf("1. Enqueue\n");
printf("2. Dequeue\n");
printf("3. Display\n");
switch (choice) {
case 1:
printf("Enter the element to enqueue: ");
scanf("%d", &element);
enqueue(&queue, element);
break;
case 2:
printf("Dequeued element: %d\n", dequeue(&queue));
break;
case 3:
display(&queue);
break;
case 4:
printf("Exiting...\n");
break;
default:
printf("Invalid choice!\n");}
while (choice != 4);
return 0;
}
Output :-
Program-2: Program to implement circular queue using array.
#include <stdio.h>
#define MAX_SIZE 5
struct CircularQueue {
int front;
int rear;};
void createCircularQueue(struct CircularQueue* queue) {
queue->front = -1;
queue->rear = -1;}
int isFull(struct CircularQueue* queue) {
return (queue->front == 0 && queue->rear == MAX_SIZE - 1) || (queue->rear == (queue->front - 1) %

(MAX_SIZE - 1));}
int isEmpty(struct CircularQueue* queue) {
return queue->front == -1;}
void enqueue(struct CircularQueue* queue, int value) {
if (isFull(queue)) {
printf("Queue is full!\n");
return;}
if (queue->front == -1) {
queue->front = 0;}
queue->rear = (queue->rear + 1) % MAX_SIZE;
queue->items[queue->rear] = value;
int dequeue(struct CircularQueue* queue) {
return -1;}
int removedItem = queue->items[queue->front];
if (queue->front == queue->rear) {
queue->front = -1;
queue->rear = -1;}
else {
queue->front = (queue->front + 1) % MAX_SIZE;}
return removedItem;}
void display(struct CircularQueue* queue) {
return; }
if (queue->rear >= queue->front) {
for (int i = queue->front; i <= queue->rear; i++) {
printf("%d ", queue->items[i]); } }
else {
for (int i = queue->front; i < MAX_SIZE; i++) {
printf("%d ", queue->items[i]);
for (int i = 0; i <= queue->rear; i++) {
printf("%d ", queue->items[i]);} }
printf("\n");}
int main() {
struct CircularQueue queue;
createCircularQueue(&queue);
int choice, element;
do {printf("\n1. Enqueue\n");
switch (choice) {
case 1:
printf("Enter the element to enqueue: ");
scanf("%d", &element);
enqueue(&queue, element);
break;
case 2:
break;
case 3:
display(&queue);
break;
case 4:
break;
default:
} while (choice != 4);
return 0;}
Output :-
Program-1: Program to perform following operations on singly linked list :
(a) Create a singly linked list comprising four nodes.
(b) Insert a node at the end of the linked list.
(c) Insert a node at the start of the linked list.
(d) Delete the last node of the linked list.
(e) Search the 3rd node of the linked list and print the value of that node.
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;};
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
if (newNode == NULL) {
printf("Memory allocation failed\n");
exit(1);}
newNode->data = data;
newNode->next = NULL;
return newNode;}
void insertAtEnd(struct Node** headRef, int newData) {
struct Node* newNode = createNode(newData);
if (*headRef == NULL) {
*headRef = newNode;
return;}
struct Node* last = *headRef;
while (last->next != NULL) {
last = last->next;}
last->next = newNode;}
void insertAtBeginning(struct Node** headRef, int newData) {

newNode->next = *headRef;
*headRef = newNode;}
void deleteLastNode(struct Node** headRef) {
if (*headRef == NULL) {
printf("List is empty\n");
return;}
if ((*headRef)->next == NULL) {
free(*headRef);
*headRef = NULL;
return;}
struct Node* secondLast = *headRef;
while (secondLast->next->next != NULL) {
secondLast = secondLast->next;}
free(secondLast->next);
secondLast->next = NULL;}
void searchAndPrint(struct Node* head, int position) {
struct Node* current = head;
int count = 0;
while (current != NULL) {
if (count == position) {
printf("Value of node at position %d: %d\n", position, current->data);
return;}
current = current->next;
count++;}
printf("Node at position %d not found\n", position);}
void displayList(struct Node* head) {
struct Node* current = head;
if (current == NULL) {
printf("List is empty\n");
return;}
printf("Linked list elements: ");
printf("%d ", current->data);
current = current->next;}
printf("\n");}
int main() {
struct Node* head = NULL;
int data;
printf("Enter data for 4 nodes to create the linked list:\n");
for (int i = 0; i < 4; i++) {
printf("Enter data for node %d: ", i + 1);
scanf("%d", &data);
insertAtEnd(&head, data);}
displayList(head);
printf("Enter data to insert at the beginning of the linked list: ");
scanf("%d", &data);
insertAtBeginning(&head, data);
displayList(head);
char choice;
printf("Do you want to delete the last node of the linked list? (y/n): ");
scanf(" %c", &choice);
if (choice == 'y' || choice == 'Y') {
deleteLastNode(&head);
displayList(head);}
int position;
printf("Enter the position of the node to search (0-based indexing): ");
scanf("%d", &position);
searchAndPrint(head, position);
return 0; }
Output :-
Program-2: Program to implement stack using linked list.
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
exit(1); }
return newNode;}
struct Stack {
struct Node* top;};
void initializeStack(struct Stack* stack) {
stack->top = NULL;}
int isEmpty(struct Stack* stack) {
return stack->top == NULL;}
void push(struct Stack* stack, int newData) {
newNode->next = stack->top;
stack->top = newNode;}
int pop(struct Stack* stack) {
if (isEmpty(stack)) {
printf("Stack underflow\n");
return -1; }
struct Node* temp = stack->top;
int poppedData = temp->data;

stack->top = stack->top->next;
free(temp);
return poppedData;}
void displayStack(struct Stack* stack) {
if (isEmpty(stack)) {
printf("Stack is empty\n");
return;}
struct Node* current = stack->top;
printf("Stack elements: ");
printf("\n");}
int main() {
struct Stack stack;
initializeStack(&stack);
int choice, data;
do { printf("\n1. Push\n");
printf("2. Pop\n");
switch (choice) {
case 1:
printf("Enter data to push: ");
scanf("%d", &data);
push(&stack, data);
break;
case 2:
printf("Popped element: %d\n", pop(&stack));
break;
case 3:
displayStack(&stack);
break;
case 4:
break;
default:
return 0;
}
Output :-
Program-3: Program to implement queue using linked list.
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
exit(1);}
return newNode;}
struct Queue {
struct Node* front;
struct Node* rear;};
void initializeQueue(struct Queue* queue) {
queue->front = NULL;
queue->rear = NULL;}
int isEmpty(struct Queue* queue) {
return queue->front == NULL;}
void enqueue(struct Queue* queue, int newData) {
queue->front = newNode;
queue->rear = newNode;
return;}
queue->rear->next = newNode;
queue->rear = newNode;}
int dequeue(struct Queue* queue) {
printf("Queue underflow\n");
return -1;}
struct Node* temp = queue->front;
int dequeuedData = temp->data;
queue->front = queue->front->next;
if (queue->front == NULL) {
queue->rear = NULL;}]
free(temp);
return dequeuedData;}
void displayQueue(struct Queue* queue) {
printf("Queue is empty\n");
return;}
struct Node* current = queue->front;
printf("\n");}
int main() {
struct Queue queue;
initializeQueue(&queue);
int choice, data;
do { printf("\n1. Enqueue\n");

switch (choice) {
case 1:
printf("Enter data to enqueue: ");
scanf("%d", &data);
enqueue(&queue, data);
break;
case 2:
break;
case 3:
displayQueue(&queue);
break;
case 4:
break;
default:
return 0;
}
Output :-
Lab – 1
(SEARCHING)
 Program in C to implement linear search.

 Program in C to implement binary search.
Lab – 2
(SORTING)
 Program in C to implement bubble sort.

 Program in C to implement insertion sort.
 Program in C to implement selection sort.
 Program in C to implement quick sort.
 Program in C to implement merge sort.
Lab – 3
(ARRAYS)
 To demonstrate the concept of one dimensional

array finding the sum of array elements .
 To insert an element in an array.
 To perform addition and multiplication of two
matrices.
 To perform transpose of a matrix.
Lab – 4
(STACKS)
 Program to implement stack operations using

array .
 Program to evaluate postfix expression using
stack.
 Program to perform infix to postfix conversion
using stack.
Lab – 5
(QUEUES)
 Program to implement queue operations using

array.
 Program to implement circular queue using
array.
Lab – 6
(LINKED LIST)
 Program to perform following operations on

singly linked list :
(a) Create a singly linked list comprising four
nodes.
(b) Insert a node at the end of the linked list.
(c) Insert a node at the start of the linked list.
(d) Delete the last node of the linked list.
(e) Search the 3rd node of the linked list and
print the value of that node.
 Program to implement stack using linked list.
 Program to implement queue using linked list.
Index
S.no Aim Date Signature
1 Searching Feb 15,2024
2 Sorting Feb 29,2024
3 Arrays Mar 14,2024
4 Stacks Mar 21,2024
5 Queues Apr 04,2024
6 Linked List Apr 25,2024

DSC Programs

Uploaded by

Copyright:

Available Formats

DSC Programs

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

DSC Programs

Uploaded by

Copyright:

Available Formats

GURUGRAM UNIVERSITY , GURUGRAM

Submitted To:- Submitted By:-

printf("enter the size of an array = ");

printf("enter the elements of an array\n");

printf("the elements of an array are:-\n");

printf("The sorted array are:-\n");

printf("Enter the size of an array = ");

printf("enter the elements of an array:-\n");

printf("The elements of the array are:-\n");

printf("the sorted array is:-\n");

void selection_sort(int arr[], int n) {

printf("The given array is:-\n");

#define size 100

int partition(int a[], int beg, int end);

void quick_sort(int a[], int beg, int end);

printf("\n Enter the number of elements in the array: ");

printf("\n Enter the elements of the array: ");

printf("\n The sorted array is: \n");

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

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

int left, right, temp, loc, flag;

loc = left = beg;

while((a[loc] <= a[right]) && (loc!=right)) {

while((a[loc] >= a[left]) && (loc!=left)) {

else if(a[loc] <a[left]) {

void quick_sort(int a[], int beg, int end) {

loc = partition(a, beg, end);

quick_sort(a, beg, loc-1);

quick_sort(a, loc+1, end);

#define size 100

void merge(int a[], int ARR, int BEG, int END);

void merge_sort(int a[],int, int);

printf("\n Enter the number of elements in the array : ");

printf("\n Enter the elements of the array: ");

printf("\n The sorted array is: \n");

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

void merge(int arr[], int beg, int mid, int end) {

int i=beg, j=mid+1, index=beg, temp[size], k;

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

if(arr[i] < arr[j]) {

int ARR ; int BEG ; int END ; int MID;

if (BEG < END) {

MID = (BEG + END)/2;

void merge_sort(int arr[], int beg, int end) {

merge_sort(arr, beg, mid);

merge_sort(arr, mid+1, end);

merge(arr, beg, mid, end);

#define MAX_SIZE 100

printf("Enter size of the array: ");

printf("Enter %d elements in the array: ", n);

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

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

sum = sum + arr[i];

printf("Sum of all elements of array = %d", sum);

int i, n, num, pos, arr[10];

printf("\n Enter the number of elements in the array : ");

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

printf("\n Enter the number to be inserted : ");

printf("\n The array after insertion of %d is : ", num);