@LINKED REPRESENTATION
#include<stdio.h>
#include<malloc.h>
struct node{
int data;
struct node* left;
struct node* right;
};
struct node* createNode(int data){
struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
int main(){
/*
// Constructing the root node
struct node *p;
p = (struct node *) malloc(sizeof(struct node));
p->data = 2;
p->left = NULL;
p->right = NULL;
// Constructing the second node
struct node *p1;
p1 = (struct node *) malloc(sizeof(struct node));
p->data = 1;
p1->left = NULL;
p1->right = NULL;
// Constructing the third node
struct node *p2;
p2 = (struct node *) malloc(sizeof(struct node));
p->data = 4;
p2->left = NULL;
p2->right = NULL;
*/
// Constructing the root node - Using Function (Recommended)
struct node *p = createNode(2);
struct node *p1 = createNode(1);
struct node *p2 = createNode(4);
// Linking the root node with left and right children
p->left = p1;
p->right = p2;
return 0;
# Pre order traversal program
#include<stdio.h>
#include<malloc.h>
struct node{
int data;
struct node* left;
struct node* right;
};
struct node* createNode(int data){
struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
void preOrder(struct node* root){
if(root!=NULL){
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
int main(){
// Constructing the root node - Using Function (Recommended)
struct node *p = createNode(4);
struct node *p1 = createNode(1);
struct node *p2 = createNode(6);
struct node *p3 = createNode(5);
struct node *p4 = createNode(2);
// Finally The tree looks like this:
// 4
// /\
// 1 6
// / \
// 5 2
// Linking the root node with left and right children
p->left = p1;
p->right = p2;
p1->left = p3;
p1->right = p4;
preOrder(p);
return 0;
}
# POST ORDER TRAVERSAL
#include<stdio.h>
#include<malloc.h>
struct node{
int data;
struct node* left;
struct node* right;
};
struct node* createNode(int data){
struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
void preOrder(struct node* root){
if(root!=NULL){
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
void postOrder(struct node* root){
if(root!=NULL){
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->data);
}
}
int main(){
// Constructing the root node - Using Function (Recommended)
struct node *p = createNode(4);
struct node *p1 = createNode(1);
struct node *p2 = createNode(6);
struct node *p3 = createNode(5);
struct node *p4 = createNode(2);
// Finally The tree looks like this:
// 4
// /\
// 1 6
// / \
// 5 2
// Linking the root node with left and right children
p->left = p1;
p->right = p2;
p1->left = p3;
p1->right = p4;
preOrder(p);
printf("\n");
postOrder(p);
return 0;
@ IN-ORDER TRAVERSAL
#include<stdio.h>
#include<malloc.h>
struct node{
int data;
struct node* left;
struct node* right;
};
struct node* createNode(int data){
struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
void preOrder(struct node* root){
if(root!=NULL){
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
void postOrder(struct node* root){
if(root!=NULL){
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->data);
void inOrder(struct node* root){
if(root!=NULL){
inOrder(root->left);
printf("%d ", root->data);
inOrder(root->right);
}
int main(){
// Constructing the root node - Using Function (Recommended)
struct node *p = createNode(4);
struct node *p1 = createNode(1);
struct node *p2 = createNode(6);
struct node *p3 = createNode(5);
struct node *p4 = createNode(2);
// Finally The tree looks like this:
// 4
// /\
// 1 6
// / \
// 5 2
// Linking the root node with left and right children
p->left = p1;
p->right = p2;
p1->left = p3;
p1->right = p4;
// preOrder(p);
// printf("\n");
// postOrder(p);
// printf("\n");
inOrder(p);
return 0;
@ CHECK IT IS BINARTY TREE OR NOT
#include<stdio.h>
#include<malloc.h>
struct node{
int data;
struct node* left;
struct node* right;
};
struct node* createNode(int data){
struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
void preOrder(struct node* root){
if(root!=NULL){
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
void postOrder(struct node* root){
if(root!=NULL){
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->data);
void inOrder(struct node* root){
if(root!=NULL){
inOrder(root->left);
printf("%d ", root->data);
inOrder(root->right);
}
}
int isBST(struct node* root){
static struct node *prev = NULL;
if(root!=NULL);
if(!isBST(root->left)){
return 0;
if(prev!=NULL && root->data <= prev->data){
return 0;
prev = root;
return isBST(root->right);
else{
return 1;
int main(){
// Constructing the root node - Using Function (Recommended)
struct node *p = createNode(5);
struct node *p1 = createNode(3);
struct node *p2 = createNode(6);
struct node *p3 = createNode(1);
struct node *p4 = createNode(4);
// Finally The tree looks like this:
// 5
// /\
// 3 6
// / \
// 1 4
// Linking the root node with left and right children
p->left = p1;
p->right = p2;
p1->left = p3;
p1->right = p4;
// preOrder(p);
// printf("\n");
// postOrder(p);
// printf("\n");
inOrder(p);
printf("\n");
// printf("%d", isBST(p));
if(isBST(p)){
printf("This is a bst" );
else{
printf("This is not a bst");
return 0;
@SEARCHING IN BINARY TREE
#include<stdio.h>
#include<malloc.h>
struct node{
int data;
struct node* left;
struct node* right;
};
struct node* createNode(int data){
struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
void preOrder(struct node* root){
if(root!=NULL){
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
void postOrder(struct node* root){
if(root!=NULL){
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->data);
void inOrder(struct node* root){
if(root!=NULL){
inOrder(root->left);
printf("%d ", root->data);
inOrder(root->right);
int isBST(struct node* root){
static struct node *prev = NULL;
if(root!=NULL){
if(!isBST(root->left)){
return 0;
if(prev!=NULL && root->data <= prev->data){
return 0;
prev = root;
return isBST(root->right);
else{
return 1;
struct node * search(struct node* root, int key){
if(root==NULL){
return NULL;
if(key==root->data){
return root;
else if(key<root->data){
return search(root->left, key);
else{
return search(root->right, key);
int main(){
// Constructing the root node - Using Function (Recommended)
struct node *p = createNode(5);
struct node *p1 = createNode(3);
struct node *p2 = createNode(6);
struct node *p3 = createNode(1);
struct node *p4 = createNode(4);
// Finally The tree looks like this:
// 5
// /\
// 3 6
// / \
// 1 4
// Linking the root node with left and right children
p->left = p1;
p->right = p2;
p1->left = p3;
p1->right = p4;
struct node* n = search(p, 10);
if(n!=NULL){
printf("Found: %d", n->data);
else{
printf("Element not found");
return 0;
@ITERATIVE SEARCH IN BIARY TREE
#include<stdio.h>
#include<malloc.h>
struct node{
int data;
struct node* left;
struct node* right;
};
struct node* createNode(int data){
struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
void preOrder(struct node* root){
if(root!=NULL){
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
void postOrder(struct node* root){
if(root!=NULL){
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->data);
void inOrder(struct node* root){
if(root!=NULL){
inOrder(root->left);
printf("%d ", root->data);
inOrder(root->right);
}
int isBST(struct node* root){
static struct node *prev = NULL;
if(root!=NULL){
if(!isBST(root->left)){
return 0;
if(prev!=NULL && root->data <= prev->data){
return 0;
prev = root;
return isBST(root->right);
else{
return 1;
struct node * searchIter(struct node* root, int key){
while(root!=NULL){
if(key == root->data){
return root;
else if(key<root->data){
root = root->left;
else{
root = root->right;
return NULL;
int main(){
// Constructing the root node - Using Function (Recommended)
struct node *p = createNode(5);
struct node *p1 = createNode(3);
struct node *p2 = createNode(6);
struct node *p3 = createNode(1);
struct node *p4 = createNode(4);
// Finally The tree looks like this:
// 5
// /\
// 3 6
// / \
// 1 4
// Linking the root node with left and right children
p->left = p1;
p->right = p2;
p1->left = p3;
p1->right = p4;
struct node* n = searchIter(p, 6);
if(n!=NULL){
printf("Found: %d", n->data);
else{
printf("Element not found");
return 0;
@INSERTION IN BINARY TREE
#include<stdio.h>
#include<malloc.h>
struct node{
int data;
struct node* left;
struct node* right;
};
struct node* createNode(int data){
struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
void preOrder(struct node* root){
if(root!=NULL){
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
void postOrder(struct node* root){
if(root!=NULL){
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->data);
void inOrder(struct node* root){
if(root!=NULL){
inOrder(root->left);
printf("%d ", root->data);
inOrder(root->right);
int isBST(struct node* root){
static struct node *prev = NULL;
if(root!=NULL){
if(!isBST(root->left)){
return 0;
if(prev!=NULL && root->data <= prev->data){
return 0;
prev = root;
return isBST(root->right);
else{
return 1;
struct node * searchIter(struct node* root, int key){
while(root!=NULL){
if(key == root->data){
return root;
else if(key<root->data){
root = root->left;
else{
root = root->right;
}
return NULL;
void insert(struct node *root, int key){
struct node *prev = NULL;
while(root!=NULL){
prev = root;
if(key==root->data){
printf("Cannot insert %d, already in BST", key);
return;
else if(key<root->data){
root = root->left;
else{
root = root->right;
struct node* new = createNode(key);
if(key<prev->data){
prev->left = new;
else{
prev->right = new;
int main(){
// Constructing the root node - Using Function (Recommended)
struct node *p = createNode(5);
struct node *p1 = createNode(3);
struct node *p2 = createNode(6);
struct node *p3 = createNode(1);
struct node *p4 = createNode(4);
// Finally The tree looks like this:
// 5
// /\
// 3 6
// / \
// 1 4
// Linking the root node with left and right children
p->left = p1;
p->right = p2;
p1->left = p3;
p1->right = p4;
insert(p, 16);
printf("%d", p->right->right->data);
return 0;
@DELETION CODE
#include<stdio.h>
#include<malloc.h>
struct node{
int data;
struct node* left;
struct node* right;
};
struct node* createNode(int data){
struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
void preOrder(struct node* root){
if(root!=NULL){
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
void postOrder(struct node* root){
if(root!=NULL){
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->data);
void inOrder(struct node* root){
if(root!=NULL){
inOrder(root->left);
printf("%d ", root->data);
inOrder(root->right);
int isBST(struct node* root){
static struct node *prev = NULL;
if(root!=NULL){
if(!isBST(root->left)){
return 0;
if(prev!=NULL && root->data <= prev->data){
return 0;
prev = root;
return isBST(root->right);
else{
return 1;
struct node * searchIter(struct node* root, int key){
while(root!=NULL){
if(key == root->data){
return root;
else if(key<root->data){
root = root->left;
else{
root = root->right;
return NULL;
void insert(struct node *root, int key){
struct node *prev = NULL;
while(root!=NULL){
prev = root;
if(key==root->data){
printf("Cannot insert %d, already in BST", key);
return;
else if(key<root->data){
root = root->left;
else{
root = root->right;
struct node* new = createNode(key);
if(key<prev->data){
prev->left = new;
else{
prev->right = new;
struct node *inOrderPredecessor(struct node* root){
root = root->left;
while (root->right!=NULL)
root = root->right;
return root;
struct node *deleteNode(struct node *root, int value){
struct node* iPre;
if (root == NULL){
return NULL;
}
if (root->left==NULL&&root->right==NULL){
free(root);
return NULL;
//searching for the node to be deleted
if (value < root->data){
root-> left = deleteNode(root->left,value);
else if (value > root->data){
root-> right = deleteNode(root->right,value);
//deletion strategy when the node is found
else{
iPre = inOrderPredecessor(root);
root->data = iPre->data;
root->left = deleteNode(root->left, iPre->data);
return root;
int main(){
// Constructing the root node - Using Function (Recommended)
struct node *p = createNode(5);
struct node *p1 = createNode(3);
struct node *p2 = createNode(6);
struct node *p3 = createNode(1);
struct node *p4 = createNode(4);
// Finally The tree looks like this:
// 5
// /\
// 3 6
// / \
// 1 4
// Linking the root node with left and right children
p->left = p1;
p->right = p2;
p1->left = p3;
p1->right = p4;
inOrder(p);
printf("\n");
deleteNode(p, 3);
inOrder(p);
return 0;
@AVL TREE PROGRAM
#include <stdio.h>
#include <stdlib.h>
struct Node
int key;
struct Node *left;
struct Node *right;
int height;
};
int getHeight(struct Node *n){
if(n==NULL)
return 0;
return n->height;
struct Node *createNode(int key){
struct Node* node = (struct Node *) malloc(sizeof(struct Node));
node->key = key;
node->left = NULL;
node->right = NULL;
node->height = 1;
return node;
int max (int a, int b){
return (a>b)?a:b;
int getBalanceFactor(struct Node * n){
if(n==NULL){
return 0;
return getHeight(n->left) - getHeight(n->right);
struct Node* rightRotate(struct Node* y){
struct Node* x = y->left;
struct Node* T2 = x->right;
x->right = y;
y->left = T2;
x->height = max(getHeight(x->right), getHeight(x->left)) + 1;
y->height = max(getHeight(y->right), getHeight(y->left)) + 1;
return x;
struct Node* leftRotate(struct Node* x){
struct Node* y = x->right;
struct Node* T2 = y->left;
y->left = x;
x->right = T2;
x->height = max(getHeight(x->right), getHeight(x->left)) + 1;
y->height = max(getHeight(y->right), getHeight(y->left)) + 1;
return y;
struct Node *insert(struct Node* node, int key){
if (node == NULL)
return createNode(key);
if (key < node->key)
node->left = insert(node->left, key);
else if (key > node->key)
node->right = insert(node->right, key);
node->height = 1 + max(getHeight(node->left), getHeight(node->right));
int bf = getBalanceFactor(node);
// Left Left Case
if(bf>1 && key < node->left->key){
return rightRotate(node);
// Right Right Case
if(bf<-1 && key > node->right->key){
return leftRotate(node);
// Left Right Case
if(bf>1 && key > node->left->key){
node->left = leftRotate(node->left);
return rightRotate(node);
// Right Left Case
if(bf<-1 && key < node->right->key){
node->right = rightRotate(node->right);
return leftRotate(node);
return node;
}
void preOrder(struct Node *root)
if(root != NULL)
printf("%d ", root->key);
preOrder(root->left);
preOrder(root->right);
int main(){
struct Node * root = NULL;
root = insert(root, 1);
root = insert(root, 2);
root = insert(root, 4);
root = insert(root, 5);
root = insert(root, 6);
root = insert(root, 3);
preOrder(root);
return 0;
