Assignment Ds in C

Assignment DS
PROGRAM 1
1. Perform following operations on 1-D Array:
a. Insert an element at specified position.
b. Delete an element of specified position.
c. Display all elements.
#include <stdio.h>
int main() {
int arr[100]; // Maximum array size is set to 100, change it as needed
int size = 0; // Current size of the array
int choice;
while (1) {
printf("\n1. Insert element at specified position\n");
printf("2. Delete element at specified position\n");
printf("3. Display all elements\n");
printf("4. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
if (size == 100) {
printf("Array is full. Cannot insert more elements.\n");
} else {
int position, element;
printf("Enter position to insert: ");
scanf("%d", &position);
if (position < 0 || position > size) {
printf("Invalid position. Please enter a valid position between 0 and %d.\n", size);
} else {
printf("Enter the element to insert: ");
scanf("%d", &element);
for (int i = size; i > position; i--) {
arr[i] = arr[i - 1];
arr[position] = element;
size++;
printf("Element inserted successfully.\n");
break;
case 2:
if (size == 0) {
printf("Array is empty. Nothing to delete.\n");
} else {
int position;
printf("Enter position to delete: ");
scanf("%d", &position);
if (position < 0 || position >= size) {
printf("Invalid position. Please enter a valid position between 0 and %d.\n", size - 1);
} else {
for (int i = position; i < size - 1; i++) {
arr[i] = arr[i + 1];
size--;
printf("Element deleted successfully.\n");
}
}
break;
case 3:
if (size == 0) {
printf("Array is empty.\n");
} else {
printf("Array elements: ");
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
printf("\n");
break;
case 4:
printf("Exiting program.\n");
return 0;
default:
printf("Invalid choice. Please enter a valid option.\n");
return 0;
OUTPUT
PROGRAM 2
2. Create a linked list with nodes having information about a student and perform
a. Insert a new node at specified position.
b. Delete of a node with the roll number of student specified.
c. Reversal of that linked list.
Coding
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Define the structure for a student node

struct Student {
int rollNumber;
char name[50];
struct Student* next;
};
// Function to create a new student node

struct Student* createStudent(int rollNumber, const char* name) {
struct Student* newStudent = (struct Student*)malloc(sizeof(struct Student));
newStudent->rollNumber = rollNumber;
strcpy(newStudent->name, name);
newStudent->next = NULL;
return newStudent;
}
// Function to insert a new student node at a specified position

void insertNode(struct Student** head, int position, int rollNumber, const char* name) {
struct Student* newStudent = createStudent(rollNumber, name);
if (position == 0) {
newStudent->next = *head;
*head = newStudent;
} else {
struct Student* current = *head;
int i = 0;
while (i < position - 1 && current != NULL) {
current = current->next;
i++;
}
if (current == NULL) {
printf("Invalid position. Insertion at the end of the list.\n");
}
newStudent->next = current->next;
current->next = newStudent;
}
}
// Function to delete a student node with a specific roll number

void deleteNode(struct Student** head, int rollNumber) {
struct Student* prev = NULL;
while (current != NULL && current->rollNumber != rollNumber) {

prev = current;
}
if (current == NULL) {
printf("Student with roll number %d not found.\n", rollNumber);
return;
}
if (prev == NULL) {
*head = current->next;
} else {
prev->next = current->next;
}
free(current);
printf("Student with roll number %d deleted.\n", rollNumber);
}
// Function to reverse the linked list

void reverseList(struct Student** head) {
struct Student* prev = NULL;
struct Student* next;
while (current != NULL) {

next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head = prev;
}
// Function to display the linked list

void displayList(struct Student* head) {
struct Student* current = head;
printf("Roll Number: %d, Name: %s\n", current->rollNumber, current->name);
}
}
int main() {
struct Student* head = NULL;
// Insert nodes
insertNode(&head, 0, 101, "Akash");
insertNode(&head, 1, 102, "Deepak");
insertNode(&head, 1, 103, "Ankur");
insertNode(&head, 2, 104, "Deepanshu");
printf("Original Linked List:\n");

displayList(head);
// Delete a node
deleteNode(&head, 102);
printf("Linked List after deleting a student:\n");
displayList(head);
// Reverse the linked list

reverseList(&head);
printf("Reversed Linked List:\n");
displayList(head);
return 0;
}
SSS
PROGRAM 3
3. Create doubly linked list with nodes having information about an employee and perform Insertion at
front of doubly linked list and perform deletion at end of that doubly linked list.
CODING
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Define the structure for an employee node
struct Employee {
int employeeID;
char name[50];
struct Employee* next;
struct Employee* prev;
};
// Function to create a new employee node
struct Employee* createEmployee(int employeeID, const char* name) {
struct Employee* newEmployee = (struct Employee*)malloc(sizeof(struct Employee));
newEmployee->employeeID = employeeID;
strcpy(newEmployee->name, name);
newEmployee->next = NULL;
newEmployee->prev = NULL;
return newEmployee;
// Function to insert an employee node at the front of the doubly linked list
void insertAtFront(struct Employee** head, int employeeID, const char* name) {
struct Employee* newEmployee = createEmployee(employeeID, name);

if (*head == NULL) {
*head = newEmployee;
} else {
newEmployee->next = *head;
(*head)->prev = newEmployee;
*head = newEmployee;
// Function to delete an employee node at the end of the doubly linked list
void deleteAtEnd(struct Employee** head) {
if (*head == NULL) {
printf("The list is empty. Cannot delete from an empty list.\n");
return;
struct Employee* current = *head;
while (current->next != NULL) {
if (current->prev != NULL) {
current->prev->next = NULL;
} else {
*head = NULL; // The list had only one element
free(current);
// Function to display the doubly linked list from the front
void displayFromFront(struct Employee* head) {

struct Employee* current = head;
printf("Employee ID: %d, Name: %s\n", current->employeeID, current->name);
int main() {
struct Employee* head = NULL;
// Insert employees at the front of the list
insertAtFront(&head, 101, "Akash");
insertAtFront(&head, 102, "Ankur");
insertAtFront(&head, 103, "Deepak");
printf("Doubly Linked List (from front):\n");
displayFromFront(head);
// Delete an employee from the end
deleteAtEnd(&head);
printf("\nDoubly Linked List after deleting an employee from the end:\n");
displayFromFront(head);
return 0;
OUTPUT
PROGRAM 4
Q4 Create a stack and perform Push, Pop, Peek and Traverse operations on the stack using Array or Linked
list.
CODING
#include <stdio.h>
#define MAX_SIZE 100
int stack[MAX_SIZE];
int top = -1;
// Function to push an element onto the stack
void push(int value) {
if (top == MAX_SIZE - 1) {
printf("Stack is full. Cannot push.\n");
return;
stack[++top] = value;
printf("Pushed: %d\n", value);
// Function to pop the top element from the stack
int pop() {
if (top == -1) {
printf("Stack is empty. Cannot pop.\n");
return -1; // Return an error value
int poppedValue = stack[top--];
printf("Popped: %d\n", poppedValue);

return poppedValue;
// Function to peek at the top element of the stack
int peek() {
if (top == -1) {
printf("Stack is empty. Cannot peek.\n");
return -1; // Return an error value
printf("Peeked: %d\n", stack[top]);
return stack[top];
// Function to traverse and display all elements of the stack
void traverse() {
if (top == -1) {
printf("Stack is empty.\n");
return;
printf("Stack elements: ");
for (int i = 0; i <= top; i++) {
printf("%d ", stack[i]);
printf("\n");
int main() {
int choice, value;
while (true) {
printf("\n1. Push\n2. Pop\n3. Peek\n4. Traverse\n5. Quit\n");
switch (choice) {
case 1:
printf("Enter value to push: ");
scanf("%d", &value);
push(value);
break;
case 2:
pop();
break;
case 3:
peek();
break;
case 4:
traverse();
break;
case 5:
printf("Exiting the program.\n");
return 0;
default:
printf("Invalid choice. Please enter a valid option.\n");
}
OUTPUT
PROGRAM 5
4. Create a Linear Queue using Array or Linked List and implement different operations such as
Insert, Delete, and Display the queue elements.
CODING
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
// Structure to represent the queue
struct Queue {
int items[MAX_SIZE];
int front;
int rear;
};
// Function to create an empty queue
void initQueue(struct Queue *q) {
q->front = -1;
q->rear = -1;
// Function to check if the queue is empty
int isEmpty(struct Queue *q) {
return (q->front == -1);
// Function to check if the queue is full
int isFull(struct Queue *q) {

return (q->rear == MAX_SIZE - 1);
// Function to insert an element into the queue
void enqueue(struct Queue *q, int value) {
if (isFull(q)) {
printf("Queue is full. Cannot enqueue.\n");
} else {
if (isEmpty(q)) {
q->front = 0;
q->rear++;
q->items[q->rear] = value;
printf("Inserted: %d\n", value);
// Function to remove an element from the queue
int dequeue(struct Queue *q) {
int item;
if (isEmpty(q)) {
printf("Queue is empty. Cannot dequeue.\n");
return -1;
} else {
item = q->items[q->front];
q->front++;
if (q->front > q->rear) {
// Reset the queue when it becomes empty
q->front = q->rear = -1;
return item;
}
// Function to display the elements of the queue
void display(struct Queue *q) {
int i;
if (isEmpty(q)) {
printf("Queue is empty.\n");
} else {
printf("Queue elements: ");
for (i = q->front; i <= q->rear; i++) {
printf("%d ", q->items[i]);
printf("\n");
int main() {
struct Queue q;
initQueue(&q);
int choice, value;
while (1) {
printf("1. Enqueue\n");
printf("2. Dequeue\n");
printf("3. Display\n");
printf("4. Quit\n");
switch (choice) {
case 1:
printf("Enter the value to enqueue: ");
scanf("%d", &value);
enqueue(&q, value);
break;
case 2:
dequeue(&q);
break;
case 3:
display(&q);
break;
case 4:
exit(0);
default:
printf("Invalid choice. Please try again.\n");
return 0;
OUTPUT
PROGRAM 6
6. Implement sparse matrix using array. Description of program:
a. Read a 2-D array from the user.
b. Store it in the sparse matrix form, use array of structures.
C. Print the final array.
CODING
#include <stdio.h>
#define MAX_ROWS 100
#define MAX_COLS 100
// Structure to represent a sparse matrix element
struct SparseElement {
int row;
int col;
int value;
};
// Function to convert a 2-D array into a sparse matrix
void convertToSparse(int arr[MAX_ROWS][MAX_COLS], int rows, int cols, struct

SparseElement sparseArr[]) {
int k = 0;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (arr[i][j] != 0) {
sparseArr[k].row = i;
sparseArr[k].col = j;
sparseArr[k].value = arr[i][j];
k++;
}
sparseArr[k].row = rows;
sparseArr[k].col = cols;
sparseArr[k].value = k; // Number of non-zero elements
// Function to print the sparse matrix
void printSparseMatrix(struct SparseElement sparseArr[]) {
int k = sparseArr[0].value;
printf("Sparse Matrix:\n");
printf("Row\tColumn\tValue\n");
printf("%d\t%d\t%d\n", sparseArr[0].row, sparseArr[0].col, k);
for (int i = 1; i <= k; i++) {
printf("%d\t%d\t%d\n", sparseArr[i].row, sparseArr[i].col, sparseArr[i].value);
int main() {
int rows, cols;
printf("Enter the number of rows: ");
scanf("%d", &rows);
printf("Enter the number of columns: ");
scanf("%d", &cols);
int arr[MAX_ROWS][MAX_COLS];
printf("Enter the elements of the 2-D array:\n");
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
scanf("%d", &arr[i][j]);
struct SparseElement sparseArr[MAX_ROWS * MAX_COLS];
// Convert the 2-D array to sparse matrix
convertToSparse(arr, rows, cols, sparseArr);
// Print the sparse matrix
printSparseMatrix(sparseArr);
return 0;
OUTPUT
PROGRAM 7
7 Implement insertion, deletion and traversals (inorder, preorder and postorder) on Binary Search Tree.
CODING
#include <stdio.h>
#include <stdlib.h>
// Define the structure for the node of the BST
struct Node {
int data;
struct Node *left;
struct Node *right;
};
// Function to create a new node
struct Node *createNode(int value) {
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->data = value;
newNode->left = newNode->right = NULL;
return newNode;
// Function to insert a new node into the BST
struct Node *insertNode(struct Node *root, int value) {
if (root == NULL) {
return createNode(value);
}
if (value < root->data) {
root->left = insertNode(root->left, value);
} else if (value > root->data) {
root->right = insertNode(root->right, value);
return root;
// Function to perform inorder traversal (left-root-right)
void inorderTraversal(struct Node *root) {
if (root != NULL) {
inorderTraversal(root->left);
printf("%d ", root->data);
inorderTraversal(root->right);
// Function to perform preorder traversal (root-left-right)
void preorderTraversal(struct Node *root) {
if (root != NULL) {
preorderTraversal(root->left);
preorderTraversal(root->right);
// Function to perform postorder traversal (left-right-root)
void postorderTraversal(struct Node *root) {
if (root != NULL) {
postorderTraversal(root->left);
postorderTraversal(root->right);
// Function to find the minimum value node in a BST
struct Node *minValueNode(struct Node *node) {
struct Node *current = node;
while (current && current->left != NULL) {
current = current->left;
return current;
// Function to delete a node from the BST
struct Node *deleteNode(struct Node *root, int value) {
if (root == NULL) {
return root;
if (value < root->data) {
root->left = deleteNode(root->left, value);
} else if (value > root->data) {
root->right = deleteNode(root->right, value);
} else {
if (root->left == NULL) {
struct Node *temp = root->right;
free(root);
return temp;
} else if (root->right == NULL) {
struct Node *temp = root->left;

free(root);
return temp;
struct Node *temp = minValueNode(root->right);
root->data = temp->data;
root->right = deleteNode(root->right, temp->data);
return root;
// Function to free memory allocated for the BST
void freeBST(struct Node *root) {
if (root != NULL) {
freeBST(root->left);
freeBST(root->right);
free(root);
int main() {
struct Node *root = NULL;
root = insertNode(root, 50);
insertNode(root, 30);
printf("Inorder traversal: ");

inorderTraversal(root);
printf("\n");
printf("Preorder traversal: ");
preorderTraversal(root);
printf("\n");
printf("Postorder traversal: ");
postorderTraversal(root);
printf("\n");
root = deleteNode(root, 20);
printf("Inorder traversal after deleting 20: ");
inorderTraversal(root);
printf("\n");
freeBST(root); // Free the allocated memory for BST
return 0;
OUTPUT
PROGRAM 8
8 Implement Selection Sort, Bubble Sort, Insertion sort, Merge sort, Quick sort, and Heap Sort using array as a
data structure.
CODING
#include <stdio.h>
// Selection Sort
void selectionSort(int arr[], int n) {
// Implementation
// Bubble Sort
void bubbleSort(int arr[], int n) {
// Implementation
// Insertion Sort
void insertionSort(int arr[], int n) {
// Implementation
// Merge Sort
void merge(int arr[], int l, int m, int r) {
// Implementation
void mergeSort(int arr[], int l, int r) {
// Implementation
}
// Quick Sort
int partition(int arr[], int low, int high) {
// Implementation
void quickSort(int arr[], int low, int high) {
// Implementation
// Heap Sort
void heapify(int arr[], int n, int i) {
// Implementation
void heapSort(int arr[], int n) {
// Implementation
int main() {
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr) / sizeof(arr[0]);
// Selection Sort
printf("Selection Sort:\n");
int selectionArr[n];
for (int i = 0; i < n; i++) {
selectionArr[i] = arr[i];
selectionSort(selectionArr, n);
for (int i = 0; i < n; i++) {
printf("%d ", selectionArr[i]);
printf("\n");
// Bubble Sort
printf("Bubble Sort:\n");
int bubbleArr[n];
for (int i = 0; i < n; i++) {
bubbleArr[i] = arr[i];
bubbleSort(bubbleArr, n);
for (int i = 0; i < n; i++) {
printf("%d ", bubbleArr[i]);
printf("\n");
// Insertion Sort
printf("Insertion Sort:\n");
int insertionArr[n];
for (int i = 0; i < n; i++) {
insertionArr[i] = arr[i];
insertionSort(insertionArr, n);
for (int i = 0; i < n; i++) {
printf("%d ", insertionArr[i]);
printf("\n");
// Merge Sort
printf("Merge Sort:\n");
int mergeArr[n];
for (int i = 0; i < n; i++) {
mergeArr[i] = arr[i];
mergeSort(mergeArr, 0, n - 1);
for (int i = 0; i < n; i++) {

printf("%d ", mergeArr[i]);
printf("\n");
// Quick Sort
printf("Quick Sort:\n");
int quickArr[n];
for (int i = 0; i < n; i++) {
quickArr[i] = arr[i];
quickSort(quickArr, 0, n - 1);
for (int i = 0; i < n; i++) {
printf("%d ", quickArr[i]);
printf("\n");
// Heap Sort
printf("Heap Sort:\n");
int heapArr[n];
for (int i = 0; i < n; i++) {
heapArr[i] = arr[i];
heapSort(heapArr, n);
for (int i = 0; i < n; i++) {
printf("%d ", heapArr[i]);
printf("\n");
return 0;
OURPUT
PROGRAM 9
9 Company ABC maintains its daily sale amount in a one dimensional array. The sales manager of the
company wants to find a pair with the given total sale amount from the stored sales data if any. You are
required to write the code using suitable data structure(s) to solve his problem.
CODING
#include <stdio.h>
#define TABLE_SIZE 10000 // Size of the hash table
// Structure to store elements in the hash table
struct Node {
int key;
int value;
struct Node *next;
};
// Function to create a new node
struct Node *createNode(int key, int value) {

newNode->key = key;
newNode->value = value;
newNode->next = NULL;
return newNode;
// Function to insert a key-value pair into the hash table
void insert(struct Node *hashTable[], int key, int value) {
int index = key % TABLE_SIZE;
if (hashTable[index] == NULL) {
hashTable[index] = createNode(key, value);
} else {
struct Node *temp = hashTable[index];
while (temp->next != NULL) {
temp = temp->next;
temp->next = createNode(key, value);
// Function to search for a pair with given total sale amount
void findPair(int sales[], int size, int target) {
struct Node *hashTable[TABLE_SIZE] = {NULL};
for (int i = 0; i < size; i++) {
int complement = target - sales[i];
int index = complement % TABLE_SIZE;
if (hashTable[index] != NULL) {
struct Node *temp = hashTable[index];
while (temp != NULL) {
if (temp->value == complement) {
printf("Pair found: %d + %d = %d\n", sales[i], complement, target);
return;
temp = temp->next;
insert(hashTable, sales[i], sales[i]);
printf("No pair found with the given total sale amount.\n");
int main() {
int sales[] = {10, 20, 30, 40, 50}; // Replace with your daily sale data
int size = sizeof(sales) / sizeof(sales[0]);
int totalSaleAmount = 70; // Change this to the desired total sale amount
findPair(sales, size, totalSaleAmount);
return 0;
OUTPUT
PROGRAM 10
10 Aman created two Binary Trees of the same data using two different algorithms. Now he wants
check that both the Binary Trees are identical or not. You are required to write the code using
suitable data structure(s) to solve his problem.
CODING
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
// Structure for a Node in Binary Tree
struct Node {
int data;
struct Node *left;
struct Node *right;
};
// Function to create a new Node
struct Node *createNode(int value) {
newNode->data = value;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
// Function to check if two binary trees are identical
bool areIdentical(struct Node *root1, struct Node *root2) {
if (root1 == NULL && root2 == NULL) {
return true;
}
if (root1 == NULL || root2 == NULL) {
return false;
return (root1->data == root2->data) &&
areIdentical(root1->left, root2->left) &&
areIdentical(root1->right, root2->right);
// Function to deallocate memory used by the tree
void freeTree(struct Node *root) {
if (root != NULL) {
freeTree(root->left);
freeTree(root->right);
free(root);
int main() {
struct Node *root1 = createNode(1);
root1->left = createNode(2);
root1->right = createNode(3);
root1->left->left = createNode(4);
root1->left->right = createNode(5);
struct Node *root2 = createNode(1);
root2->left = createNode(2);
root2->right = createNode(3);
root2->left->left = createNode(4);
root2->left->right = createNode(5);
if (areIdentical(root1, root2)) {
printf("Both Binary Trees are identical.\n");
} else {
printf("Binary Trees are not identical.\n");
// Deallocate memory used by the trees
freeTree(root1);
freeTree(root2);
return 0;
OUTPUT

Assignment Ds in C

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

Assignment Ds in C

Uploaded by

Copyright:

Available Formats

Assignment DS

int arr[100]; // Maximum array size is set to 100, change it as needed

int size = 0; // Current size of the array

printf("\n1. Insert element at specified position\n");

printf("2. Delete element at specified position\n");

printf("3. Display all elements\n");

printf("Enter your choice: ");

printf("Array is full. Cannot insert more elements.\n");

int position, element;

printf("Enter position to insert: ");

if (position < 0 || position > size) {

printf("Enter the element to insert: ");

for (int i = size; i > position; i--) {

arr[i] = arr[i - 1];

printf("Element inserted successfully.\n");

printf("Array is empty. Nothing to delete.\n");

printf("Enter position to delete: ");

if (position < 0 || position >= size) {

for (int i = position; i < size - 1; i++) {

arr[i] = arr[i + 1];

printf("Element deleted successfully.\n");

printf("Array elements: ");

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

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

printf("Invalid choice. Please enter a valid option.\n");

// Define the structure for a student node

// Function to create a new student node

// Function to insert a new student node at a specified position

// Function to delete a student node with a specific roll number

while (current != NULL && current->rollNumber != rollNumber) {

// Function to reverse the linked list

while (current != NULL) {

// Function to display the linked list

printf("Original Linked List:\n");

// Reverse the linked list

// Define the structure for an employee node

struct Employee* next;

struct Employee* prev;

// Function to create a new employee node

struct Employee* createEmployee(int employeeID, const char* name) {

struct Employee* newEmployee = (struct Employee*)malloc(sizeof(struct Employee));

void insertAtFront(struct Employee** head, int employeeID, const char* name) {

struct Employee* newEmployee = createEmployee(employeeID, name);

void deleteAtEnd(struct Employee** head) {

printf("The list is empty. Cannot delete from an empty list.\n");

struct Employee* current = *head;

while (current->next != NULL) {

*head = NULL; // The list had only one element

// Function to display the doubly linked list from the front

void displayFromFront(struct Employee* head) {

while (current != NULL) {

printf("Employee ID: %d, Name: %s\n", current->employeeID, current->name);

struct Employee* head = NULL;

// Insert employees at the front of the list

insertAtFront(&head, 101, "Akash");

insertAtFront(&head, 102, "Ankur");

insertAtFront(&head, 103, "Deepak");

printf("Doubly Linked List (from front):\n");

// Delete an employee from the end

printf("\nDoubly Linked List after deleting an employee from the end:\n");

#define MAX_SIZE 100

int top = -1;

// Function to push an element onto the stack