• Project Of DataStructure Tree node All Code

#include <stdio.h>

#include <stdlib.h>

#include <limits.h>

#include <ctype.h>

#include <string.h>

// Define the node structure.

struct Node {

int data;

struct Node* left;

struct Node* right;

};

// Create a new node with given data.

struct Node* createNode(int data) {

struct Node* newNode = (struct Node*) malloc(sizeof(struct Node));

if (newNode == NULL) {

printf("Memory allocation error!\n");

exit(1);

newNode->data = data;

newNode->left = newNode->right = NULL;

return newNode;

// Iterative BST insertion.

struct Node* insert(struct Node* root, int data) {

struct Node* newNode = createNode(data);

return newNode;

struct Node* current = root;

struct Node* parent = NULL;

while (current) {

parent = current;

if (data < current->data)

current = current->left;

else

current = current->right;

if (data < parent->data)

parent->left = newNode;

else

parent->right = newNode;

return root;

// Iterative search in BST. Returns pointer to the node if found; otherwise NULL.

struct Node* searchNode(struct Node* root, int key) {

while (root) {

if (root->data == key)

return root;

if (key < root->data)

root = root->left;

else

root = root->right;
 }

return NULL;

// Find the minimum value in BST.

int findMin(struct Node* root) {

if (root == NULL) return INT_MIN;

while (root->left)

root = root->left;

return root->data;

// Find the maximum value in BST.

int findMax(struct Node* root) {

if (root == NULL) return INT_MAX;

while (root->right)

root = root->right;

return root->data;

// Iterative Level-order traversal.

void levelOrderTraversal(struct Node* root) {

if (root == NULL) return;

struct Node* queue[100];

int front = 0, rear = 0;

queue[rear++] = root;

while (front < rear) {

struct Node* current = queue[front++];

if (current->left)

queue[rear++] = current->left;

if (current->right)

queue[rear++] = current->right;

printf("\n");

// Iterative In-order traversal using a stack.

void inOrderTraversal(struct Node* root) {

struct Node* stack[100];

int top = -1;

struct Node* current = root;

while (current || top >= 0) {

while (current) {

stack[++top] = current;

current = current->left;

current = stack[top--];

printf("%d ", current->data);

current = current->right;

printf("\n");

// Iterative Pre-order traversal using a stack.

void preOrderTraversal(struct Node* root) {

if (root == NULL)

return;
 struct Node* stack[100];

int top = -1;

stack[++top] = root;

while (top >= 0) {

struct Node* current = stack[top--];

printf("%d ", current->data);

// Push right first so that left is processed first.

if (current->right)

stack[++top] = current->right;

if (current->left)

stack[++top] = current->left;

printf("\n");

// Iterative Post-order traversal using two stacks.

void postOrderTraversal(struct Node* root) {

if (root == NULL)

return;

struct Node* stack1[100];

struct Node* stack2[100];

int top1 = -1, top2 = -1;

stack1[++top1] = root;

while (top1 >= 0) {

struct Node* current = stack1[top1--];

if (current->left)

stack1[++top1] = current->left;

if (current->right)

stack1[++top1] = current->right;

while (top2 >= 0) {

printf("%d ", stack2[top2--]->data);

printf("\n");

// Iterative deletion from BST.

// This function deletes the node with key "key" and returns the new root.

struct Node* deleteNode(struct Node* root, int key) {

struct Node* parent = NULL;

struct Node* current = root;

// Search for the node.

while (current && current->data != key) {

parent = current;

if (key < current->data)

current = current->left;

else

current = current->right;

if (current == NULL) {

printf("Node with key %d not found.\n", key);

return root; // key not found.

// Case 1: Node has no children.

if (current->left == NULL && current->right == NULL) {

if (parent == NULL) // Node to delete is root.

root = NULL;

else if (parent->left == current)

parent->left = NULL;

else

parent->right = NULL;

free(current);

// Case 2: Node has two children.

else if (current->left && current->right) {

// Find inorder successor (smallest in right subtree).

struct Node* successor = current->right;

struct Node* successorParent = current;

while (successor->left) {

successorParent = successor;

successor = successor->left;

// Copy successor's data to current node.

current->data = successor->data;

// Delete the successor now.

if (successorParent->left == successor)

successorParent->left = successor->right;

else

successorParent->right = successor->right;

free(successor);

// Case 3: Node has one child.

struct Node* child = (current->left) ? current->left : current->right;

if (parent == NULL)

root = child;

else if (parent->left == current)

parent->left = child;

else

parent->right = child;

free(current);

return root;

// Display the full tree by printing nodes level by level.

// This iterative level-order display also prints the level number.

void displayFullTree(struct Node* root) {

if (root == NULL) {

printf("Tree is empty.\n");

return;

struct Node* queue[100];

int levels[100];

int front = 0, rear = 0;

queue[rear] = root;

levels[rear] = 0;

rear++;

int currentLevel = 0;
 printf("Level %d: ", currentLevel);

while (front < rear) {

struct Node* curr = queue[front];

int lev = levels[front];

front++;

if (lev > currentLevel) {

currentLevel = lev;

printf("\nLevel %d: ", currentLevel);

printf("%d ", curr->data);

if (curr->left) {

queue[rear] = curr->left;

levels[rear] = lev + 1;

rear++;

if (curr->right) {

queue[rear] = curr->right;

levels[rear] = lev + 1;

rear++;

printf("\n");

int main() {

struct Node* root = NULL;

int choice, value;

// 1. Display Tree

// 2. Search

// 3. Insert new node(s) line by line (stop on alphabet)

// 4. Delete a Node

// 5. Find Minimum

// 6. Find Maximum

// 7. Pre-order Traversal

// 8. In-order Traversal

// 9. Post-order Traversal

// 10. Level-order Traversal

// 11. Exit

do {

printf("\n======================================\n");

printf("1. Display full tree (level by level)\n");

printf("2. Search for a value\n");

printf("3. Insert new node(s) (line by line; non-numeric input stops insertion)\n");

printf("4. Delete a node\n");

printf("5. Find minimum value\n");

printf("6. Find maximum value\n");

printf("7. Pre-order traversal\n");

printf("8. In-order traversal\n");

printf("9. Post-order traversal\n");

printf("10. Level-order traversal\n");

printf("11. Exit\n");

printf("Enter your choice: ");

if(scanf("%d", &choice) != 1) {

// In case of non-numeric choice.

printf("Invalid input. Exiting.\n");

break;

}
switch (choice) {

case 1:

printf("Displaying full tree:\n");

displayFullTree(root);

break;

case 2:

printf("Enter value to search: ");

scanf("%d", &value);

if (searchNode(root, value))

printf("Value %d found in the tree.\n", value);

else

printf("Value %d not found in the tree.\n", value);

break;

case 3: {

// Clear any lingering newline from previous input.

while(getchar() != '\n');

char input[20];

printf("Insert nodes line by line. Enter a non-numeric input to stop.\n");

while (1) {

printf("Enter value: ");

if (fgets(input, sizeof(input), stdin) == NULL)

break;

// Trim newline if present.

input[strcspn(input, "\n")] = 0;

// Attempt conversion; if it fails, break.

if (sscanf(input, "%d", &value) != 1)

break;

root = insert(root, value);

break;
}

case 4:

printf("Enter value to delete: ");

scanf("%d", &value);

root = deleteNode(root, value);

break;

case 5:

if (root)

printf("Minimum value in the tree: %d\n", findMin(root));

else

printf("Tree is empty.\n");

break;

case 6:

if (root)

printf("Maximum value in the tree: %d\n", findMax(root));

else

printf("Tree is empty.\n");

break;

case 7:

printf("Pre-order traversal: ");

preOrderTraversal(root);

break;

case 8:

printf("In-order traversal: ");

inOrderTraversal(root);

break;

case 9:

printf("Post-order traversal: ");

postOrderTraversal(root);

break;

case 10:
 printf("Level-order traversal: ");

levelOrderTraversal(root);

break;

case 11:

printf("Exiting the program.\n");

break;

default:

printf("Invalid choice! Please try again.\n");

} while (choice != 11);

return 0;

}
*/ Running Project