aadit/MIT-Curricular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Upload files to "DS/C/endsem-omnibus"

Browse Source
This commit is contained in:
Aadit Agrawal 2024-11-20 08:29:16 +05:30
parent f1cb7a6c93
commit c53746d826
5 changed files with 779 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

221
DS/C/endsem-omnibus/LL.c Normal file
View File

@ -0,0 +1,221 @@
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
struct Node* head = NULL;
void insertAtBeginning(int value) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = head;
head = newNode;
printf("\nInsertion successful at beginning\n");
}
void insertAtEnd(int value) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = NULL;
if(head == NULL) {
head = newNode;
return;
}
struct Node* temp = head;
while(temp->next != NULL) {
temp = temp->next;
}
temp->next = newNode;
printf("\nInsertion successful at end\n");
}
void insertAtPosition(int value, int position) {
if(position < 1) {
printf("\nInvalid position\n");
return;
}
if(position == 1) {
insertAtBeginning(value);
return;
}
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
struct Node* temp = head;
for(int i = 1; i < position-1 && temp != NULL; i++) {
temp = temp->next;
}
if(temp == NULL) {
printf("\nPosition exceeds list length\n");
free(newNode);
return;
}
newNode->next = temp->next;
temp->next = newNode;
printf("\nInsertion successful at position %d\n", position);
}
void deleteFromBeginning() {
if(head == NULL) {
printf("\nList is empty\n");
return;
}
struct Node* temp = head;
head = head->next;
free(temp);
printf("\nDeletion successful from beginning\n");
}
void deleteFromEnd() {
if(head == NULL) {
printf("\nList is empty\n");
return;
}
if(head->next == NULL) {
free(head);
head = NULL;
return;
}
struct Node* temp = head;
while(temp->next->next != NULL) {
temp = temp->next;
}
free(temp->next);
temp->next = NULL;
printf("\nDeletion successful from end\n");
}
void sortList() {
if(head == NULL || head->next == NULL) {
return;
}
struct Node *current, *index;
int temp;
for(current = head; current != NULL; current = current->next) {
for(index = current->next; index != NULL; index = index->next) {
if(current->data > index->data) {
temp = current->data;
current->data = index->data;
index->data = temp;
}
}
}
printf("\nList sorted successfully\n");
}
void reverseList() {
struct Node *prev = NULL, *current = head, *next = NULL;
while(current != NULL) {
next = current->next;
current->next = prev;
prev = current;
current = next;
}
head = prev;
printf("\nList reversed successfully\n");
}
void display() {
if(head == NULL) {
printf("\nList is empty\n");
return;
}
struct Node* temp = head;
printf("\nList elements are: ");
while(temp != NULL) {
printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}
void search(int value) {
struct Node* temp = head;
int position = 1;
while(temp != NULL) {
if(temp->data == value) {
printf("\nElement %d found at position %d\n", value, position);
return;
}
temp = temp->next;
position++;
}
printf("\nElement %d not found in the list\n", value);
}
int main() {
int choice, value, position;
while(1) {
printf("\n1. Insert at beginning");
printf("\n2. Insert at end");
printf("\n3. Insert at specific position");
printf("\n4. Delete from beginning");
printf("\n5. Delete from end");
printf("\n6. Sort list");
printf("\n7. Reverse list");
printf("\n8. Display");
printf("\n9. Search");
printf("\n10. Exit");
printf("\nEnter your choice: ");
scanf("%d", &choice);
switch(choice) {
case 1:
printf("\nEnter value to insert: ");
scanf("%d", &value);
insertAtBeginning(value);
break;
case 2:
printf("\nEnter value to insert: ");
scanf("%d", &value);
insertAtEnd(value);
break;
case 3:
printf("\nEnter value to insert: ");
scanf("%d", &value);
printf("\nEnter position: ");
scanf("%d", &position);
insertAtPosition(value, position);
break;
case 4:
deleteFromBeginning();
break;
case 5:
deleteFromEnd();
break;
case 6:
sortList();
break;
case 7:
reverseList();
break;
case 8:
display();
break;
case 9:
printf("\nEnter value to search: ");
scanf("%d", &value);
search(value);
break;
case 10:
printf("\nExiting program\n");
exit(0);
default:
printf("\nInvalid choice\n");
}
}
return 0;
}

160
DS/C/endsem-omnibus/bst.c Normal file
View File

@ -0,0 +1,160 @@
#include <stdio.h>
#include <stdlib.h>
// Structure for a binary tree node containing data and pointers to left and right children
struct node {
int data;
struct node *left, *right;
};
// Function to create a new node with given value
// Allocates memory and initializes node with NULL children
struct node* createNode(int value) {
struct node* newNode = malloc(sizeof(struct node));
newNode->data = value;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}
// Function to insert a new value into the BST
// Recursively finds correct position and inserts new node while maintaining BST properties
struct node* insert(struct node* root, int value) {
if (root == NULL) return createNode(value);
if (value < root->data)
root->left = insert(root->left, value);
else if (value > root->data)
root->right = insert(root->right, value);
return root;
}
// Function to find the node with minimum value in a BST
// Used as a helper function for deletion
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 with given value from BST
// Handles three cases: no child, one child, and two children
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 {
// Node with only one child or no child
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;
}
// Node with two children: Get the inorder successor (smallest in the right subtree)
struct node* temp = minValueNode(root->right);
root->data = temp->data;
root->right = deleteNode(root->right, temp->data);
}
return root;
}
// Function to perform inorder traversal of BST
// Visits left subtree, root, then right subtree (LNR)
void inorder(struct node* root) {
if (root != NULL) {
inorder(root->left);
printf("%d ", root->data);
inorder(root->right);
}
}
// Function to perform preorder traversal of BST
// Visits root, left subtree, then right subtree (NLR)
void preorder(struct node* root) {
if (root != NULL) {
printf("%d ", root->data);
preorder(root->left);
preorder(root->right);
}
}
// Function to perform postorder traversal of BST
// Visits left subtree, right subtree, then root (LRN)
void postorder(struct node* root) {
if (root != NULL) {
postorder(root->left);
postorder(root->right);
printf("%d ", root->data);
}
}
// Function to search for a key in BST
// Returns pointer to node if found, NULL if not found
struct node* search(struct node* root, int key) {
if (root == NULL || root->data == key)
return root;
if (root->data < key)
return search(root->right, key);
return search(root->left, key);
}
// Main function providing menu-driven interface for BST operations
int main() {
struct node* root = NULL;
int choice, value;
while(1) {
printf("\n1. Insert\n2. Delete\n3. Inorder\n4. Preorder\n");
printf("5. Postorder\n6. Search\n7. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
switch(choice) {
case 1:
printf("Enter value to insert: ");
scanf("%d", &value);
root = insert(root, value);
break;
case 2:
printf("Enter value to delete: ");
scanf("%d", &value);
root = deleteNode(root, value);
break;
case 3:
printf("Inorder traversal: ");
inorder(root);
printf("\n");
break;
case 4:
printf("Preorder traversal: ");
preorder(root);
printf("\n");
break;
case 5:
printf("Postorder traversal: ");
postorder(root);
printf("\n");
break;
case 6:
printf("Enter value to search: ");
scanf("%d", &value);
if(search(root, value) != NULL)
printf("Found\n");
else
printf("Not Found\n");
break;
case 7:
exit(0);
default:
printf("Invalid choice!\n");
}
}
return 0;
}

172
DS/C/endsem-omnibus/bstiterative.c Normal file
View File

@ -0,0 +1,172 @@
#include <stdio.h>
#include <stdlib.h>
// BST Node structure
typedef struct Node {
int data;
struct Node *left;
struct Node *right;
} Node;
// Function to create a new node
Node* createNode(int value) {
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->data = value;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}
// Iterative Insert function
Node* insert(Node* root, int value) {
// If tree is empty, create root node
if (root == NULL) return createNode(value);
Node* current = root;
while (1) {
// If value is less than current node
if (value < current->data) {
if (current->left == NULL) {
current->left = createNode(value);
break;
}
current = current->left;
}
// If value is greater than current node
else if (value > current->data) {
if (current->right == NULL) {
current->right = createNode(value);
break;
}
current = current->right;
}
// If value already exists
else break;
}
return root;
}
// Iterative Search function
Node* search(Node* root, int value) {
Node* current = root;
while (current != NULL) {
// If value found
if (value == current->data)
return current;
// If value is less than current node
else if (value < current->data)
current = current->left;
// If value is greater than current node
else
current = current->right;
}
return NULL;
}
// Function to find minimum value node
Node* findMin(Node* root) {
if (root == NULL) return NULL;
Node* current = root;
while (current->left != NULL)
current = current->left;
return current;
}
// Iterative Delete function
Node* delete(Node* root, int value) {
if (root == NULL) return root;
Node* current = root;
Node* parent = NULL;
// Find the node to delete and its parent
while (current != NULL && current->data != value) {
parent = current;
if (value < current->data)
current = current->left;
else
current = current->right;
}
// If value not found
if (current == NULL) return root;
// Case 1: Node has no children
if (current->left == NULL && current->right == NULL) {
if (current != root) {
if (parent->left == current)
parent->left = NULL;
else
parent->right = NULL;
}
else
root = NULL;
free(current);
}
// Case 2: Node has one child
else if (current->left == NULL || current->right == NULL) {
Node* child = (current->left) ? current->left : current->right;
if (current != root) {
if (parent->left == current)
parent->left = child;
else
parent->right = child;
}
else
root = child;
free(current);
}
// Case 3: Node has two children
else {
Node* successor = findMin(current->right);
int successorData = successor->data;
delete(root, successor->data);
current->data = successorData;
}
return root;
}
// Iterative Inorder traversal
void inorderTraversal(Node* root) {
if (root == NULL) return;
Node* stack[1000];
int top = -1;
Node* current = root;
while (current != NULL || top != -1) {
// Reach the leftmost node
while (current != NULL) {
stack[++top] = current;
current = current->left;
}
current = stack[top--];
printf("%d ", current->data);
current = current->right;
}
}
// Iterative Level Order traversal
void levelOrder(Node* root) {
if (root == NULL) return;
Node* queue[1000];
int front = 0, rear = 0;
queue[rear++] = root;
while (front < rear) {
Node* current = queue[front++];
printf("%d ", current->data);
if (current->left != NULL)
queue[rear++] = current->left;
if (current->right != NULL)
queue[rear++] = current->right;
}
}

101
DS/C/endsem-omnibus/circq.c Normal file
View File

@ -0,0 +1,101 @@
#include <stdio.h>
#include <stdlib.h>
#define MAX 5
int queue[MAX];
int front = -1;
int rear = -1;
// Different from normal queue: Need to check if (rear+1)%MAX == front for full condition
int isFull() {
if((rear + 1) % MAX == front)
return 1;
return 0;
}
// Different from normal queue: Both front and rear can wrap around to 0
int isEmpty() {
if(front == -1)
return 1;
return 0;
}
void enqueue() {
int item;
if(isFull()) {
printf("\nQueue is Full!!");
}
else {
printf("\nEnter element to insert: ");
scanf("%d", &item);
// Different from normal queue: rear wraps around using modulo
if(front == -1) {
front = rear = 0;
}
else {
rear = (rear + 1) % MAX;
}
queue[rear] = item;
printf("\nElement inserted successfully!");
}
}
void dequeue() {
if(isEmpty()) {
printf("\nQueue is Empty!!");
}
else {
printf("\nDeleted element is: %d", queue[front]);
// Different from normal queue: front wraps around using modulo
if(front == rear) {
front = rear = -1;
}
else {
front = (front + 1) % MAX;
}
}
}
void display() {
int i;
if(isEmpty()) {
printf("\nQueue is Empty!!");
}
else {
printf("\nQueue elements are: ");
// Different from normal queue: Need to use modulo to wrap around while displaying
for(i = front; i != rear; i = (i + 1) % MAX) {
printf("%d ", queue[i]);
}
printf("%d", queue[i]);
}
}
int main() {
int choice;
while(1) {
printf("\n\n1. Insert");
printf("\n2. Delete");
printf("\n3. Display");
printf("\n4. Exit");
printf("\nEnter your choice: ");
scanf("%d", &choice);
switch(choice) {
case 1:
enqueue();
break;
case 2:
dequeue();
break;
case 3:
display();
break;
case 4:
exit(0);
default:
printf("\nInvalid choice!!");
}
}
return 0;
}

125
DS/C/endsem-omnibus/heap.c Normal file
View File

@ -0,0 +1,125 @@
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
// Structure for Min Heap
typedef struct {
int arr[MAX_SIZE];
int size;
} MinHeap;
// Structure for Stack
typedef struct {
int arr[MAX_SIZE];
int top;
} Stack;
// Initialize empty stack
void initStack(Stack *s) {
s->top = -1;
}
// Check if stack is empty
int isEmpty(Stack *s) {
return s->top == -1;
}
// Check if stack is full
int isFull(Stack *s) {
return s->top == MAX_SIZE - 1;
}
// Push element onto stack
void push(Stack *s, int value) {
if(isFull(s)) {
printf("Stack Overflow\n");
return;
}
s->arr[++s->top] = value;
}
// Pop element from stack
int pop(Stack *s) {
if(isEmpty(s)) {
printf("Stack Underflow\n");
return -1;
}
return s->arr[s->top--];
}
// Initialize Min Heap
void initMinHeap(MinHeap *heap) {
heap->size = 0;
}
// Helper function to swap elements
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
// Heapify function
void heapify(MinHeap *heap, int index) {
int smallest = index;
int left = 2 * index + 1;
int right = 2 * index + 2;
if(left < heap->size && heap->arr[left] < heap->arr[smallest])
smallest = left;
if(right < heap->size && heap->arr[right] < heap->arr[smallest])
smallest = right;
if(smallest != index) {
swap(&heap->arr[index], &heap->arr[smallest]);
heapify(heap, smallest);
}
}
// Convert stack to min heap
void stackToHeap(Stack *s, MinHeap *heap) {
// Copy stack elements to heap array
heap->size = s->top + 1;
for(int i = 0; i <= s->top; i++) {
heap->arr[i] = s->arr[i];
}
// Heapify all non-leaf nodes
for(int i = (heap->size/2) - 1; i >= 0; i--) {
heapify(heap, i);
}
}
int main() {
Stack stack;
MinHeap heap;
initStack(&stack);
initMinHeap(&heap);
// Push some elements onto stack
push(&stack, 5);
push(&stack, 3);
push(&stack, 8);
push(&stack, 1);
push(&stack, 2);
printf("Original Stack: ");
for(int i = 0; i <= stack.top; i++) {
printf("%d ", stack.arr[i]);
}
printf("\n");
// Convert stack to min heap
stackToHeap(&stack, &heap);
printf("After Heapifying: ");
for(int i = 0; i < heap.size; i++) {
printf("%d ", heap.arr[i]);
}
printf("\n");
return 0;
}