Upload files to "DS/C/endsem-omnibus"
This commit is contained in:
Aadit Agrawal
parent
c53746d826
commit
091ec8cd90
4 changed files with 653 additions and 0 deletions
363
DS/C/endsem-omnibus/treefunc.c
Normal file
363
DS/C/endsem-omnibus/treefunc.c
Normal file
|
|
@ -0,0 +1,363 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#define MAX 10
|
||||
#define MAXQ 10
|
||||
|
||||
// Node structure for binary tree - contains data and pointers to left and right children
|
||||
typedef struct Node {
|
||||
int data;
|
||||
struct Node* lchild;
|
||||
struct Node* rchild;
|
||||
} Node;
|
||||
|
||||
// Queue structure for level order traversal
|
||||
typedef struct {
|
||||
Node* arr[MAX];
|
||||
int front;
|
||||
int rear;
|
||||
} queue;
|
||||
|
||||
// Check if queue is full
|
||||
int isFullq(queue* q) {
|
||||
return (q->rear == MAX-1);
|
||||
}
|
||||
|
||||
// Check if queue is empty
|
||||
int isEmptyq(queue* q) {
|
||||
return (q->front == -1);
|
||||
}
|
||||
|
||||
// Add element to queue
|
||||
void enqueue(queue* q, Node* value) {
|
||||
if(isFullq(q)) {
|
||||
printf("Overflow");
|
||||
return;
|
||||
}
|
||||
else {
|
||||
q->arr[++(q->rear)] = value;
|
||||
if(q->front == -1) {
|
||||
q->front = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Remove and return element from queue
|
||||
Node* dequeue(queue* q) {
|
||||
Node* x;
|
||||
if(isEmptyq(q)) {
|
||||
printf("Underflow");
|
||||
return NULL;
|
||||
}
|
||||
else if(q->front == q->rear) {
|
||||
x = q->arr[q->front];
|
||||
q->front = q->rear = -1;
|
||||
return x;
|
||||
}
|
||||
else {
|
||||
x = q->arr[(q->front)++];
|
||||
return x;
|
||||
}
|
||||
}
|
||||
|
||||
// Stack structure for iterative traversals
|
||||
typedef struct {
|
||||
Node* arr[MAX];
|
||||
int top;
|
||||
} STACK;
|
||||
|
||||
// Check if stack is full
|
||||
int isFull(STACK* s) {
|
||||
return s->top == MAX-1;
|
||||
}
|
||||
|
||||
// Check if stack is empty
|
||||
int isEmpty(STACK* s) {
|
||||
return s->top == -1;
|
||||
}
|
||||
|
||||
// Push element onto stack
|
||||
void push(STACK* s, Node* value) {
|
||||
if(isFull(s)) {
|
||||
printf("Stack Overflow");
|
||||
return;
|
||||
}
|
||||
else {
|
||||
s->arr[++(s->top)] = value;
|
||||
}
|
||||
}
|
||||
|
||||
// Pop and return element from stack
|
||||
Node* pop(STACK* s) {
|
||||
if(isEmpty(s)) {
|
||||
printf("Stack underflow");
|
||||
return NULL;
|
||||
}
|
||||
else {
|
||||
return s->arr[(s->top)--];
|
||||
}
|
||||
}
|
||||
|
||||
// Create new tree node
|
||||
Node* getNode() {
|
||||
Node* newNode = (Node*)malloc(sizeof(Node));
|
||||
newNode->data = 0;
|
||||
newNode->lchild = NULL;
|
||||
newNode->rchild = NULL;
|
||||
return newNode;
|
||||
}
|
||||
|
||||
// Recursively create binary tree
|
||||
Node* createTree(int item) {
|
||||
if(item != -1) {
|
||||
Node* t = getNode();
|
||||
t->data = item;
|
||||
|
||||
int x;
|
||||
printf("Enter the left child of %d (-1 for no child): ", item);
|
||||
scanf("%d", &x);
|
||||
t->lchild = createTree(x);
|
||||
|
||||
printf("Enter the right child of %d (-1 for no child): ", item);
|
||||
scanf("%d", &x);
|
||||
t->rchild = createTree(x);
|
||||
|
||||
return t;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Recursive preorder traversal (Root-Left-Right)
|
||||
void preorder(Node* root) {
|
||||
if(root != NULL) {
|
||||
printf("%d ", root->data);
|
||||
preorder(root->lchild);
|
||||
preorder(root->rchild);
|
||||
}
|
||||
}
|
||||
|
||||
// Recursive inorder traversal (Left-Root-Right)
|
||||
void inorder(Node* root) {
|
||||
if(root != NULL) {
|
||||
inorder(root->lchild);
|
||||
printf("%d ", root->data);
|
||||
inorder(root->rchild);
|
||||
}
|
||||
}
|
||||
|
||||
// Recursive postorder traversal (Left-Right-Root)
|
||||
void postorder(Node* root) {
|
||||
if(root != NULL) {
|
||||
postorder(root->lchild);
|
||||
postorder(root->rchild);
|
||||
printf("%d ", root->data);
|
||||
}
|
||||
}
|
||||
|
||||
// Level order traversal using queue
|
||||
void levelorder(Node* root) {
|
||||
if(root == NULL) return;
|
||||
queue q;
|
||||
q.front = -1;
|
||||
q.rear = -1;
|
||||
Node* t = root;
|
||||
printf("%d ", t->data);
|
||||
enqueue(&q, t);
|
||||
while(!isEmptyq(&q)) {
|
||||
t = dequeue(&q);
|
||||
if(t->lchild) {
|
||||
printf("%d ", t->lchild->data);
|
||||
enqueue(&q, t->lchild);
|
||||
}
|
||||
if(t->rchild) {
|
||||
printf("%d ", t->rchild->data);
|
||||
enqueue(&q, t->rchild);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Iterative preorder traversal using stack
|
||||
void itrpre(Node* root) {
|
||||
STACK s;
|
||||
s.top = -1;
|
||||
Node* t = root;
|
||||
while(t != NULL || !isEmpty(&s)) {
|
||||
if(t != NULL) {
|
||||
printf("%d ", t->data);
|
||||
push(&s, t);
|
||||
t = t->lchild;
|
||||
}
|
||||
else {
|
||||
t = pop(&s);
|
||||
t = t->rchild;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Iterative inorder traversal using stack
|
||||
void itrin(Node* root) {
|
||||
STACK s;
|
||||
s.top = -1;
|
||||
Node* t = root;
|
||||
while(t != NULL || !isEmpty(&s)) {
|
||||
if(t != NULL) {
|
||||
push(&s, t);
|
||||
t = t->lchild;
|
||||
}
|
||||
else {
|
||||
t = pop(&s);
|
||||
printf("%d ", t->data);
|
||||
t = t->rchild;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Iterative postorder traversal using stack
|
||||
void itrpost(Node* root) {
|
||||
STACK s;
|
||||
s.top = -1;
|
||||
Node* t = root;
|
||||
Node* visit = NULL;
|
||||
while(t != NULL || !isEmpty(&s)) {
|
||||
if(t != NULL) {
|
||||
push(&s, t);
|
||||
t = t->lchild;
|
||||
}
|
||||
else {
|
||||
Node* p = s.arr[s.top];
|
||||
if(p->rchild != NULL && p->rchild != visit)
|
||||
t = p->rchild;
|
||||
else {
|
||||
printf("%d ", p->data);
|
||||
visit = pop(&s);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Count total number of nodes in tree
|
||||
int count(Node* root) {
|
||||
Node* p = root;
|
||||
int x, y;
|
||||
if(p != NULL) {
|
||||
x = count(p->lchild);
|
||||
y = count(p->rchild);
|
||||
return x + y + 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Calculate sum of all node values in tree
|
||||
int sumnodes(Node* root) {
|
||||
Node* p = root;
|
||||
int x, y;
|
||||
if(p != NULL) {
|
||||
x = sumnodes(p->lchild);
|
||||
y = sumnodes(p->rchild);
|
||||
return x + y + p->data;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Search for element in tree
|
||||
int Search(Node* root, int ele) {
|
||||
if(root == NULL)
|
||||
return 0;
|
||||
if(root->data == ele)
|
||||
return 1;
|
||||
if(Search(root->lchild, ele))
|
||||
return 1;
|
||||
return Search(root->rchild, ele);
|
||||
}
|
||||
|
||||
// Display menu of operations
|
||||
void displayMenu() {
|
||||
printf("\n=== Binary Tree Operations ===\n");
|
||||
printf("1. Create a new tree\n");
|
||||
printf("2. Recursive Preorder Traversal\n");
|
||||
printf("3. Recursive Inorder Traversal\n");
|
||||
printf("4. Recursive Postorder Traversal\n");
|
||||
printf("5. Iterative Preorder Traversal\n");
|
||||
printf("6. Iterative Inorder Traversal\n");
|
||||
printf("7. Iterative Postorder Traversal\n");
|
||||
printf("8. Level Order Traversal\n");
|
||||
printf("9. Count Nodes\n");
|
||||
printf("10. Sum of Nodes\n");
|
||||
printf("11. Search Element\n");
|
||||
printf("0. Exit\n");
|
||||
printf("Enter your choice: ");
|
||||
}
|
||||
|
||||
int main() {
|
||||
Node* root = NULL;
|
||||
int choice, rootnum, searchEle;
|
||||
|
||||
do {
|
||||
displayMenu();
|
||||
scanf("%d", &choice);
|
||||
|
||||
switch(choice) {
|
||||
case 1:
|
||||
printf("Enter data for root node: ");
|
||||
scanf("%d", &rootnum);
|
||||
root = createTree(rootnum);
|
||||
printf("Tree created successfully!\n");
|
||||
break;
|
||||
case 2:
|
||||
printf("Recursive Preorder Traversal: ");
|
||||
preorder(root);
|
||||
printf("\n");
|
||||
break;
|
||||
case 3:
|
||||
printf("Recursive Inorder Traversal: ");
|
||||
inorder(root);
|
||||
printf("\n");
|
||||
break;
|
||||
case 4:
|
||||
printf("Recursive Postorder Traversal: ");
|
||||
postorder(root);
|
||||
printf("\n");
|
||||
break;
|
||||
case 5:
|
||||
printf("Iterative Preorder Traversal: ");
|
||||
itrpre(root);
|
||||
printf("\n");
|
||||
break;
|
||||
case 6:
|
||||
printf("Iterative Inorder Traversal: ");
|
||||
itrin(root);
|
||||
printf("\n");
|
||||
break;
|
||||
case 7:
|
||||
printf("Iterative Postorder Traversal: ");
|
||||
itrpost(root);
|
||||
printf("\n");
|
||||
break;
|
||||
case 8:
|
||||
printf("Level Order Traversal: ");
|
||||
levelorder(root);
|
||||
printf("\n");
|
||||
break;
|
||||
case 9:
|
||||
printf("Number of nodes: %d\n", count(root));
|
||||
break;
|
||||
case 10:
|
||||
printf("Sum of all nodes: %d\n", sumnodes(root));
|
||||
break;
|
||||
case 11:
|
||||
printf("Enter element to search: ");
|
||||
scanf("%d", &searchEle);
|
||||
if(Search(root, searchEle))
|
||||
printf("Element found in the tree\n");
|
||||
else
|
||||
printf("Element not found in the tree\n");
|
||||
break;
|
||||
case 0:
|
||||
printf("Exiting program...\n");
|
||||
break;
|
||||
default:
|
||||
printf("Invalid choice! Please try again.\n");
|
||||
}
|
||||
} while(choice != 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue