Create a binary tree of 2 levels

#include <stdio.h>

#include <stdlib.h>

// Define the structure for a binary tree node

struct node{

int data;

struct node*left;

struct node*right;

};

// Function to create a new node

struct node* createNode(int data){

struct node * n; // Creating a node pointer

n = (struct node*) malloc(sizeof(struct node)); //Allocating memoru 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(){

struct node *p = createNode(1);

struct node *p1 = createNode(2);

struct node *p2 = createNode(3);

struct node *p3 = createNode(4);

struct node *p4 = createNode(5);

struct node *p5 = createNode(6);

//Linking the root with left and right children

p->left = p1;

p->right = p2;

p->left->left = p3;

p->left->right = p4;

p->right->left = p5;

p->right->right = p6;

printf("Binary Tree Structure:\n");

printf(" %d\n", p->data);

printf(" / \\\n");

printf(" %d %d\n", p->left->data, p->right->data);

printf(" / \\ / \\\n");

printf(" %d %d %d %d\n", p->left->left->data, p->left->right->data,

p->right->left->data, p->right->right->data);

return 0;

}
 Enqueue and Dequeue Operation

#include<stdio.h>

#include<stdlib.h>

struct queue

int size;

int f;

int r;

int* arr;

};

// For checking Empty

int isEmpty(struct queue *q){

if(q->r==q->f){

return 1;

return 0;

//For checking full

int isFull(struct queue *q){

if(q->r==q->size-1){

return 1;

return 0;

}
//Enqueue

void enqueue(struct queue *q, int val){

if(isFull(q)){

printf("This Queue is full\n");

else{

q->r++;

q->arr[q->r] = val;

printf("Enqued element: %d\n", val);

//Dequeue

int dequeue(struct queue *q){

int a = -1;

if(isEmpty(q)){

printf("This Queue is empty\n");

else{

q->f++;

a = q->arr[q->f];

printf("Dequeued element: %d\n",a);

return a;

//Calling function

int main(){

struct queue q;

q.size = 100;
 q.f = q.r = 0;

q.arr = (int*) malloc(q.size*sizeof(int));

// Enqueue few elements

enqueue(&q, 12);

enqueue(&q, 15);

enqueue(&q, 1);

dequeue(&q);

dequeue(&q);

dequeue(&q);

return 0;

}
 Circular Queue – Enqueue and Dequeue Operation

#include<stdio.h>

#include<stdlib.h>

struct circularQueue

int size;

int f;

int r;

int* arr;

};

// For checking Empty

int isEmpty(struct circularQueue *q){

if(q->r==q->f){

return 1;

return 0;

//For checking full

int isFull(struct circularQueue *q){

if((q->r+1) %q->size==q->f){

return 1;

return 0;

}
//Enqueue

void enqueue(struct circularQueue *q, int val){

if(isFull(q)){

printf("This Queue is full\n");

else{

q->r = ((q->r+1)%q->size);

q->arr[q->r] = val;

printf("Enqued element: %d\n", val);

//Dequeue

int dequeue(struct circularQueue *q){

int a = -1;

if(isEmpty(q)){

printf("This Queue is empty\n");

else{

q->f++;

a = q->arr[q->f];

printf("Dequeued element: %d\n",a);

return a;

//Calling function

int main(){

struct circularQueue q;

q.size = 100;
 q.f = q.r = 0;

q.arr = (int*) malloc(q.size*sizeof(int));

// Enqueue few elements

enqueue(&q, 12);

enqueue(&q, 15);

enqueue(&q, 1);

dequeue(&q);

dequeue(&q);

dequeue(&q);

return 0;

}
 Binary tree- Pre, Post and InOrder Traversal

#include <stdio.h>

#include <stdlib.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

struct node *p = createNode(1);

struct node *p1 = createNode(2);

struct node *p2 = createNode(3);

struct node *p3 = createNode(5);

struct node *p4 = createNode(4);

//Linking the root with left and right children

p->left = p1;

p->right = p2;

p1->left = p3;

p2->right = p4;

preOrder(p);
 printf("\n");

postOrder(p);

printf("\n");

inOrder(p);

return 0;

}
 Bubble Sort

#include <stdio.h>

void printArray(int *A, int n){

for(int i=0; i<n; i++)

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

printf("\n");

void bubbleSort(int *A, int n){

int temp;

for(int i=0; i<n-1; i++)// for number of pass

for(int j=0; j<n-1-i; j++)//for comparison of pass

if (A[j]>A[j+1]){

temp = A[j];

A[j] = A[j+1];

A[j+1] = temp;

int main(){
 int A[] = {7,8,65,45,4};

int n = 5;

printArray(A, n);

bubbleSort(A, n);

printArray(A, n);

}
 Insertion Sort

#include<stdio.h>

void printArray(int* A, int n){

for (int i = 0; i < n; i++)

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

printf("\n");

void insertionSort(int *A, int n){

int key, j;

// Loop for passes

for (int i = 1; i <= n-1; i++)

key = A[i];

j = i-1;

// Loop for each pass

while(j>=0 && A[j] > key){

A[j+1] = A[j];

j--;

A[j+1] = key;

int main(){

int A[] = {12, 54, 65, 7, 23, 9};

printArray(A, n);

insertionSort(A, n);

printArray(A, n);

return 0;

}
 Selection Sort

#include<stdio.h>

void printArray(int* A, int n){

for (int i = 0; i < n; i++)

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

printf("\n");

void selectionSort(int *A, int n){

int indexOfMin, temp;

printf("Running Selection sort...\n");

for (int i = 0; i < n-1; i++)

indexOfMin = i;

for (int j = i+1; j < n; j++)

if(A[j] < A[indexOfMin]){

indexOfMin = j;

// Swap A[i] and A[indexOfMin]

temp = A[i];

A[i] = A[indexOfMin];

A[indexOfMin] = temp;

}
int main(){

int A[] = {3, 5, 2, 13, 12};

int n = 5;

printArray(A, n);

selectionSort(A, n);

printArray(A, n);

return 0;

}
 Array

#include <stdio.h>

int main() {

int myArray[5];

myArray[0] = 10;

myArray[1] = 20;

myArray[2] = 30;

myArray[3] = 40;

myArray[4] = 50;

printf("Elements of the array : ");

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

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

return 0;

}
 Linear Search

#include <stdio.h>

int linearSearch(int arr[], int size, int element)

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

if (arr[i] == element) {

return i;

return -1;

int main()

int arr[] = {10, 20, 30, 40, 50};

int size = sizeof(arr) / sizeof(arr[0]);

int element = 30;

int result = linearSearch(arr, size, element);

if (result != -1) {

printf("Element %d found at index %d.\n", element, result);

} else {

printf("Element %d not found in the array.\n", element);

return 0;

}
 Binary Search

#include <stdio.h>

int binarySearch(int arr[], int size, int element) {

int low, mid, high;

low = 0;

high = size - 1;

while (low <= high) {

int mid = (low + high) / 2;

if (arr[mid] == element) {

return mid;

} else if (arr[mid] < element) {

low = mid + 1;

} else {

high = mid - 1;

return -1;

int main() {

int arr[] = {10, 20, 30, 40, 50};

int size = sizeof(arr) / sizeof(arr[0]);

int element = 30;

int result = binarySearch(arr, size, element);

printf("Element %d found at index: %d\n", element, result);

} else {

printf("Element %d not found in the array\n", element);

return 0;

}
 Push and Pop Operations

#include <stdio.h>

#include <stdlib.h>

struct stack{

int size;

int top;

int * arr;

};

//ptr stands for pointer

int isEmpty(struct stack* ptr){

if(ptr-> top==-1){

return 1;

else{

return 0;

int isFull(struct stack* ptr){

if(ptr->top == ptr->size - 1){

return 1;

}
 else{

return 0;

void push(struct stack* ptr, int val){

if (isFull(ptr)){

printf("Stack overflow! cannot push %d to the Stack\n", val);

else{

ptr->top++;

ptr->arr[ptr->top] = val;

int pop(struct stack* ptr){

if (isEmpty(ptr)){

printf("Stack Underflow! cannot pop the stack\n");

return -1;

else{

int val = ptr->arr[ptr->top];

ptr->top--;

return val;

}
int main()

struct stack * sp = (struct stack*) malloc(sizeof(struct stack));

sp->size = 10;

sp->top = -1;

sp->arr = (int * ) malloc(sp->size * sizeof(int));

printf("Stack has been created succesfully\n");

printf("Before pushing Full: %d\n", isFull(sp));

printf("Before pushing Empty: %d\n", isEmpty(sp));

push(sp, 56);

push(sp, 56);

push(sp, 56);

push(sp, 56);

push(sp, 56);

push(sp, 76);

push(sp, 56);

push(sp, 86);

push(sp, 56);

push(sp, 6); // pushed to 10 values

push(sp, 6); //stack overflow since the size of stack is 10

printf("After pushing Full: %d\n", isFull(sp));

printf("After pushing Empty: %d\n", isEmpty(sp));

printf("Poppped %d from the Stack\n", pop(sp));

return 0;

}
 Count leaf nodes in a binary tree

#include <stdio.h>

#include <stdlib.h>

// Define the structure for a binary tree node

struct node{

int data;

struct node*left;

struct node*right;

};

// Function to create a new node

struct node* createNode(int data){

struct node * n; // Creating a node pointer

n = (struct node*) malloc(sizeof(struct node)); //Allocating memoru 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

// funnction to count the leaf nodes in a binary tree

int countleafNodes (struct node* Z){

//If the tree is Empty

if(Z == NULL){

return 0;

}
 ///If the node is a leaf node

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

return 1;

//Recursively count leaf nodes in the left and right subtrees

return countleafNodes(Z->left) + countleafNodes(Z->right);

int main(){

//Constructing the root node - using function

struct node *Z = createNode(1);

struct node *Z1 = createNode(2);

struct node *Z2 = createNode(3);

struct node *Z3 = createNode(4);

struct node *Z4 = createNode(5);

struct node *Z5 = createNode(6);

struct node *Z6 = createNode(7);

//Linking the root with left and right children

Z->left = Z1;

Z->right = Z2;

Z->left->left = Z3;

Z->left->right = Z4;

Z->right->left = Z5;

Z->right->right = Z6;

int leafNodeCount = countleafNodes(Z);

return 0;