#include <stdio.h>int main(){   int LA[3] = {}, i;   printf("Array Before Insertion:\n");   for(i = 0; i < 3; i++)      printf("LA[%d] = %d \n", i, LA[i]);   printf("Inserting Elements.. \n");   printf("The array elements after insertion :\n"); // prints array values   for(i = 0; i < 3; i++) {      LA[i] = i + 2;      printf("LA[%d] = %d \n", i, LA[i]);   }   return 0;}

Output

Array Before Insertion:LA[0] = 0 LA[1] = 0 LA[2] = 0 Inserting Elements.. The array elements after insertion :LA[0] = 2 LA[1] = 3 LA[2] = 4

#include <iostream>using namespace std;int main(){   int LA[3] = {}, i;   cout << "Array Before Insertion:" << endl;   for(i = 0; i < 3; i++)      cout << "LA[" << i <<"] = " << LA[i] << endl;          //prints garbage values   cout << "Inserting elements.." <<endl;   cout << "Array After Insertion:" << endl; // prints array values   for(i = 0; i < 5; i++) {      LA[i] = i + 2;      cout << "LA[" << i <<"] = " << LA[i] << endl;   }   return 0;}

Output

Array Before Insertion:LA[0] = 0LA[1] = 0LA[2] = 0Inserting elements..Array After Insertion:LA[0] = 2LA[1] = 3LA[2] = 4LA[3] = 5LA[4] = 6

public class ArrayDemo {   public static void main(String []args) {      int LA[] = new int[3];      System.out.println("Array Before Insertion:");      for(int i = 0; i < 3; i++)         System.out.println("LA[" + i + "] = " + LA[i]); //prints empty array      System.out.println("Inserting Elements..");            // Printing Array after Insertion      System.out.println("Array After Insertion:");      for(int i = 0; i < 3; i++) {         LA[i] = i+3;         System.out.println("LA[" + i + "] = " + LA[i]);      }   }}

Output

Array Before Insertion:LA[0] = 0LA[1] = 0LA[2] = 0Inserting Elements..Array After Insertion:LA[0] = 3LA[1] = 4LA[2] = 5

# python program to insert element using insert operationdef insert(arr, element):arr.append(element)# Driver's codeif __name__ == '__main__':# declaring array and value to insertLA = [0, 0, 0]x = 0# array before inserting an elementprint("Array Before Insertion: ")for x in range(len(LA)):    print("LA", [x], " = " , LA[x])print("Inserting elements....")# array after Inserting elementfor x in range(len(LA)):    LA.append(x);    LA[x] = x+1;print("Array After Insertion: ")for x in range(len(LA)):    print("LA", [x], " = " , LA[x])

Output

Array Before Insertion: LA [0]  =  0LA [1]  =  0LA [2]  =  0Inserting elements....Array After Insertion: LA [0]  =  1LA [1]  =  2LA [2]  =  3LA [3]  =  0LA [4]  =  1LA [5]  =  2

#include <stdio.h>void main(){   int LA[] = {1,3,5};   int n = 3;   int i;   printf("The original array elements are :\n");   for(i = 0; i<n; i++)      printf("LA[%d] = %d \n", i, LA[i]);   for(i = 1; i<n; i++) {      LA[i] = LA[i+1];      n = n - 1;   }   printf("The array elements after deletion :\n");   for(i = 0; i<n; i++)      printf("LA[%d] = %d \n", i, LA[i]);}

Output

The original array elements are :LA[0] = 1LA[1] = 3LA[2] = 5The array elements after deletion :LA[0] = 1LA[1] = 5

#include <iostream>using namespace std;int main(){   int LA[] = {1,3,5};   int i, n = 3;   cout << "The original array elements are :"<<endl;   for(i = 0; i<n; i++) {      cout << "LA[" << i << "] = " << LA[i] << endl;   }   for(i = 1; i<n; i++) {      LA[i] = LA[i+1];      n = n - 1;   }   cout << "The array elements after deletion :"<<endl;   for(i = 0; i<n; i++) {      cout << "LA[" << i << "] = " << LA[i] <<endl;   }}

Output

The original array elements are :LA[0] = 1LA[1] = 3LA[2] = 5The array elements after deletion :LA[0] = 1LA[1] = 5

public class ArrayDemo {   public static void main(String []args) {      int LA[] = new int[3];      int n = LA.length;      System.out.println("Array Before Deletion:");      for(int i = 0; i < n; i++) {         LA[i] = i + 3;         System.out.println("LA[" + i + "] = " + LA[i]);      }      for(int i = 1; i<n-1; i++) {         LA[i] = LA[i+1];         n = n - 1;      }      System.out.println("Array After Deletion:");      for(int i = 0; i < n; i++) {         System.out.println("LA[" + i + "] = " + LA[i]);      }   }}

Output

Array Before Deletion:LA[0] = 3LA[1] = 4LA[2] = 5Array After Deletion:LA[0] = 3LA[1] = 5

#python program to delete the value using delete operationif __name__ == '__main__':# Declaring array and deleting valueLA = [0,0,0]n = len(LA)print("Array Before Deletion: ")for x in range(len(LA)):    LA.append(x)    LA[x] = x + 3    print("LA", [x], " = " , LA[x])# delete the value if exists # or show error it does not exist in the list for x in range(1, n-1):    LA[x] = LA[x+1]    n = n-1print("Array After Deletion: ")for x in range(n):    print("LA", [x], " = " , LA[x])

Output

Array Before Deletion: LA [0]  =  3LA [1]  =  4LA [2]  =  5Array After Deletion: LA [0]  =  3LA [1]  =  5

#include <stdio.h>void main(){   int LA[] = {1,3,5,7,8};   int item = 5, n = 5;   int i = 0, j = 0;   printf("The original array elements are :\n");   for(i = 0; i<n; i++) {      printf("LA[%d] = %d \n", i, LA[i]);   }   for(i = 0; i<n; i++) {      if( LA[i] == item ) {         printf("Found element %d at position %d\n", item, i+1);      }   }}

Output

The original array elements are :LA[0] = 1 LA[1] = 3 LA[2] = 5 LA[3] = 7 LA[4] = 8 Found element 5 at position 3

#include <iostream>using namespace std;int main(){   int LA[] = {1,3,5,7,8};   int item = 5, n = 5;   int i = 0;   cout << "The original array elements are : " <<endl;   for(i = 0; i<n; i++) {      cout << "LA[" << i << "] = " << LA[i] << endl;   }   for(i = 0; i<n; i++) {      if( LA[i] == item ) {         cout << "Found element " << item << " at position " << i+1 <<endl;      }   }   return 0;}

Output

The original array elements are : LA[0] = 1LA[1] = 3LA[2] = 5LA[3] = 7LA[4] = 8Found element 5 at position 3

public class ArrayDemo{   public static void main(String []args){      int LA[] = new int[5];      System.out.println("Array:");      for(int i = 0; i < 5; i++) {         LA[i] = i + 3;         System.out.println("LA[" + i + "] = " + LA[i]);      }      for(int i = 0; i < 5; i++) {         if(LA[i] == 6)            System.out.println("Element " + 6 + " is found at index " + i);      }   }}

Output

Array:LA[0] = 3LA[1] = 4LA[2] = 5LA[3] = 6LA[4] = 7Element 6 is found at index 3

#search operation using pythondef findElement(arr, n, value):for i in range(n):if (arr[i] == value):return i# If the key is not foundreturn -1# Driver's codeif __name__ == '__main__':LA = [1,3,5,7,8]print("Array element are: ")for x in range(len(LA)):    print("LA", [x], " = ", LA[x])value = 5n = len(LA)# element found using search operationindex = findElement(LA, n, value)if index != -1:print("Element", value, "Found at position = " + str(index + 1))else:print("Element not found")

Output

Array element are: LA [0]  =  1LA [1]  =  3LA [2]  =  5LA [3]  =  7LA [4]  =  8Element 5 Found at position = 3

#include <stdio.h>int main(){   int LA[] = {1,3,5,7,8};   int item = 10, k = 3, n = 5;   int i = 0, j = n;   printf("The original array elements are :\n");   for(i = 0; i<n; i++) {      printf("LA[%d] = %d \n", i, LA[i]);   }}

Output

The original array elements are :LA[0] = 1 LA[1] = 3 LA[2] = 5 LA[3] = 7 LA[4] = 8

#include <iostream>using namespace std;int main(){   int LA[] = {1,3,5,7,8};   int item = 10, k = 3, n = 5;   int i = 0, j = n;   cout << "The original array elements are:\n";   for(i = 0; i<n; i++)      cout << "LA[" << i << "] = " << LA[i] << endl;   return 0;}

Output

The original array elements are:LA[0] = 1LA[1] = 3LA[2] = 5LA[3] = 7LA[4] = 8

public class ArrayDemo {   public static void main(String []args) {      int LA[] = new int[5];      System.out.println("The array elements are: ");      for(int i = 0; i < 5; i++) {         LA[i] = i + 2;         System.out.println("LA[" + i + "] = " + LA[i]);      }   }}

Output

The array elements are: LA[0] = 2LA[1] = 3LA[2] = 4LA[3] = 5LA[4] = 6

# Python code to iterate over a array using pythonLA = [1, 3, 5, 7, 8]# length of the elementslength = len(LA)# Traversing the elements using For loop and range# same as 'for x in range(len(array))'print("Array elements are: ")for x in range(length):print("LA", [x], " = ", LA[x])

Output

Array elements are: LA [0]  =  1LA [1]  =  3LA [2]  =  5LA [3]  =  7LA [4]  =  8

#include <stdio.h>void main(){   int LA[] = {1,3,5,7,8};   int k = 3, n = 5, item = 10;   int i, j;   printf("The original array elements are :\n");   for(i = 0; i<n; i++) {      printf("LA[%d] = %d \n", i, LA[i]);   }   LA[k-1] = item;   printf("The array elements after updation :\n");   for(i = 0; i<n; i++) {      printf("LA[%d] = %d \n", i, LA[i]);   }}

Output

The original array elements are :LA[0] = 1 LA[1] = 3 LA[2] = 5 LA[3] = 7 LA[4] = 8 The array elements after updation :LA[0] = 1 LA[1] = 3 LA[2] = 10 LA[3] = 7 LA[4] = 8

#include <iostream>using namespace std;int main(){   int LA[] = {1,3,5,7,8};   int item = 10, k = 3, n = 5;   int i = 0, j = n;   cout << "The original array elements are :\n";   for(i = 0; i<n; i++)      cout << "LA[" << i << "] = " << LA[i] << endl;   LA[2] = item;   cout << "The array elements after updation are :\n";   for(i = 0; i<n; i++)      cout << "LA[" << i << "] = " << LA[i] << endl;   return 0;}

Output

The original array elements are :LA[0] = 1LA[1] = 3LA[2] = 5LA[3] = 7LA[4] = 8The array elements after updation are :LA[0] = 1LA[1] = 3LA[2] = 10LA[3] = 7LA[4] = 8

public class ArrayDemo {   public static void main(String []args) {      int LA[] = new int[5];      int item = 15;      System.out.println("The array elements are: ");      for(int i = 0; i < 5; i++) {         LA[i] = i + 2;         System.out.println("LA[" + i + "] = " + LA[i]);      }      LA[3] = item;      System.out.println("The array elements after updation are: ");      for(int i = 0; i < 5; i++)         System.out.println("LA[" + i + "] = " + LA[i]);   }}

Output

The array elements are: LA[0] = 2LA[1] = 3LA[2] = 4LA[3] = 5LA[4] = 6The array elements after updation are: LA[0] = 2LA[1] = 3LA[2] = 4LA[3] = 15LA[4] = 6

#update operation using python#Declaring array elementsLA = [1,3,5,7,8]#before updationprint("The original array elements are :");for x in range(len(LA)):    print("LA", [x], " = ", LA[x])#after updationLA[2] = 10print("The array elements after updation are: ")for x in range(len(LA)):    print("LA", [x], " = ", LA[x])

Output

The original array elements are :LA [0]  =  1LA [1]  =  3LA [2]  =  5LA [3]  =  7LA [4]  =  8The array elements after updation are: LA [0]  =  1LA [1]  =  3LA [2]  =  10LA [3]  =  7LA [4]  =  8

#include <stdio.h>int main(){   int LA[] = {1,3,5,7,8};   int n = 5;   int i;   printf("The original array elements are :\n");   for(i = 0; i<n; i++) {      printf("LA[%d] = %d \n", i, LA[i]);   }}

Output

The original array elements are :LA[0] = 1 LA[1] = 3 LA[2] = 5 LA[3] = 7 LA[4] = 8

#include <iostream>using namespace std;int main(){   int LA[] = {1,3,5,7,8};   int n = 5;   int i;   cout << "The original array elements are :\n";   for(i = 0; i<n; i++)      cout << "LA[" << i << "] = " << LA[i] << endl;   return 0;}

Output

The original array elements are :LA[0] = 1LA[1] = 3LA[2] = 5LA[3] = 7LA[4] = 8

public class ArrayDemo {   public static void main(String []args) {      int LA[] = new int[5];      System.out.println("The array elements are: ");      for(int i = 0; i < 5; i++) {         LA[i] = i + 2;         System.out.println("LA[" + i + "] = " + LA[i]);      }   }}

Output

The array elements are: LA[0] = 2LA[1] = 3LA[2] = 4LA[3] = 5LA[4] = 6

#Display operation using python#Display operation using python#Declaring array elementsLA = [2,3,4,5,6]#Displaying the arrayprint("The array elements are: ")for x in range(len(LA)):    print("LA", [x], " = " , LA[x])

Output

The array elements are: LA [0]  =  2LA [1]  =  3LA [2]  =  4LA [3]  =  5LA [4]  =  6

#include <stdio.h>#include <string.h>#include <stdlib.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   printf("\n[");      //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}//insertion at the beginningvoid insertatbegin(int data){      //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;      // point it to old first node   lk->next = head;      //point first to new first node   head = lk;}void main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(44);   insertatbegin(50);   printf("Linked List: ");      // print list   printList();}

Output

Linked List: [ 50  44  30  22  12 ]

#include <bits/stdc++.h>#include <string>using namespace std;struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   cout << "\n[";      //start from the beginning   while(p != NULL) {      cout << " " << p->data << " ";      p = p->next;   }   cout << "]";}//insertion at the beginningvoid insertatbegin(int data){      //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;      // point it to old first node   lk->next = head;      //point first to new first node   head = lk;}int main(){   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(44);   insertatbegin(50);   cout << "Linked List: ";      // print list   printList();}

Output

Linked List: [ 50  44  30  22  12 ]

public class Linked_List {   static class node {      int data;      node next;      node (int value) {         data = value;         next = null;      }   }   static node head;      // display the list   static void printList() {      node p = head;      System.out.print("\n[");         //start from the beginning      while(p != null) {         System.out.print(" " + p.data + " ");         p = p.next;      }      System.out.print("]");   }   //insertion at the beginning   static void insertatbegin(int data) {      //create a link      node lk = new node(data);;      // point it to old first node      lk.next = head;      //point first to new first node      head = lk;   }   public static void main(String args[]) {      int k=0;      insertatbegin(12);      insertatbegin(22);      insertatbegin(30);      insertatbegin(44);      insertatbegin(50);      insertatbegin(33);      System.out.println("Linked List: ");            // print list      printList();   }}

Output

Linked List: [33  50  44  30  22  12 ]

class Node:   def __init__(self, data=None):      self.data = data      self.next = Noneclass SLL:   def __init__(self):      self.head = None# Print the linked list   def listprint(self):      printval = self.head      print("Linked List: ")      while printval is not None:         print (printval.data)         printval = printval.next   def AddAtBeginning(self,newdata):      NewNode = Node(newdata)      # Update the new nodes next val to existing node      NewNode.next = self.head      self.head = NewNodel1 = SLL()l1.head = Node("731")e2 = Node("672")e3 = Node("63")l1.head.next = e2e2.next = e3l1.AddAtBeginning("122")l1.listprint()

Output

Linked List: 12273167263

#include <stdio.h>#include <string.h>#include <stdlib.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   printf("\n[");      //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;      //point first to new first node   head = lk;}void insertatend(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   struct node *linkedlist = head;   // point it to old first node   while(linkedlist->next != NULL)      linkedlist = linkedlist->next;   //point first to new first node   linkedlist->next = lk;}void main(){   int k=0;   insertatbegin(12);   insertatend(22);   insertatend(30);   insertatend(44);   insertatend(50);   printf("Linked List: ");      // print list   printList();}

Output

Linked List:[ 12 22 30 44 50 ]

#include <bits/stdc++.h>#include <string>using namespace std;struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   cout << "\n[";      //start from the beginning   while(p != NULL) {      cout << " " << p->data << " ";      p = p->next;   }   cout << "]";}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void insertatend(int data){      //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   struct node *linkedlist = head;   // point it to old first node   while(linkedlist->next != NULL)      linkedlist = linkedlist->next;   //point first to new first node   linkedlist->next = lk;}int main(){   insertatbegin(12);   insertatend(22);   insertatbegin(30);   insertatend(44);   insertatbegin(50);   cout << "Linked List: ";   // print list   printList();}

Output

Linked List: [ 50  30  12  22  44 ]

public class Linked_List {   static class node {      int data;      node next;      node (int value) {         data = value;         next = null;      }   }   static node head;   // display the list   static void printList() {      node p = head;      System.out.print("\n[");      //start from the beginning      while(p != null) {         System.out.print(" " + p.data + " ");         p = p.next;      }      System.out.print("]");   }   //insertion at the beginning   static void insertatbegin(int data) {      //create a link      node lk = new node(data);;      // point it to old first node      lk.next = head;      //point first to new first node      head = lk;   }   static void insertatend(int data) {         //create a link      node lk = new node(data);      node linkedlist = head;      // point it to old first node      while(linkedlist.next != null)         linkedlist = linkedlist.next;      //point first to new first node      linkedlist.next = lk;   }   public static void main(String args[]) {      int k=0;      insertatbegin(12);      insertatbegin(22);      insertatbegin(30);      insertatend(44);      insertatend(50);      insertatend(33);      System.out.println("Linked List: ");      // print list      printList();   }}

Output

Linked List: [ 30  22  12  44 50  33 ]

class Node:   def __init__(self, data=None):      self.data = data      self.next = Noneclass LL:   def __init__(self):      self.head = None   def listprint(self):      val = self.head      print("Linked List:")      while val is not None:         print(val.data)         val = val.nextl1 = LL()l1.head = Node("23")l2 = Node("12")l3 = Node("7")l4 = Node("14")l5 = Node("61")# Linking the first Node to second nodel1.head.next = l2# Linking the second Node to third nodel2.next = l3l3.next = l4l4.next = l5l1.listprint()

Output

Linked List:231271461

#include <stdio.h>#include <string.h>#include <stdlib.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   printf("\n[");      //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void insertafternode(struct node *list, int data){   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   lk->next = list->next;   list->next = lk;}void main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertafternode(head->next, 30);   printf("Linked List: ");   // print list   printList();}

Output

Linked List:[ 22 12 30 ]

#include <bits/stdc++.h>#include <string>using namespace std;struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   cout << "\n[";      //start from the beginning   while(p != NULL) {      cout << " " << p->data << " ";      p = p->next;   }   cout << "]";}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void insertafternode(struct node *list, int data){   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   lk->next = list->next;   list->next = lk;}int main(){   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertafternode(head->next,44);   insertafternode(head->next->next, 50);   cout << "Linked List: ";   // print list   printList();}

Output

Linked List: [ 30  22  44  50  12 ]

public class Linked_List {   static class node {      int data;      node next;      node (int value) {         data = value;         next = null;      }   }   static node head;   // display the list   static void printList() {      node p = head;      System.out.print("\n[");      //start from the beginning      while(p != null) {         System.out.print(" " + p.data + " ");         p = p.next;      }      System.out.print("]");   }   //insertion at the beginning   static void insertatbegin(int data) {      //create a link      node lk = new node(data);;      // point it to old first node      lk.next = head;      //point first to new first node      head = lk;   }   static void insertafternode(node list, int data) {      node lk = new node(data);      lk.next = list.next;      list.next = lk;   }   public static void main(String args[]) {      int k=0;      insertatbegin(12);      insertatbegin(22);      insertatbegin(30);      insertatbegin(44);      insertafternode(head.next, 50);      insertafternode(head.next.next, 33);      System.out.println("Linked List: ");      // print list      printList();   }}

Output

Linked List: [44  30  50  33  22  12 ]

class Node:   def __init__(self, data=None):      self.data = data      self.next = Noneclass SLL:   def __init__(self):      self.head = None# Print the linked list   def listprint(self):      printval = self.head      print("Linked List: ")      while printval is not None:         print (printval.data)         printval = printval.next   # Function to add node   def InsertAtPos(self,nodeatpos,newdata):      if nodeatpos is None:         print("The mentioned node is absent")         return      NewNode = Node(newdata)      NewNode.next = nodeatpos.next      nodeatpos.next = NewNodel1 = SLL()l1.head = Node("731")e2 = Node("672")e3 = Node("63")l1.head.next = e2e2.next = e3l1.InsertAtPos(l1.head.next, "122")l1.listprint()

Output

Linked List: 73167212263

#include <stdio.h>#include <string.h>#include <stdlib.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   printf("\n[");      //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void deleteatbegin(){   head = head->next;}int main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(40);   insertatbegin(55);   printf("Linked List: ");      // print list   printList();   deleteatbegin();   printf("\nLinked List after deletion: ");      // print list   printList();}

Output

Linked List: [ 55  40  30  22  12 ]Linked List after deletion: [ 40  30  22  12 ]

#include <bits/stdc++.h>#include <string>using namespace std;struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   cout << "\n[";      //start from the beginning   while(p != NULL) {      cout << " " << p->data << " ";      p = p->next;   }   cout << "]";}//insertion at the beginningvoid insertatbegin(int data){      //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void deleteatbegin(){   head = head->next;}int main(){   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(44);   insertatbegin(50);   cout << "Linked List: ";   // print list   printList();   deleteatbegin();   cout << "Linked List after deletion: ";   printList();}

Output

Linked List: [ 50  44  30  22  12 ]Linked List after deletion: [ 44  30  22  12 ]

public class Linked_List {   static class node {      int data;      node next;      node (int value) {         data = value;         next = null;      }   }   static node head;      // display the list   static void printList() {      node p = head;      System.out.print("\n[");            //start from the beginning      while(p != null) {         System.out.print(" " + p.data + " ");         p = p.next;      }      System.out.print("]");   }      //insertion at the beginning   static void insertatbegin(int data) {      //create a link      node lk = new node(data);;            // point it to old first node      lk.next = head;            //point first to new first node      head = lk;   }   static void deleteatbegin() {      head = head.next;   }   public static void main(String args[]) {      int k=0;      insertatbegin(12);      insertatbegin(22);      insertatbegin(30);      insertatbegin(44);      insertatbegin(50);      insertatbegin(33);      System.out.println("Linked List: ");            // print list      printList();      deleteatbegin();      System.out.println("\nLinked List after deletion: ");            // print list      printList();   }}

Output

Linked List: [ 33  50  44  30  22  12 ]Linked List after deletion: [50  44  30  22  12 ]

#python code for deletion at beginning using linked list.from typing import Optionalclass Node:    def __init__(self, data: int, next: Optional['Node'] = None):        self.data = data        self.next = nextclass LinkedList:    def __init__(self):        self.head = None     #display the list    def print_list(self):        p = self.head        print("\n[", end="")        while p:            print(f" {p.data} ", end="")            p = p.next        print("]")     #Insertion at the beginning    def insert_at_begin(self, data: int):        lk = Node(data)         #point it to old first node        lk.next = self.head        #point firt to new first node        self.head = lk    def delete_at_begin(self):        self.head = self.head.nextif __name__ == "__main__":    linked_list = LinkedList()    linked_list.insert_at_begin(12)    linked_list.insert_at_begin(22)    linked_list.insert_at_begin(30)    linked_list.insert_at_begin(44)    linked_list.insert_at_begin(50)    #print list    print("Linked List: ", end="")    linked_list.print_list()    linked_list.delete_at_begin()    print("Linked List after deletion: ", end="")    linked_list.print_list()

Output

Linked List: [ 50  44  30  22  12 ]Linked List after deletion: [ 44  30  22  12 ]

#include <stdio.h>#include <string.h>#include <stdlib.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   printf("\n[");      //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}//insertion at the beginningvoid insertatbegin(int data){      //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void deleteatend(){   struct node *linkedlist = head;   while (linkedlist->next->next != NULL)      linkedlist = linkedlist->next;   linkedlist->next = NULL;}void main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(40);   insertatbegin(55);   printf("Linked List: ");      // print list   printList();   deleteatend();   printf("\nLinked List after deletion: ");      // print list   printList();}

Output

Linked List: [ 55  40  30  22  12 ]Linked List after deletion: [ 55  40  30  22 ]

#include <bits/stdc++.h>#include <string>using namespace std;struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// Displaying the listvoid printList(){   struct node *p = head;   while(p != NULL) {      cout << " " << p->data << " ";      p = p->next;   }}// Insertion at the beginningvoid insertatbegin(int data){      //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;      // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void deleteatend(){   struct node *linkedlist = head;   while (linkedlist->next->next != NULL)      linkedlist = linkedlist->next;   linkedlist->next = NULL;}int main(){   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(44);   insertatbegin(50);   cout << "Linked List: ";   // print list   printList();   deleteatend();   cout << "\nLinked List after deletion: ";   printList();}

Output

Linked List:  50  44  30  22  12 Linked List after deletion:  50  44  30  22

public class Linked_List {   static class node {      int data;      node next;      node (int value) {         data = value;         next = null;      }   }   static node head;      // display the list   static void printList() {      node p = head;      System.out.print("\n[");            //start from the beginning      while(p != null) {         System.out.print(" " + p.data + " ");         p = p.next;      }      System.out.print("]");   }      //insertion at the beginning   static void insertatbegin(int data) {            //create a link      node lk = new node(data);;            // point it to old first node      lk.next = head;      //point first to new first node      head = lk;   }   static void deleteatend() {      node linkedlist = head;      while (linkedlist.next.next != null)         linkedlist = linkedlist.next;      linkedlist.next = null;   }   public static void main(String args[]) {      int k=0;      insertatbegin(12);      insertatbegin(22);      insertatbegin(30);      insertatbegin(44);      insertatbegin(50);      insertatbegin(33);      System.out.println("Linked List: ");      // print list      printList();      //deleteatbegin();      deleteatend();      System.out.println("\nLinked List after deletion: ");      // print list      printList();   }}

Output

Linked List: [ 33  50  44  30  22  12 ]Linked List after deletion: [ 33  50  44  30  22 ]

#python code for deletion at beginning using linked list.class Node:    def __init__(self, data=None):        self.data = data        self.next = Noneclass LinkedList:    def __init__(self):        self.head = None #Displaying the list    def printList(self):        p = self.head        print("\n[", end="")        while p != None:            print(" " + str(p.data) + " ", end="")            p = p.next        print("]") #Insertion at the beginning    def insertatbegin(self, data):        #create a link        lk = Node(data)        #point it to old first node        lk.next = self.head        #point first to new first node        self.head = lk    def deleteatend(self):        linkedlist = self.head        while linkedlist.next.next != None:            linkedlist = linkedlist.next        linkedlist.next = Noneif __name__ == "__main__":    linked_list = LinkedList()    linked_list.insertatbegin(12)    linked_list.insertatbegin(22)    linked_list.insertatbegin(30)    linked_list.insertatbegin(40)    linked_list.insertatbegin(55)    #print list    print("Linked List: ", end="")    linked_list.printList()    linked_list.deleteatend()    print("Linked List after deletion: ", end="")    linked_list.printList()

Output

Linked List: [ 55  40  30  22  12 ]Linked List after deletion: [ 55  40  30  22 ]

#include <stdio.h>#include <string.h>#include <stdlib.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   printf("\n[");   //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void deletenode(int key){   struct node *temp = head, *prev;   if (temp != NULL && temp->data == key) {      head = temp->next;      return;   }   // Find the key to be deleted   while (temp != NULL && temp->data != key) {      prev = temp;      temp = temp->next;   }   // If the key is not present   if (temp == NULL) return;   // Remove the node   prev->next = temp->next;}void main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(40);   insertatbegin(55);   printf("Linked List: ");   // print list   printList();   deletenode(30);   printf("\nLinked List after deletion: ");   // print list   printList();}

Output

Linked List: [ 55  40  30  22  12 ]Linked List after deletion: [ 55  40  22  12 ]

#include <bits/stdc++.h>#include <string>using namespace std;struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   cout << "\n[";   //start from the beginning   while(p != NULL) {      cout << " " << p->data << " ";      p = p->next;   }   cout << "]";}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void deletenode(int key){   struct node *temp = head, *prev;   if (temp != NULL && temp->data == key) {      head = temp->next;      return;   }   // Find the key to be deleted   while (temp != NULL && temp->data != key) {      prev = temp;      temp = temp->next;   }   // If the key is not present   if (temp == NULL) return;   // Remove the node   prev->next = temp->next;}int main(){   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(44);   insertatbegin(50);   cout << "Linked List: ";   // print list   printList();   deletenode(30);   cout << "Linked List after deletion: ";   printList();}

Output

Linked List: [ 50  44  30  22  12 ]Linked List after deletion: [ 50  44  22  12 ]

public class Linked_List {   static class node {      int data;      node next;      node (int value) {         data = value;         next = null;      }   }   static node head;      // display the list   static void printList() {      node p = head;      System.out.print("\n[");         //start from the beginning      while(p != null) {         System.out.print(" " + p.data + " ");         p = p.next;      }      System.out.print("]");   }      //insertion at the beginning   static void insertatbegin(int data) {         //create a link      node lk = new node(data);;      // point it to old first node      lk.next = head;      //point first to new first node      head = lk;   }   static void deletenode(int key) {      node temp = head;      node prev = null;      if (temp != null && temp.data == key) {         head = temp.next;         return;      }            // Find the key to be deleted      while (temp != null && temp.data != key) {         prev = temp;         temp = temp.next;      }            // If the key is not present      if (temp == null) return;            // Remove the node      prev.next = temp.next;   }   public static void main(String args[]) {      int k=0;      insertatbegin(12);      insertatbegin(22);      insertatbegin(30);      insertatbegin(44);      insertatbegin(50);      insertatbegin(33);      System.out.println("Linked List: ");      // print list      printList();      //deleteatbegin();      //deleteatend();      deletenode(12);      System.out.println("\nLinked List after deletion: ");      // print list      printList();   }}

Output

Linked List: [ 33  50  44  30  22  12 ]Linked List after deletion: [ 33  50  44  30  22 ]

#python code for deletion at given position using linked list.class Node:    def __init__(self, data=None):        self.data = data        self.next = Noneclass LinkedList:    def __init__(self):        self.head = None    # display the list    def printList(self):        p = self.head        print("\n[", end="")        #start from the beginning        while(p != None):            print(" ", p.data, " ", end="")            p = p.next        print("]")    #insertion at the beginning    def insertatbegin(self, data):        #create a link        lk = Node(data)        # point it to old first node        lk.next = self.head        #point first to new first node        self.head = lk    def deletenode(self, key):        temp = self.head        if (temp != None and temp.data == key):            self.head = temp.next            return        # Find the key to be deleted        while (temp != None and temp.data != key):            prev = temp            temp = temp.next        # If the key is not present        if (temp == None):            return        # Remove the node        prev.next = temp.nextllist = LinkedList()llist.insertatbegin(12)llist.insertatbegin(22)llist.insertatbegin(30)llist.insertatbegin(40)llist.insertatbegin(55)print("Original Linked List: ", end="")# print listllist.printList()llist.deletenode(30)print("\nLinked List after deletion: ", end="")# print listllist.printList()

Output

Linked List: [ 55  40  30  22  12 ]Linked List after deletion: [ 55  40  22  12 ]

#include <stdio.h>#include <string.h>#include <stdlib.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   printf("\n[");      //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void reverseList(struct node** head){   struct node *prev = NULL, *cur=*head, *tmp;   while(cur!= NULL) {      tmp = cur->next;      cur->next = prev;      prev = cur;      cur = tmp;   }   *head = prev;}void main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(40);   insertatbegin(55);   printf("Linked List: ");   // print list   printList();   reverseList(&head);   printf("\nReversed Linked List: ");   printList();}

Output

Linked List: [ 55  40  30  22  12 ]Reversed Linked List: [ 12  22  30  40  55 ]

#include <bits/stdc++.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   printf("\n[");   //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void reverseList(struct node** head){   struct node *prev = NULL, *cur=*head, *tmp;   while(cur!= NULL) {      tmp = cur->next;      cur->next = prev;      prev = cur;      cur = tmp;   }   *head = prev;}int main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(40);   insertatbegin(55);   printf("Linked List: ");   // print list   printList();   reverseList(&head);   printf("\nReversed Linked List: ");   printList();   return 0;}

Output

Linked List: [ 55  40  30  22  12 ]Reversed Linked List: [ 12  22  30  40  55 ]

public class Linked_List {   static Node head;   static class Node {      int data;      Node next;      Node (int value) {         data = value;         next = null;      }   }   // display the list   static void printList(Node node) {      System.out.print("\n[");      //start from the beginning      while(node != null) {         System.out.print(" " + node.data + " ");         node = node.next;      }      System.out.print("]");   }   static Node reverseList(Node head) {      Node prev = null;      Node cur = head;      Node temp = null;      while (cur != null) {         temp = cur.next;         cur.next = prev;         prev = cur;         cur = temp;      }      head = prev;      return head;   }   public static void main(String args[]) {      Linked_List list = new Linked_List();      list.head = new Node(33);      list.head.next = new Node(50);      list.head.next.next = new Node(44);      list.head.next.next.next = new Node(22);      list.head.next.next.next.next = new Node(12);      System.out.println("Linked List: ");            // print list      list.printList(head);      head = list.reverseList(head);      System.out.println("\nReversed linked list ");      list.printList(head);   }}

Output

Linked List: [ 33  50  44  22  12 ]Reversed linked list [ 12 22  44  50  33 ]

class Node:   def __init__(self, data=None):      self.data = data      self.next = Noneclass SLL:   def __init__(self):      self.head = None# Print the linked list   def listprint(self):      printval = self.head      print("Linked List: ")      while printval is not None:         print (printval.data)         printval = printval.next   def reverse(self):      prev = None      curr = self.head      while(curr is not None):         next = curr.next         curr.next = prev         prev = curr         curr = next      self.head = prevl1 = SLL()l1.head = Node("731")e2 = Node("672")e3 = Node("63")l1.head.next = e2e2.next = e3l1.listprint()l1.reverse()print("After reversing: ")l1.listprint()

Output

Linked List: 73167263After reversing: Linked List: 63672731

#include <stdio.h>#include <string.h>#include <stdlib.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   printf("\n[");   //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}int searchlist(int key){   struct node *temp = head;   while(temp != NULL) {      if (temp->data == key) {         return 1;      }      temp=temp->next;   }   return 0;}void main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(40);   insertatbegin(55);   printf("Linked List: ");   // print list   printList();   k = searchlist(30);   if (k == 1)      printf("\nElement is found");   else      printf("\nElement is not present in the list");}

Output

Linked List: [ 55  40  30  22  12 ]Element is found

#include <bits/stdc++.h>#include <string>using namespace std;struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   cout << "\n[";   //start from the beginning   while(p != NULL) {      cout << " " << p->data << " ";      p = p->next;   }   cout << "]";}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}int searchlist(int key){   struct node *temp = head;   while(temp != NULL) {      if (temp->data == key) {         return 1;      }      temp=temp->next;   }   return 0;}int main(){   int k = 0;   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(44);   insertatbegin(50);   cout << "Linked List: ";   // print list   printList();   k = searchlist(16);   if (k == 1)      cout << "\nElement is found";   else      cout << "\nElement is not present in the list";}

Output

Linked List: [ 50  44  30  22  12 ]Element is not present in the list

public class Linked_List {   static class node {      int data;      node next;      node (int value) {         data = value;         next = null;      }   }   static node head;   // display the list   static void printList() {      node p = head;      System.out.print("\n[");      //start from the beginning      while(p != null) {         System.out.print(" " + p.data + " ");         p = p.next;      }      System.out.print("]");   }   //insertion at the beginning   static void insertatbegin(int data) {      //create a link      node lk = new node(data);;      // point it to old first node      lk.next = head;            //point first to new first node      head = lk;   }   static int searchlist(int key) {      node temp = head;      while(temp != null) {         if (temp.data == key) {            return 1;         }         temp=temp.next;      }      return 0;   }   public static void main(String args[]) {      int k=0;      insertatbegin(12);      insertatbegin(22);      insertatbegin(30);      insertatbegin(44);      insertatbegin(50);      insertatbegin(33);      System.out.println("Linked List: ");      // print list      printList();      k = searchlist(44);      if (k == 1)         System.out.println("\nElement is found");      else         System.out.println("\nElement is not present in the list");   }}

Output

Linked List: [33  50  44  30  22  12 ]Element is found

class Node:   def __init__(self, data=None):      self.data = data      self.next = Noneclass SLL:   def __init__(self):      self.head = None   def search(self, x):      count = 0            # Initialize current to head      current = self.head      # loop till current not equal to None      while current != None:         if current.data == x:            print("data found")            count = count + 1         current = current.next      if count == 0:         print("Data Not found")l1 = SLL()l1.head = Node("731")e2 = Node("672")e3 = Node("63")l1.head.next = e2e2.next = e3l1.search("63")

Output

data found

#include <stdio.h>#include <string.h>#include <stdlib.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;   // display the list   void printList(){   struct node *p = head;   printf("\n[");   //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}   //insertion at the beginning   void insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   printf("Linked List: ");   // print list   printList();}

Output

Linked List: [ 30  22  12 ]

#include <bits/stdc++.h>#include <string>using namespace std;struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// Displaying the listvoid printList(){   struct node *p = head;   while(p != NULL) {      cout << " " << p->data << " ";      p = p->next;   }}// Insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}int main(){   insertatbegin(12);   insertatbegin(22);   insertatbegin(30);   insertatbegin(44);   insertatbegin(50);   cout << "Linked List: ";   // print list   printList();}

Output

Linked List:  50  44  30  22  12

public class Linked_List {   static class node {      int data;      node next;      node (int value) {         data = value;         next = null;      }   }   static node head;   // display the list   static void printList() {      node p = head;      System.out.print("\n[");            //start from the beginning      while(p != null) {         System.out.print(" " + p.data + " ");         p = p.next;      }      System.out.print("]");   }      //insertion at the beginning   static void insertatbegin(int data) {      //create a link      node lk = new node(data);;      // point it to old first node      lk.next = head;      //point first to new first node      head = lk;   }   public static void main(String args[]) {      int k=0;      insertatbegin(12);      insertatbegin(22);      insertatbegin(30);      insertatbegin(44);      insertatbegin(50);      insertatbegin(33);      System.out.println("Linked List: ");      // print list      printList();   }}

Output

Linked List: [ 33  50  44  30  22  12 ]

class Node:   def __init__(self, data=None):      self.data = data      self.next = Noneclass SLL:   def __init__(self):      self.head = None# Print the linked list   def listprint(self):      printval = self.head      print("Linked List: ")      while printval is not None:         print (printval.data)         printval = printval.nextl1 = SLL()l1.head = Node("731")e2 = Node("672")e3 = Node("63")l1.head.next = e2e2.next = e3l1.listprint()

Output

Linked List: 73167263

#include <stdio.h>#include <string.h>#include <stdlib.h>struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   printf("\n[");   //start from the beginning   while(p != NULL) {      printf(" %d ",p->data);      p = p->next;   }   printf("]");}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void insertatend(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   struct node *linkedlist = head;   // point it to old first node   while(linkedlist->next != NULL)      linkedlist = linkedlist->next;   //point first to new first node   linkedlist->next = lk;}void insertafternode(struct node *list, int data){   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   lk->next = list->next;   list->next = lk;}void deleteatbegin(){   head = head->next;}void deleteatend(){   struct node *linkedlist = head;   while (linkedlist->next->next != NULL)      linkedlist = linkedlist->next;   linkedlist->next = NULL;}void deletenode(int key){   struct node *temp = head, *prev;   if (temp != NULL && temp->data == key) {      head = temp->next;      return;   }   // Find the key to be deleted   while (temp != NULL && temp->data != key) {      prev = temp;      temp = temp->next;   }   // If the key is not present   if (temp == NULL) return;   // Remove the node   prev->next = temp->next;}int searchlist(int key){   struct node *temp = head;   while(temp != NULL) {      if (temp->data == key) {         return 1;      }      temp=temp->next;   }   return 0;}void main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertatend(30);   insertatend(44);   insertatbegin(50);   insertafternode(head->next->next, 33);   printf("Linked List: ");   // print list   printList();   deleteatbegin();   deleteatend();   deletenode(12);   printf("\nLinked List after deletion: ");   // print list   printList();   insertatbegin(4);   insertatbegin(16);   printf("\nUpdated Linked List: ");   printList();   k = searchlist(16);   if (k == 1)      printf("\nElement is found");   else      printf("\nElement is not present in the list");}

Output

Linked List: [ 50  22  12  33  30  44 ]Linked List after deletion: [ 22  33  30 ]Updated Linked List: [ 16  4  22  33  30 ]Element is found

#include <bits/stdc++.h>#include <string>using namespace std;struct node {   int data;   struct node *next;};struct node *head = NULL;struct node *current = NULL;// display the listvoid printList(){   struct node *p = head;   cout << "\n[";   //start from the beginning   while(p != NULL) {      cout << " " << p->data << " ";      p = p->next;   }   cout << "]";}//insertion at the beginningvoid insertatbegin(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   // point it to old first node   lk->next = head;   //point first to new first node   head = lk;}void insertatend(int data){   //create a link   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   struct node *linkedlist = head;   // point it to old first node   while(linkedlist->next != NULL)      linkedlist = linkedlist->next;   //point first to new first node   linkedlist->next = lk;}void insertafternode(struct node *list, int data){   struct node *lk = (struct node*) malloc(sizeof(struct node));   lk->data = data;   lk->next = list->next;   list->next = lk;}void deleteatbegin(){   head = head->next;}void deleteatend(){   struct node *linkedlist = head;   while (linkedlist->next->next != NULL)      linkedlist = linkedlist->next;   linkedlist->next = NULL;}void deletenode(int key){   struct node *temp = head, *prev;   if (temp != NULL && temp->data == key) {      head = temp->next;      return;   }   // Find the key to be deleted   while (temp != NULL && temp->data != key) {      prev = temp;      temp = temp->next;   }   // If the key is not present   if (temp == NULL) return;   // Remove the node   prev->next = temp->next;}int searchlist(int key){   struct node *temp = head;   while(temp != NULL) {      if (temp->data == key) {         temp=temp->next;         return 1;      } else         return 0;   }}int main(){   int k=0;   insertatbegin(12);   insertatbegin(22);   insertatend(30);   insertatend(44);   insertatbegin(50);   insertafternode(head->next->next, 33);   cout << "Linked List: ";   // print list   printList();   deleteatbegin();   deleteatend();   deletenode(12);   cout << "\nLinked List after deletion: ";   // print list   printList();   insertatbegin(4);   insertatbegin(16);   cout << "\nUpdated Linked List: ";   printList();   k = searchlist(16);   if (k == 1)      cout << "\nElement is found";   else      cout << "\nElement is not present in the list";   return 0;}

Output

Linked List: [ 50  22  12  33  30  44 ]Linked List after deletion: [ 22  33  30 ]Updated Linked List: [ 16  4  22  33  30 ]Element is found

public class Linked_List {   static class node {      int data;      node next;      node (int value) {         data = value;         next = null;      }   }   static node head;   // display the list   static void printList() {      node p = head;      System.out.print("\n[");      //start from the beginning      while(p != null) {         System.out.print(" " + p.data + " ");         p = p.next;      }      System.out.print("]");   }   //insertion at the beginning   static void insertatbegin(int data) {      //create a link      node lk = new node(data);;      // point it to old first node      lk.next = head;      //point first to new first node      head = lk;   }   static void insertatend(int data) {      //create a link      node lk = new node(data);      node linkedlist = head;      // point it to old first node      while(linkedlist.next != null)         linkedlist = linkedlist.next;      //point first to new first node      linkedlist.next = lk;   }   static void insertafternode(node list, int data) {      node lk = new node(data);      lk.next = list.next;      list.next = lk;   }   static void deleteatbegin() {      head = head.next;   }   static void deleteatend() {      node linkedlist = head;      while (linkedlist.next.next != null)         linkedlist = linkedlist.next;      linkedlist.next = null;   }   static void deletenode(int key) {      node temp = head;      node prev = null;      if (temp != null && temp.data == key) {         head = temp.next;         return;      }      // Find the key to be deleted      while (temp != null && temp.data != key) {         prev = temp;         temp = temp.next;      }            // If the key is not present      if (temp == null) return;            // Remove the node      prev.next = temp.next;   }   static int searchlist(int key) {      node temp = head;      while(temp != null) {         if (temp.data == key) {            temp=temp.next;            return 1;         }      }      return 0;   }   public static void main(String args[]) {      int k=0;      insertatbegin(12);      insertatbegin(22);      insertatend(30);      insertatend(44);      insertatbegin(50);      insertafternode(head.next.next, 33);      System.out.println("Linked List: ");            // print list      printList();      deleteatbegin();      deleteatend();      deletenode(12);      System.out.println("\nLinked List after deletion: ");      // print list      printList();      insertatbegin(4);      insertatbegin(16);      System.out.println("\nUpdated Linked List: ");      printList();      k = searchlist(16);      if (k == 1)         System.out.println("\nElement is found");      else         System.out.println("\nElement is not present in the list");   }}

Output

Linked List:[ 50 22 12 33 30 44 ]Linked List after deletion:[ 22 33 30 ]Updated Linked List:[ 16 4 22 33 30 ]Element is found

class LLNode:   def __init__(self, data=None):      self.data = data      self.next = Noneclass LL:   def __init__(self):      self.head = None   def listprint(self):      printval = self.head      while printval is not None:         print(printval.data)         printval = printval.next   def AddAtBeginning(self,newdata):      NewNode = LLNode(newdata)      # Update the new nodes next val to existing node      NewNode.next = self.head      self.head = NewNode   # Function to add node at a position   def InsertAtPos(self,nodeatpos,newdata):      if nodeatpos is None:         print("The mentioned node is absent")         return      NewNode = LLNode(newdata)      NewNode.next = nodeatpos.next      nodeatpos.next = NewNode   def reverse(self):      prev = None      curr = self.head      while(curr is not None):         next = curr.next         curr.next = prev         prev = curr         curr = next      self.head = prev   def search(self, x):      count = 0      # Initialize current to head      current = self.head      # loop till current not equal to None      while current != None:         if current.data == x:            print("data found")            count = count + 1         current = current.next      if count == 0:         print("Data Not found")l1 = LL()l1.head = LLNode("23")l2 = LLNode("12")l3 = LLNode("7")l4 = LLNode("14")l5 = LLNode("61")# Linking the first Node to second nodel1.head.next = l2# Linking the second Node to third nodel2.next = l3l3.next = l4l4.next = l5print("Original Linked List: ")l1.listprint()l1.AddAtBeginning("45")l1.InsertAtPos(l1.head.next.next, "4")print("Updated Linked List:")l1.listprint()l1.reverse()print("Reversed Linked List:")l1.listprint()l1.search("7")

Output

Original Linked List: 231271461Updated Linked List:452312471461Reversed Linked List:611474122345data found

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>struct node {   int data;   int key;   struct node *next;   struct node *prev;};//this link always point to first Linkstruct node *head = NULL;//this link always point to last Linkstruct node *last = NULL;struct node *current = NULL;//is list emptybool isEmpty(){   return head == NULL;}//display the doubly linked listvoid printList(){   struct node *ptr = head;   while(ptr != NULL) {      printf("(%d,%d) ",ptr->key,ptr->data);      ptr = ptr->next;   }}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if(isEmpty()) {      //make it the last link      last = link;   } else {      //update first prev link      head->prev = link;   }   //point it to old first link   link->next = head;   //point first to new first link   head = link;}void main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("\nDoubly Linked List: ");   printList();}

Output

Doubly Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) (1,10)

#include <iostream>#include <cstring>#include <cstdlib>#include <cstdbool>struct node {   int data;   int key;   struct node *next;   struct node *prev;};//this link always point to first Linkstruct node *head = NULL;//this link always point to last Linkstruct node *last = NULL;struct node *current = NULL;//is list emptybool isEmpty(){   return head == NULL;}//display the doubly linked listvoid printList(){   struct node *ptr = head;   while(ptr != NULL) {      printf("(%d,%d) ",ptr->key,ptr->data);      ptr = ptr->next;   }}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if(isEmpty()) {      //make it the last link      last = link;   } else {      //update first prev link      head->prev = link;   }   //point it to old first link   link->next = head;   //point first to new first link   head = link;}int main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("\nDoubly Linked List: ");   printList();   return 0;}

Output

Doubly Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) (1,10)

//Java code for doubly linked listimport java.util.*;class Node {    public int data;    public int key;    public Node next;    public Node prev;    public Node(int data, int key) {        this.data = data;        this.key = key;        this.next = null;        this.prev = null;    }}public class Main {    //this link always point to first Link    static Node head = null;    //this link always point to last Link    static Node last = null;    static Node current = null;    // is list empty    public static boolean is_empty() {        return head == null;    }    //display the doubly linked list    public static void print_list() {        Node ptr = head;        while (ptr != null) {            System.out.println("(" + ptr.key + "," + ptr.data + ")");            ptr = ptr.next;        }    }    //insert link at the first location    public static void insert_first(int key, int data) {          //create a link        Node link = new Node(data, key);        if (is_empty()) {            //make it the last link            last = link;        } else {            //update first prev link            head.prev = link;        }        //point it to old first link        link.next = head;         //point first to new first link        head = link;    }    public static void main(String[] args) {        insert_first(1, 10);        insert_first(2, 20);        insert_first(3, 30);        insert_first(4, 1);        insert_first(5, 40);        insert_first(6, 56);        System.out.println("\nDoubly Linked List: ");        print_list();    }}

Output

Doubly Linked List: (6,56)(5,40)(4,1)(3,30)(2,20)(1,10)

#Python code for doubly linked listclass Node:    def __init__(self, data=None, key=None):        self.data = data        self.key = key        self.next = None        self.prev = None#this link always point to first Linkhead = None#this link always point to last Linklast = Nonecurrent = None#is list emptydef is_empty():    return head == None#display the doubly linked listdef print_list():    ptr = head    while ptr != None:        print(f"({ptr.key},{ptr.data})")        ptr = ptr.next#insert link at the first locationdef insert_first(key, data):    global head, last    #create a link    link = Node(data, key)    if is_empty():        #make it the last link        last = link    else:        #update first prev link        head.prev = link    #point it to old first link    link.next = head    #point first to new first link    head = linkinsert_first(1,10)insert_first(2,20)insert_first(3,30)insert_first(4,1)insert_first(5,40)insert_first(6,56)print("\nDoubly Linked List: ")print_list()

Output

Doubly Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) (1,10)

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>struct node {   int data;   int key;   struct node *next;   struct node *prev;};//this link always point to first Linkstruct node *head = NULL;//this link always point to last Linkstruct node *last = NULL;struct node *current = NULL;//is list emptybool isEmpty(){   return head == NULL;}//display the doubly linked listvoid printList(){   struct node *ptr = head;   while(ptr != NULL) {      printf("(%d,%d) ",ptr->key,ptr->data);      ptr = ptr->next;   }}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if(isEmpty()) {      //make it the last link      last = link;   } else {      //update first prev link      head->prev = link;   }   //point it to old first link   link->next = head;   //point first to new first link   head = link;}//delete first itemstruct node* deleteFirst(){   //save reference to first link   struct node *tempLink = head;   //if only one link   if(head->next == NULL) {      last = NULL;   } else {      head->next->prev = NULL;   }   head = head->next;   //return the deleted link   return tempLink;}void main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("\nDoubly Linked List: ");   printList();   printf("\nList after deleting first record: ");   deleteFirst();   printList();}

Output

Doubly Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) (1,10) List after deleting first record: (5,40) (4,1) (3,30) (2,20) (1,10)

#include <iostream>#include <cstring>#include <cstdlib>#include <cstdbool>struct node {   int data;   int key;   struct node *next;   struct node *prev;};//this link always point to first Linkstruct node *head = NULL;//this link always point to last Linkstruct node *last = NULL;struct node *current = NULL;//is list emptybool isEmpty(){   return head == NULL;}//display the doubly linked listvoid printList(){   struct node *ptr = head;   while(ptr != NULL) {      printf("(%d,%d) ",ptr->key,ptr->data);      ptr = ptr->next;   }}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if(isEmpty()) {      //make it the last link      last = link;   } else {      //update first prev link      head->prev = link;   }   //point it to old first link   link->next = head;   //point first to new first link   head = link;}//delete first itemstruct node* deleteFirst(){   //save reference to first link   struct node *tempLink = head;   //if only one link   if(head->next == NULL) {      last = NULL;   } else {      head->next->prev = NULL;   }   head = head->next;   //return the deleted link   return tempLink;}int main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("\nDoubly Linked List: ");   printList();   printf("\nList after deleting first record: ");   deleteFirst();   printList();   return 0;}

Output

Doubly Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) (1,10) List after deleting first record: (5,40) (4,1) (3,30) (2,20) (1,10)

//Java code for doubly linked listimport java.util.*;class Node {    public int data;    public int key;    public Node next;    public Node prev;    public Node(int data, int key) {        this.data = data;        this.key = key;        this.next = null;        this.prev = null;    }}public class Main {    //this link always point to first Link    public static Node head = null;    //this link always point to last Link    public static Node last = null;    //this link always point to current Link    public static Node current = null;    //is list empty    public static boolean isEmpty() {        return head == null;    }    //display the doubly linked list    public static void printList() {        Node ptr = head;        while (ptr != null) {            System.out.print("(" + ptr.key + "," + ptr.data + ") ");            ptr = ptr.next;        }    }    //insert link at the first location    public static void insertFirst(int key, int data) {        //create a link        Node link = new Node(data, key);        if (isEmpty()) {            //make it the last link            last = link;        } else {            //update first prev link            head.prev = link;        }        //point it to old first link        link.next = head;        head = link;    }    //delete the first item    public static Node deleteFirst() {        //save reference to first link        Node tempLink = head;        //if only one link        if (head.next == null) {            last = null;        } else {            head.next.prev = null;        }        head = head.next;        //return the deleted link        return tempLink;    }    public static void main(String[] args) {        insertFirst(1, 10);        insertFirst(2, 20);        insertFirst(3, 30);        insertFirst(4, 1);        insertFirst(5, 40);        insertFirst(6, 56);        System.out.print("\nDoubly Linked List: ");        printList();        System.out.print("\nList after deleting first record: ");        deleteFirst();        printList();    }}

Output

Doubly Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) (1,10) List after deleting first record: (5,40) (4,1) (3,30) (2,20) (1,10)

#Python code for doubly linked listclass Node:    def __init__(self, data=None, key=None):        self.data = data        self.key = key        self.next = None        self.prev = None#this link always point to first Linkhead = None#this link always point to last Linklast = Nonecurrent = None#is list emptydef isEmpty():    return head == None#display the doubly linked listdef printList():    ptr = head    while ptr != None:        print(f"({ptr.key},{ptr.data}) ", end="")        ptr = ptr.next#insert link at the first locationdef insertFirst(key, data):    #create a link    global head, last    link = Node(data, key)    if isEmpty():        #make it the last link        last = link    else:        #update first prev link        head.prev = link    #point it to old first link    link.next = head    head = link#delete first itemdef deleteFirst():     #save reference to first link    global head, last    tempLink = head    #if only one link    if head.next == None:        last = None    else:        head.next.prev = None    head = head.next    #return the deleted link    return tempLinkinsertFirst(1,10)insertFirst(2,20)insertFirst(3,30)insertFirst(4,1)insertFirst(5,40)insertFirst(6,56)print("\nDoubly Linked List: ", end="")printList()print("\nList after deleting first record: ")deleteFirst()printList()

Output

Doubly Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) (1,10) List after deleting first record: (5,40) (4,1) (3,30) (2,20) (1,10)

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>struct node {   int data;   int key;   struct node *next;   struct node *prev;};//this link always point to first Linkstruct node *head = NULL;//this link always point to last Linkstruct node *last = NULL;struct node *current = NULL;//is list emptybool isEmpty(){   return head == NULL;}//display the doubly linked listvoid printList(){   struct node *ptr = head;   while(ptr != NULL) {      printf("(%d,%d) ",ptr->key,ptr->data);      ptr = ptr->next;   }}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if(isEmpty()) {      //make it the last link      last = link;   } else {      //update first prev link      head->prev = link;   }   //point it to old first link   link->next = head;   //point first to new first link   head = link;}//insert link at the last locationvoid insertLast(int key, int data){      //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if(isEmpty()) {      //make it the last link      last = link;   } else {      //make link a new last link      last->next = link;      //mark old last node as prev of new link      link->prev = last;   }   //point last to new last node   last = link;}void main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertLast(5,40);   insertLast(6,56);   printf("\nDoubly Linked List: ");   printList();}

Output

Doubly Linked List: (4,1) (3,30) (2,20) (1,10) (5,40) (6,56)

#include <iostream>#include <cstring>#include <cstdlib>#include <cstdbool>struct node {   int data;   int key;   struct node *next;   struct node *prev;};//this link always point to first Linkstruct node *head = NULL;//this link always point to last Linkstruct node *last = NULL;struct node *current = NULL;//is list emptybool isEmpty(){   return head == NULL;}//display the doubly linked listvoid printList(){   struct node *ptr = head;   while(ptr != NULL) {      printf("(%d,%d) ",ptr->key,ptr->data);      ptr = ptr->next;   }}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if(isEmpty()) {      //make it the last link      last = link;   } else {      //update first prev link      head->prev = link;   }   //point it to old first link   link->next = head;   //point first to new first link   head = link;}//insert link at the last locationvoid insertLast(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if(isEmpty()) {      //make it the last link      last = link;   } else {      //make link a new last link      last->next = link;      //mark old last node as prev of new link      link->prev = last;   }   //point last to new last node   last = link;}int main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertLast(5,40);   insertLast(6,56);   printf("\nDoubly Linked List: ");   printList();   return 0;}

Output

Doubly Linked List: (4,1) (3,30) (2,20) (1,10) (5,40) (6,56)

import java.util.*;class Node {    public int data;    public int key;    public Node next;    public Node prev;    public Node(int data, int key) {        this.data = data;        this.key = key;        this.next = null;        this.prev = null;    }}public class Main {    static Node head = null;    static Node last = null;    static Node current = null;    public static boolean isEmpty() {        return head == null;    }     public static void printList() {        Node ptr = head;        while (ptr != null) {            System.out.print("(" + ptr.key + "," + ptr.data + ") ");            ptr = ptr.next;        }    }    public static void insertFirst(int key, int data) {        Node link = new Node(data, key);        if (isEmpty()) {            last = link;        } else {            head.prev = link;        }        link.next = head;        head = link;    }    public static void insertLast(int key, int data) {        Node link = new Node(data, key);        if (isEmpty()) {            last = link;        } else {            last.next = link;            link.prev = last;        }        last = link;    }        public static void main(String[] args) {        insertFirst(1,10);        insertFirst(2,20);        insertFirst(3,30);        insertFirst(4,1);        insertLast(5,40);        insertLast(6,56);        System.out.print("\nDoubly Linked List: ");        printList();    }}

Output

Doubly Linked List: (4,1) (3,30) (2,20) (1,10) (5,40) (6,56)

class Node:    def __init__(self, data=None, key=None):        self.data = data        self.key = key        self.next = None        self.prev = Nonehead = Nonelast = Nonecurrent = Nonedef isEmpty():    return head == Nonedef printList():    ptr = head    while ptr != None:        print(f"({ptr.key},{ptr.data})", end=" ")        ptr = ptr.nextdef insertFirst(key, data):    global head, last    link = Node(data, key)    if isEmpty():        last = link    else:        head.prev = link    link.next = head    head = linkdef insertLast(key, data):    global head, last    link = Node(data, key)    if isEmpty():        last = link    else:        last.next = link        link.prev = last    last = linkinsertFirst(1,10)insertFirst(2,20)insertFirst(3,30)insertFirst(4,1)insertLast(5,40)insertLast(6,56)print("\nDoubly Linked List: ", end="")printList()

Output

Doubly Linked List: (4,1) (3,30) (2,20) (1,10) (5,40) (6,56)

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>struct node {   int data;   int key;   struct node *next;};struct node *head = NULL;struct node *current = NULL;bool isEmpty(){   return head == NULL;}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if (isEmpty()) {      head = link;      head->next = head;   } else {      //point it to old first node      link->next = head;      //point first to new first node      head = link;   }}//display the listvoid printList(){   struct node *ptr = head;   printf("\n[ ");   //start from the beginning   if(head != NULL) {      while(ptr->next != ptr) {         printf("(%d,%d) ",ptr->key,ptr->data);         ptr = ptr->next;      }   }   printf(" ]");}void main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("Circular Linked List: ");   //print list   printList();}

Output

Circular Linked List: [ (6,56) (5,40) (4,1) (3,30) (2,20)  ]

#include <iostream>#include <cstring>#include <cstdlib>#include <cstdbool>struct node {   int data;   int key;   struct node *next;};struct node *head = NULL;struct node *current = NULL;bool isEmpty(){   return head == NULL;}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if (isEmpty()) {      head = link;      head->next = head;   } else {      //point it to old first node      link->next = head;      //point first to new first node      head = link;   }}//display the listvoid printList(){   struct node *ptr = head;   printf("\n[ ");   //start from the beginning   if(head != NULL) {      while(ptr->next != ptr) {         printf("(%d,%d) ",ptr->key,ptr->data);         ptr = ptr->next;      }   }   printf(" ]");}int main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("Circular Linked List: ");      //print list   printList();   return 0;}

Output

Circular Linked List: [ (6,56) (5,40) (4,1) (3,30) (2,20)  ]

//Java program for circular link listimport java.util.*;class Node {    int data;    int key;    Node next;}public class Main {    static Node head = null;    static Node current = null;    static boolean isEmpty() {        return head == null;    }    //insert link at the first location    static void insertFirst(int key, int data) {        //create a link        Node link = new Node();        link.key = key;        link.data = data;        if (isEmpty()) {            head = link;            head.next = head;        } else {            //point it to old first node            link.next = head;            //point first to new first node            head = link;        }    }    //display the list    static void printList() {        Node ptr = head;        System.out.print("\n[ ");        //start from the beginning        if (head != null) {            while (ptr.next != ptr) {                System.out.print("(" + ptr.key + "," + ptr.data + ") ");                ptr = ptr.next;            }        }        System.out.print(" ]");    }    public static void main(String[] args) {        insertFirst(1, 10);        insertFirst(2, 20);        insertFirst(3, 30);        insertFirst(4, 1);        insertFirst(5, 40);        insertFirst(6, 56);        System.out.print("Circular Linked List: ");        //print list        printList();    }}

Output

Circular Linked List: [ (6,56) (5,40) (4,1) (3,30) (2,20) ]

#python program for circular linked listclass Node:    def __init__(self, key, data):        self.key = key        self.data = data        self.next = Nonehead = Nonecurrent = Nonedef is_empty():    return head is None#insert link at the first locationdef insert_first(key, data):    #create a link    global head    new_node = Node(key, data)    if is_empty():        head = new_node        head.next = head    else:        #point it to old first node        new_node.next = head        #point first to the new first node        head = new_node        #display the listdef print_list():    global head    ptr = head    print("[", end=" ")    #start from the beginning    if head is not None:        while ptr.next != ptr:            print("({}, {})".format(ptr.key, ptr.data), end=" ")            ptr = ptr.next        print("]")insert_first(1, 10)insert_first(2, 20)insert_first(3, 30)insert_first(4, 1)insert_first(5, 40)insert_first(6, 56)#printlistprint("Circular Linked List: ")print_list()

Output

Circular Linked List: [ (6,56) (5,40) (4,1) (3,30) (2,20) ]

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>struct node {   int data;   int key;   struct node *next;};struct node *head = NULL;struct node *current = NULL;bool isEmpty(){   return head == NULL;}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if (isEmpty()) {      head = link;      head->next = head;   } else {      //point it to old first node      link->next = head;      //point first to new first node      head = link;   }}//delete first itemstruct node * deleteFirst(){   //save reference to first link   struct node *tempLink = head;   if(head->next == head) {      head = NULL;      return tempLink;   }   //mark next to first link as first   head = head->next;   //return the deleted link   return tempLink;}//display the listvoid printList(){   struct node *ptr = head;   //start from the beginning   if(head != NULL) {      while(ptr->next != ptr) {         printf("(%d,%d) ",ptr->key,ptr->data);         ptr = ptr->next;      }   }}void main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("Circular Linked List: ");   //print list   printList();   deleteFirst();   printf("\nList after deleting the first item: ");   printList();}

Output

Circular Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) List after deleting the first item: (5,40) (4,1) (3,30) (2,20)

#include <iostream>#include <cstring>#include <cstdlib>#include <cstdbool>struct node {   int data;   int key;   struct node *next;};struct node *head = NULL;struct node *current = NULL;bool isEmpty(){   return head == NULL;}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if (isEmpty()) {      head = link;      head->next = head;   } else {      //point it to old first node      link->next = head;      //point first to new first node      head = link;   }}//delete first itemstruct node * deleteFirst(){      //save reference to first link   struct node *tempLink = head;   if(head->next == head) {      head = NULL;      return tempLink;   }   //mark next to first link as first   head = head->next;   //return the deleted link   return tempLink;}//display the listvoid printList(){   struct node *ptr = head;   //start from the beginning   if(head != NULL) {      while(ptr->next != ptr) {         printf("(%d,%d) ",ptr->key,ptr->data);         ptr = ptr->next;      }   }}int main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("Circular Linked List: ");   //print list   printList();   deleteFirst();   printf("\nList after deleting the first item: ");   printList();   return 0;}

Output

Circular Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) List after deleting the first item: (5,40) (4,1) (3,30) (2,20)

//Java program for circular linked listimport java.util.*;public class Main {    static class Node {        int data;        int key;        Node next;    }    static Node head = null;    static Node current = null;    static boolean isEmpty() {        return head == null;    }    //insert link at the first location    static void insertFirst(int key, int data) {        //create a link        Node link = new Node();        link.key = key;        link.data = data;        if (isEmpty()) {            head = link;            head.next = head;        } else {            //point it to old first node            link.next = head;            //point first to new first node            head = link;        }    }//delete first item    static Node deleteFirst() {        //save reference to first link        Node tempLink = head;        if (head.next == head) {            head = null;            return tempLink;        }        //mark next to first link as first        head = head.next;        //return the deleted link        return tempLink;    }    //display the list    static void printList() {        Node ptr = head;         //start from the beginning        if (head != null) {            while (ptr.next != ptr) {                System.out.printf("(%d,%d) ", ptr.key, ptr.data);                ptr = ptr.next;            }        }    }    public static void main(String[] args) {        insertFirst(1, 10);        insertFirst(2, 20);        insertFirst(3, 30);        insertFirst(4, 1);        insertFirst(5, 40);        insertFirst(6, 56);        System.out.print("Circular Linked List: ");        //print list        printList();        deleteFirst();  }}

Output

Circular Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) List after deleting the first item: (5,40) (4,1) (3,30) (2,20)

#python program for circular linked listclass Node:    def __init__(self, key, data):        self.key = key        self.data = data        self.next = Nonehead = Nonecurrent = Nonedef is_empty():    return head is None#insert link at the first locationdef insert_first(key, data):    #create a link    global head    new_node = Node(key, data)    if is_empty():        head = new_node        head.next = head    else:        #point it to old first node        new_node.next = head        #point first to the new first node        head = new_node        def print_list():    global head    ptr = head    print("[", end=" ")    #start from the beginning    if head is not None:        while ptr.next != ptr:            print("({}, {})".format(ptr.key, ptr.data), end=" ")            ptr = ptr.next        print("]")def delete_first():    global head    temp_link = head    if head.next == head:        head = None        return temp_link    head = head.next    return temp_link  insert_first(1, 10)insert_first(2, 20)insert_first(3, 30)insert_first(4, 1)insert_first(5, 40)insert_first(6, 56)#printlistprint("Circular Linked List: ")print_list()delete_first()print("\nList after deleting the first item: ")print_list();

Output

Circular Linked List: (6,56) (5,40) (4,1) (3,30) (2,20) List after deleting the first item: (5,40) (4,1) (3,30) (2,20)

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>struct node {   int data;   int key;   struct node *next;};struct node *head = NULL;struct node *current = NULL;bool isEmpty(){   return head == NULL;}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if (isEmpty()) {      head = link;      head->next = head;   } else {      //point it to old first node      link->next = head;      //point first to new first node      head = link;   }}//display the listvoid printList(){   struct node *ptr = head;   printf("\n[ ");   //start from the beginning   if(head != NULL) {      while(ptr->next != ptr) {         printf("(%d,%d) ",ptr->key,ptr->data);         ptr = ptr->next;      }   }   printf(" ]");}void main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("Circular Linked List: ");   //print list   printList();}

Output

Circular Linked List: [ (6,56) (5,40) (4,1) (3,30) (2,20)  ]

#include <iostream>#include <cstring>#include <cstdlib>#include <cstdbool>struct node {   int data;   int key;   struct node *next;};struct node *head = NULL;struct node *current = NULL;bool isEmpty(){   return head == NULL;}//insert link at the first locationvoid insertFirst(int key, int data){      //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if (isEmpty()) {      head = link;      head->next = head;   } else {      //point it to old first node      link->next = head;      //point first to new first node      head = link;   }}//display the listvoid printList(){   struct node *ptr = head;   printf("\n[ ");   //start from the beginning   if(head != NULL) {      while(ptr->next != ptr) {         printf("(%d,%d) ",ptr->key,ptr->data);         ptr = ptr->next;      }   }   printf(" ]");}int main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("Circular Linked List: ");   //print list   printList();   return 0;}

Output

Circular Linked List: [ (6,56) (5,40) (4,1) (3,30) (2,20)  ]

//Java program for circular link listimport java.util.*;class Node {    int data;    int key;    Node next;}public class Main {    static Node head = null;    static Node current = null;    static boolean isEmpty() {        return head == null;    }    //insert link at the first location    static void insertFirst(int key, int data) {        //create a link        Node link = new Node();        link.key = key;        link.data = data;        if (isEmpty()) {            head = link;            head.next = head;        } else {            //point it to old first node            link.next = head;            //point first to new first node            head = link;        }    }    //display the list    static void printList() {        Node ptr = head;        System.out.print("\n[ ");        //start from the beginning        if (head != null) {            while (ptr.next != ptr) {                System.out.print("(" + ptr.key + "," + ptr.data + ") ");                ptr = ptr.next;            }        }        System.out.print(" ]");    }    public static void main(String[] args) {        insertFirst(1, 10);        insertFirst(2, 20);        insertFirst(3, 30);        insertFirst(4, 1);        insertFirst(5, 40);        insertFirst(6, 56);        System.out.print("Circular Linked List: ");        //print list        printList();    }}

Output

Circular Linked List: [ (6,56) (5,40) (4,1) (3,30) (2,20) ]

#python program for circular linked listclass Node:    def __init__(self, key, data):        self.key = key        self.data = data        self.next = Nonehead = Nonecurrent = Nonedef is_empty():    return head is None#insert link at the first locationdef insert_first(key, data):    #create a link    global head    new_node = Node(key, data)    if is_empty():        head = new_node        head.next = head    else:        #point it to old first node        new_node.next = head        #point first to the new first node        head = new_node        #display the listdef print_list():    global head    ptr = head    print("[", end=" ")    #start from the beginning    if head is not None:        while ptr.next != ptr:            print("({}, {})".format(ptr.key, ptr.data), end=" ")            ptr = ptr.next        print("]")insert_first(1, 10)insert_first(2, 20)insert_first(3, 30)insert_first(4, 1)insert_first(5, 40)insert_first(6, 56)#printlistprint("Circular Linked List: ")print_list()

Output

Circular Linked List: [ (6,56) (5,40) (4,1) (3,30) (2,20) ]

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>struct node {   int data;   int key;   struct node *next;};struct node *head = NULL;struct node *current = NULL;bool isEmpty(){   return head == NULL;}int length(){   int length = 0;   //if list is empty   if(head == NULL) {      return 0;   }   current = head->next;   while(current != head) {      length++;      current = current->next;   }   return length;}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if (isEmpty()) {      head = link;      head->next = head;   } else {      //point it to old first node      link->next = head;      //point first to new first node      head = link;   }}//delete first itemstruct node * deleteFirst(){   //save reference to first link   struct node *tempLink = head;   if(head->next == head) {      head = NULL;      return tempLink;   }   //mark next to first link as first   head = head->next;   //return the deleted link   return tempLink;}//display the listvoid printList(){   struct node *ptr = head;   printf("\n[ ");   //start from the beginning   if(head != NULL) {      while(ptr->next != ptr) {         printf("(%d,%d) ",ptr->key,ptr->data);         ptr = ptr->next;      }   }   printf(" ]");}int main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   printf("Original List: ");   //print list   printList();   while(!isEmpty()) {      struct node *temp = deleteFirst();      printf("\nDeleted value:");      printf("(%d,%d) ",temp->key,temp->data);   }   printf("\nList after deleting all items: ");   printList();}

Output

Original List: [ (6,56) (5,40) (4,1) (3,30) (2,20)  ]Deleted value:(6,56) Deleted value:(5,40) Deleted value:(4,1) Deleted value:(3,30) Deleted value:(2,20) Deleted value:(1,10) List after deleting all items: [  ]

#include <iostream>#include <cstring>#include <cstdlib>#include <cstdbool>using namespace std;struct node {   int data;   int key;   struct node *next;};struct node *head = NULL;struct node *current = NULL;bool isEmpty(){   return head == NULL;}int length(){   int length = 0;      //if list is empty   if(head == NULL) {      return 0;   }   current = head->next;   while(current != head) {      length++;      current = current->next;   }   return length;}//insert link at the first locationvoid insertFirst(int key, int data){   //create a link   struct node *link = (struct node*) malloc(sizeof(struct node));   link->key = key;   link->data = data;   if (isEmpty()) {      head = link;      head->next = head;   } else {      //point it to old first node      link->next = head;            //point first to new first node      head = link;   }}//delete first itemstruct node * deleteFirst(){      //save reference to first link   struct node *tempLink = head;   if(head->next == head) {      head = NULL;      return tempLink;   }   //mark next to first link as first   head = head->next;      //return the deleted link   return tempLink;}//display the listvoid printList(){   struct node *ptr = head;   cout << "\n[ ";   //start from the beginning   if(head != NULL) {      while(ptr->next != ptr) {         cout << "(" << ptr->key << "," << ptr->data << ") ";         ptr = ptr->next;      }   }   cout << " ]";}int main(){   insertFirst(1,10);   insertFirst(2,20);   insertFirst(3,30);   insertFirst(4,1);   insertFirst(5,40);   insertFirst(6,56);   cout << "Original List: ";   //print list   printList();   while(!isEmpty()) {      struct node *temp = deleteFirst();      cout << "\n Deleted value:";      cout << "(" << temp->key << "," << temp->data << ") ";   }   cout << "\n List after deleting all items: ";   printList();   return 0;}

Output

Original List: [ (6,56) (5,40) (4,1) (3,30) (2,20)  ] Deleted value:(6,56)  Deleted value:(5,40)  Deleted value:(4,1)  Deleted value:(3,30)  Deleted value:(2,20)  Deleted value:(1,10)  List after deleting all items: [  ]

class Node {    int data;    int key;    Node next;    Node(int key, int data) {        this.key = key;        this.data = data;        this.next = null;    }}public class LinkedList {    private Node head;    private Node current;    boolean isEmpty() {        return head == null;    }    int length() {        int length = 0;        //if list is empty        if (head == null) {            return 0;        }        current = head.next;        while (current != head) {            length++;            current = current.next;        }        return length;    }    //insert link at the first location    void insertFirst(int key, int data) {        //create a link        Node link = new Node(key, data);        if (isEmpty()) {            head = link;            head.next = head;        } else {            //point it to old first node            link.next = head;            //point first to new first node            head = link;        }    }    //delete first item    Node deleteFirst() {        if (head.next == head) {            //save reference to first link            Node tempLink = head;            head = null;            return tempLink;        }        Node tempLink = head;        //mark next to first link as first        head = head.next;        //return the deleted link        return tempLink;    }    //display the list    void printList() {        Node ptr = head;        System.out.print("\n[ ");        //start from the beginning        if (head != null) {            while (ptr.next != ptr) {                System.out.print("(" + ptr.key + "," + ptr.data + ") ");                ptr = ptr.next;            }        }        System.out.print(" ]");    }    public static void main(String[] args) {        LinkedList linkedList = new LinkedList();        linkedList.insertFirst(1, 10);        linkedList.insertFirst(2, 20);        linkedList.insertFirst(3, 30);        linkedList.insertFirst(4, 1);        linkedList.insertFirst(5, 40);        linkedList.insertFirst(6, 56);        System.out.print("Original List: ");        linkedList.printList();        //print list        while (!linkedList.isEmpty()) {            Node temp = linkedList.deleteFirst();            System.out.println("\nDeleted value: (" + temp.key + "," + temp.data + ")");        }        System.out.print("\nList after deleting all items: ");        linkedList.printList();    }}

Output

Original List: [ (6,56) (5,40) (4,1) (3,30) (2,20)  ]Deleted value: (6,56)Deleted value: (5,40)Deleted value: (4,1)Deleted value: (3,30)Deleted value: (2,20)Deleted value: (1,10)List after deleting all items: [  ]

class Node:    def __init__(self, key, data):        self.key = key        self.data = data        self.next = Noneclass LinkedList:    def __init__(self):        self.head = None        self.current = None    def is_empty(self):        return self.head is None    def length(self):        length = 0        # If list is empty        if self.head is None:            return 0        self.current = self.head.next        while self.current != self.head:            length += 1            self.current = self.current.next        return length    # insert link at the first location    def insert_first(self, key, data):        # create a link        new_node = Node(key, data)        if self.is_empty():            self.head = new_node            self.head.next = self.head        else:            # point it to old first node            new_node.next = self.head            # point first to new first node            self.head = new_node    # delete first item    def delete_first(self):        # save reference to first link        if self.head.next == self.head:            temp_link = self.head            self.head = None            return temp_link        # mark next to first link as first        temp_link = self.head        self.head = self.head.next        # return the deleted link        return temp_link    # Diplay the list    def print_list(self):        ptr = self.head        print("[", end=" ")        # start from the beginning        if self.head is not None:            while ptr.next != ptr:                print("({}, {})".format(ptr.key, ptr.data), end=" ")                ptr = ptr.next        print("]")# Main functionif __name__ == '__main__':    linked_list = LinkedList()    linked_list.insert_first(1, 10)    linked_list.insert_first(2, 20)    linked_list.insert_first(3, 30)    linked_list.insert_first(4, 1)    linked_list.insert_first(5, 40)    linked_list.insert_first(6, 56)    print("Original List: ", end="")    linked_list.print_list()    while not linked_list.is_empty():        temp = linked_list.delete_first()        print("\nDeleted value: ({}, {})".format(temp.key, temp.data))    # print list    print("List after deleting all items: ", end="")    linked_list.print_list()

Output

Original List: [ (6, 56) (5, 40) (4, 1) (3, 30) (2, 20) ]Deleted value: (6, 56)Deleted value: (5, 40)Deleted value: (4, 1)Deleted value: (3, 30)Deleted value: (2, 20)Deleted value: (1, 10)List after deleting all items: [ ]

#include <stdio.h>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is full*/int isfull(){   if(top == MAXSIZE)      return 1;   else      return 0;}/* Function to insert into the stack */int push(int data){   if(!isfull()) {      top = top + 1;      stack[top] = data;   } else {      printf("Could not insert data, Stack is full.\n");   }}/* Main function */int main(){   int i;   push(44);   push(10);   push(62);   push(123);   push(15);   printf("Stack Elements: \n");      // print stack data   for(i = 0; i < 8; i++) {      printf("%d ", stack[i]);   }   return 0;}

Output

Stack Elements: 44 10 62 123 15 0 0 0

#include <iostream>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is full*/int isfull(){   if(top == MAXSIZE)      return 1;   else      return 0;}/* Function to insert into the stack */int push(int data){   if(!isfull()) {      top = top + 1;      stack[top] = data;   } else {      printf("Could not insert data, Stack is full.\n");   }}/* Main function */int main(){   int i;   push(44);   push(10);   push(62);   push(123);   push(15);   printf("Stack Elements: \n");   // print stack data   for(i = 0; i < 8; i++) {      printf("%d ", stack[i]);   }   return 0;}

Output

Stack Elements: 44 10 62 123 15 0 0 0

import java.io.*;import java.util.*; // util imports the stack classpublic class StackExample {   public static void main (String[] args) {      Stack<Integer> stk = new Stack<Integer>();            // inserting elements into the stack      stk.push(52);      stk.push(19);      stk.push(33);      stk.push(14);      stk.push(6);      System.out.print("The stack is: " + stk);   }}

Output

The stack is: [52, 19, 33, 14, 6]

class Stack:   def __init__(self):      self.stack = []   def __str__(self):      return str(self.stack)   def push(self, data):      if data not in self.stack:         self.stack.append(data)         return True      else:         return Falsestk = Stack()stk.push(1)stk.push(2)stk.push(3)stk.push(4)stk.push(5)print("Stack Elements:")print(stk)

Output

Stack Elements:[1, 2, 3, 4, 5]

#include <stdio.h>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is empty */int isempty(){   if(top == -1)      return 1;   else      return 0;}/* Check if the stack is full*/int isfull(){   if(top == MAXSIZE)      return 1;   else      return 0;}/* Function to delete from the stack */int pop(){   int data;   if(!isempty()) {      data = stack[top];      top = top - 1;      return data;   } else {      printf("Could not retrieve data, Stack is empty.\n");   }}/* Function to insert into the stack */int push(int data){   if(!isfull()) {      top = top + 1;      stack[top] = data;   } else {      printf("Could not insert data, Stack is full.\n");   }}/* Main function */int main(){   int i;   push(44);   push(10);   push(62);   push(123);   push(15);   printf("Stack Elements: \n");   // print stack data   for(i = 0; i < 8; i++) {      printf("%d ", stack[i]);   }   /*printf("Element at top of the stack: %d\n" ,peek());*/   printf("\nElements popped: \n");   // print stack data   while(!isempty()) {      int data = pop();      printf("%d ",data);   }   return 0;}

Output

Stack Elements: 44 10 62 123 15 0 0 0 Elements popped: 15 123 62 10 44

#include <iostream>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is empty */int isempty(){   if(top == -1)      return 1;   else      return 0;}/* Check if the stack is full*/int isfull(){   if(top == MAXSIZE)      return 1;   else      return 0;}/* Function to delete from the stack */int pop(){   int data;   if(!isempty()) {      data = stack[top];      top = top - 1;      return data;   } else {      printf("Could not retrieve data, Stack is empty.\n");   }}/* Function to insert into the stack */int push(int data){   if(!isfull()) {      top = top + 1;      stack[top] = data;   } else {      printf("Could not insert data, Stack is full.\n");   }}/* Main function */int main(){   int i;   push(44);   push(10);   push(62);   push(123);   push(15);   printf("Stack Elements: \n");   // print stack data   for(i = 0; i < 8; i++) {      printf("%d ", stack[i]);   }      /*printf("Element at top of the stack: %d\n" ,peek());*/   printf("\nElements popped: \n");   // print stack data   while(!isempty()) {      int data = pop();      printf("%d ",data);   }   return 0;}

Output

Stack Elements: 44 10 62 123 15 0 0 0 Elements popped: 15 123 62 10 44

import java.io.*;import java.util.*; // util imports the stack classpublic class StackExample {   public static void main (String[] args) {      Stack<Integer> stk = new Stack<Integer>();            // Inserting elements into the stack      stk.push(52);      stk.push(19);      stk.push(33);      stk.push(14);      stk.push(6);      System.out.print("The stack is: " + stk);            // Deletion from the stack      System.out.print("\nThe popped element is: ");      Integer n = (Integer) stk.pop();      System.out.print(n);   }}

Output

The stack is: [52, 19, 33, 14, 6]The popped element is: 6

class Stack:   def __init__(self):      self.stack = []   def __str__(self):      return str(self.stack)   def push(self, data):      if data not in self.stack:         self.stack.append(data)         return True      else:         return False   def remove(self):      if len(self.stack) <= 0:         return ("No element in the Stack")      else:         return self.stack.pop()stk = Stack()stk.push(1)stk.push(2)stk.push(3)stk.push(4)stk.push(5)print("Stack Elements:")print(stk)print("----Deletion operation in stack----")p = stk.remove()print("The popped element is: " + str(p))print("Updated Stack:")print(stk)

Output

Stack Elements:[1, 2, 3, 4, 5]----Deletion operation in stack----The popped element is: 5Updated Stack:[1, 2, 3, 4]

#include <stdio.h>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is full */int isfull(){   if(top == MAXSIZE)      return 1;   else      return 0;}/* Function to return the topmost element in the stack */int peek(){   return stack[top];}/* Function to insert into the stack */int push(int data){   if(!isfull()) {      top = top + 1;      stack[top] = data;   } else {      printf("Could not insert data, Stack is full.\n");   }}/* Main function */int main(){   int i;   push(44);   push(10);   push(62);   push(123);   push(15);   printf("Stack Elements: \n");   // print stack data   for(i = 0; i < 8; i++) {      printf("%d ", stack[i]);   }   printf("\nElement at top of the stack: %d\n" ,peek());   return 0;}

Output

Stack Elements: 44 10 62 123 15 0 0 0 Element at top of the stack: 15

#include <iostream>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is full */int isfull(){   if(top == MAXSIZE)      return 1;   else      return 0;}/* Function to return the topmost element in the stack */int peek(){   return stack[top];}/* Function to insert into the stack */int push(int data){   if(!isfull()) {      top = top + 1;      stack[top] = data;   } else {      printf("Could not insert data, Stack is full.\n");   }}/* Main function */int main(){   int i;   push(44);   push(10);   push(62);   push(123);   push(15);   printf("Stack Elements: \n");   // print stack data   for(i = 0; i < 8; i++) {      printf("%d ", stack[i]);   }   printf("\nElement at top of the stack: %d\n" ,peek());   return 0;}

Output

Stack Elements: 44 10 62 123 15 0 0 0 Element at top of the stack: 15

import java.io.*;import java.util.*; // util imports the stack classpublic class StackExample {   public static void main (String[] args) {      Stack<Integer> stk = new Stack<Integer>();            // inserting elements into the stack      stk.push(52);      stk.push(19);      stk.push(33);      stk.push(14);      stk.push(6);      System.out.print("The stack is: " + stk);      Integer pos = (Integer) stk.peek();      System.out.print("\nThe element found is " + pos);   }}

Output

The stack is: [52, 19, 33, 14, 6]The element found is 6

class Stack:   def __init__(self):      self.stack = []   def __str__(self):      return str(self.stack)   def push(self, data):      if data not in self.stack:         self.stack.append(data)         return True      else:         return False   # Use peek to look at the top of the stack   def peek(self):      return self.stack[-1]stk = Stack()stk.push(1)stk.push(2)stk.push(3)stk.push(4)stk.push(5)print("Stack Elements:")print(stk)print("topmost element: ",stk.peek())

Output

Stack Elements:[1, 2, 3, 4, 5]topmost element: 5

#include <stdio.h>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is full */int isfull(){   if(top == MAXSIZE)      return 1;   else      return 0;}/* Main function */int main(){   printf("Stack full: %s\n" , isfull()?"true":"false");   return 0;}

Output

Stack full: false

#include <iostream>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is full */int isfull(){   if(top == MAXSIZE)      return 1;   else      return 0;}/* Main function */int main(){   printf("Stack full: %s\n" , isfull()?"true":"false");   return 0;}

Output

Stack full: false

import java.io.*;public class StackExample {   private int arr[];   private int top;   private int capacity;   StackExample(int size) {      arr = new int[size];      capacity = size;      top = -1;   }   public boolean isEmpty() {      return top == -1;   }   public boolean isFull() {      return top == capacity - 1;   }   public void push(int key) {      if (isFull()) {         System.out.println("Stack is Full\n");         return;      }      arr[++top] = key;   }   public static void main (String[] args) {      StackExample stk = new StackExample(5);      stk.push(1); // inserting 1 in the stack      stk.push(2);      stk.push(3);      stk.push(4);      stk.push(5);      System.out.println("Stack Full? " + stk.isFull());   }}

Output

Stack Full? true

#python code for stack(IsFull)MAXSIZE = 8stack = [None] * MAXSIZEtop = -1#Check if the stack is empty def isfull():    if top == MAXSIZE - 1:        return True    else:        return False#main functionprint("Stack full:", isfull())

Output

Stack full: False

#include <stdio.h>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is empty */int isempty() {   if(top == -1)      return 1;   else      return 0;}/* Main function */int main() {   printf("Stack empty: %s\n" , isempty()?"true":"false");   return 0;}

Output

Stack empty: true

#include <iostream>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is empty */int isempty(){   if(top == -1)      return 1;   else      return 0;}/* Main function */int main(){   printf("Stack empty: %s\n" , isempty()?"true":"false");   return 0;}

Output

Stack empty: true

import java.io.*;import java.util.*; // util imports the stack classpublic class StackExample {   public static void main (String[] args) {      Stack<Integer> stk = new Stack<Integer>();            // Inserting elements into the stack      stk.push(52);      stk.push(19);      stk.push(33);      stk.push(14);      stk.push(6);      System.out.println("Stack empty? "+ stk.isEmpty());   }}

Output

Stack empty? false

#python code for stack(IsFull)MAXSIZE = 8stack = [None] * MAXSIZEtop = -1#Check if the stack is empty def isempty():    if top == -1:        return True    else:        return False  #main functionprint("Stack empty:", isempty())

Output

Stack empty: True

#include <stdio.h>int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is empty */int isempty(){   if(top == -1)      return 1;   else      return 0;}/* Check if the stack is full */int isfull(){   if(top == MAXSIZE)      return 1;   else      return 0;}/* Function to return the topmost element in the stack */int peek(){   return stack[top];}/* Function to delete from the stack */int pop(){   int data;   if(!isempty()) {      data = stack[top];      top = top - 1;      return data;   } else {      printf("Could not retrieve data, Stack is empty.\n");   }}/* Function to insert into the stack */int push(int data){   if(!isfull()) {      top = top + 1;      stack[top] = data;   } else {      printf("Could not insert data, Stack is full.\n");   }}/* Main function */int main(){   push(44);   push(10);   push(62);   push(123);   push(15);   printf("Element at top of the stack: %d\n" ,peek());   printf("Elements: \n");   // print stack data   while(!isempty()) {      int data = pop();      printf("%d\n",data);   }   printf("Stack full: %s\n" , isfull()?"true":"false");   printf("Stack empty: %s\n" , isempty()?"true":"false");   return 0;}

Output

Element at top of the stack: 15Elements: 15123621044Stack full: falseStack empty: true

#include <iostream>using namespace std;int MAXSIZE = 8;int stack[8];int top = -1;/* Check if the stack is empty */int isempty(){   if(top == -1)      return 1;   else      return 0;}/* Check if the stack is full */int isfull(){   if(top == MAXSIZE)      return 1;   else      return 0;}/* Function to return the topmost element in the stack */int peek(){   return stack[top];}/* Function to delete from the stack */int pop(){   int data;   if(!isempty()) {      data = stack[top];      top = top - 1;      return data;   } else      cout << "Could not retrieve data, Stack is empty." << endl;}/* Function to insert into the stack */int push(int data){   if(!isfull()) {      top = top + 1;      stack[top] = data;   } else      cout << "Could not insert data, Stack is full." << endl;}/* Main function */int main(){   push(44);   push(10);   push(62);   push(123);   push(15);   cout << "Element at top of the stack: " << peek() << endl;   printf("Elements: \n");   // print stack data   while(!isempty()) {      int data = pop();      cout << data <<endl;   }   printf("Stack full: %s\n" , isfull()?"true":"false");   printf("Stack empty: %s\n" , isempty()?"true":"false");   return 0;}

Output

Element at top of the stack: 15Elements: 15123621044Stack full: falseStack empty: true

import java.io.*;import java.util.*; // util imports the stack classpublic class StackExample {   public static void main (String[] args) {      Stack<Integer> stk = new Stack<Integer>();      // inserting elements into the stack      stk.push(52);      stk.push(19);      stk.push(33);      stk.push(14);      stk.push(6);      System.out.print("The stack is: " + stk);      // deletion from the stack      System.out.print("\nThe popped element is: ");      Integer n = (Integer) stk.pop();      System.out.print(n);      // searching for an element in the stack      Integer pos = (Integer) stk.search(19);      if(pos == -1)         System.out.print("\nThe element 19 not found in stack");      else         System.out.print("\nThe element 19 is found at " + pos);   }}

Output

The stack is: [52, 19, 33, 14, 6]The popped element is: 6The element 19 is found at 3

class Stack:   def __init__(self):      self.stack = []   def add(self, data):      if data not in self.stack:         self.stack.append(data)         return True      else:         return False# Use peek to look at the top of the stack   def peek(self):      return self.stack[-1]# Use list pop method to remove element   def remove(self):      if len(self.stack) <= 0:         return ("No element in the Stack")      else:         return self.stack.pop()stk = Stack()stk.add(1)stk.add(2)stk.add(3)stk.add(4)stk.add(5)print("topmost element: ",stk.peek())print("----Deletion operation in stack----")stk.remove()stk.peek()print("topmost element after deletion: ",stk.peek())

Output

topmost element: 5----Deletion operation in stack----topmost element after deletion: 4

#include<stdio.h>#include<string.h>#include<ctype.h>//char stackchar stack[25]; int top = -1; void push(char item) {   stack[++top] = item; } char pop() {   return stack[top--]; } //returns precedence of operatorsint precedence(char symbol) {   switch(symbol) {      case '+':       case '-':         return 2;          break;       case '*':       case '/':         return 3;          break;       case '^':          return 4;          break;       case '(':       case ')':       case '#':         return 1;          break;    } } //check whether the symbol is operator?int isOperator(char symbol) {   switch(symbol) {      case '+':       case '-':       case '*':       case '/':       case '^':       case '(':       case ')':         return 1;       break;          default:         return 0;    } } //converts infix expression to postfixvoid convert(char infix[],char postfix[]) {   int i,symbol,j = 0;    stack[++top] = '#';    for(i = 0;i<strlen(infix);i++) {      symbol = infix[i];       if(isOperator(symbol) == 0) {         postfix[j] = symbol;          j++;       } else {         if(symbol == '(') {            push(symbol);          } else {            if(symbol == ')') {               while(stack[top] != '(') {                  postfix[j] = pop();                   j++;                }                pop();   //pop out (.             } else {               if(precedence(symbol)>precedence(stack[top])) {                  push(symbol);                } else {                  while(precedence(symbol)<=precedence(stack[top])) {                     postfix[j] = pop();                      j++;                   }                   push(symbol);                }            }         }      }   }   while(stack[top] != '#') {      postfix[j] = pop();       j++;    }    postfix[j]='\0';  //null terminate string. } //int stackint stack_int[25]; int top_int = -1; void push_int(int item) {   stack_int[++top_int] = item; } char pop_int() {   return stack_int[top_int--]; } //evaluates postfix expressionint evaluate(char *postfix){   char ch;   int i = 0,operand1,operand2;   while( (ch = postfix[i++]) != '\0') {      if(isdigit(ch)) {         push_int(ch-'0');  // Push the operand       } else {         //Operator,pop two  operands          operand2 = pop_int();         operand1 = pop_int();         switch(ch) {            case '+':               push_int(operand1+operand2);               break;            case '-':               push_int(operand1-operand2);               break;            case '*':               push_int(operand1*operand2);               break;            case '/':               push_int(operand1/operand2);               break;         }      }   }   return stack_int[top_int];}void main() {    char infix[25] = "1*(2+3)",postfix[25];    convert(infix,postfix);    printf("Infix expression is: %s\n" , infix);   printf("Postfix expression is: %s\n" , postfix);   printf("Evaluated expression is: %d\n" , evaluate(postfix));}

Output

Infix expression is: 1*(2+3)Postfix expression is: 123+*Evaluated expression is: 5

// C++ Code for Expression Parsing Using Stack#include <iostream>#include <string>#include <cctype>#include <stack>// char stackstd::stack<char> stack;void push(char item) {    stack.push(item);}char pop() {    char top = stack.top();    stack.pop();    return top;}// returns precedence of operatorsint precedence(char symbol) {    switch(symbol) {        case '+':        case '-':            return 2;        case '*':        case '/':            return 3;        case '^':            return 4;        case '(':        case ')':        case '#':            return 1;    }    return 0;}// check whether the symbol is an operatorint isOperator(char symbol) {    switch(symbol) {        case '+':        case '-':        case '*':        case '/':        case '^':        case '(':        case ')':            return 1;        default:            return 0;    }}// converts infix expression to postfixvoid convert(const std::string& infix, std::string& postfix) {    int j = 0;    stack.push('#');    for (char symbol : infix) {        if (isOperator(symbol) == 0) {            postfix += symbol;            j++;        } else {            if (symbol == '(') {                push(symbol);            } else {                if (symbol == ')') {                    while (stack.top() != '(') {                        postfix += pop();                        j++;                    }                    stack.pop(); // pop out '('                } else {                    if (precedence(symbol) > precedence(stack.top())) {                        push(symbol);                    } else {                        while (precedence(symbol) <= precedence(stack.top())) {                            postfix += pop();                            j++;                        }                        push(symbol);                    }                }            }        }    }    while (stack.top() != '#') {        postfix += pop();        j++;    }    postfix[j] = '\0'; // null terminate string}// evaluates postfix expressionint evaluate(const std::string& postfix) {    std::stack<int> stack_int;    int operand1, operand2;    for (char ch : postfix) {        if (std::isdigit(ch)) {            stack_int.push(ch - '0'); // Push the operand        } else {            // Operator, pop two operands            operand2 = stack_int.top();            stack_int.pop();            operand1 = stack_int.top();            stack_int.pop();            switch (ch) {                case '+':                    stack_int.push(operand1 + operand2);                    break;                case '-':                    stack_int.push(operand1 - operand2);                    break;                case '*':                    stack_int.push(operand1 * operand2);                    break;                case '/':                    stack_int.push(operand1 / operand2);                    break;            }        }    }    return stack_int.top();}int main() {    std::string infix = "1*(2+3)", postfix;    convert(infix, postfix);    std::cout << "Infix expression is: " << infix << std::endl;    std::cout << "Postfix expression is: " << postfix << std::endl;    std::cout << "Evaluated expression is: " << evaluate(postfix) << std::endl;    return 0;}

Output

Infix expression is: 1*(2+3)Postfix expression is: 123+*Evaluated expression is: 5

// Java Code for Expression Parsing Using Stackimport java.util.Stack;public class Main {    // char stack    static Stack<Character> stack = new Stack<>();    static void push(char item) {        stack.push(item);    }    static char pop() {        return stack.pop();    }    // returns precedence of operators    static int precedence(char symbol) {        switch (symbol) {            case '+':            case '-':                return 2;            case '*':            case '/':                return 3;            case '^':                return 4;            case '(':            case ')':            case '#':                return 1;        }        return 0;    }    // check whether the symbol is an operator    static int isOperator(char symbol) {        switch (symbol) {            case '+':            case '-':            case '*':            case '/':            case '^':            case '(':            case ')':                return 1;            default:                return 0;        }    }    // converts infix expression to postfix    static void convert(String infix, StringBuilder postfix) {        int j = 0;        stack.push('#');        for (char symbol : infix.toCharArray()) {            if (isOperator(symbol) == 0) {                postfix.append(symbol);                j++;            } else {                if (symbol == '(') {                    push(symbol);                } else {                    if (symbol == ')') {                        while (stack.peek() != '(') {                            postfix.append(pop());                            j++;                        }                        stack.pop(); // pop out '('                    } else {                        if (precedence(symbol) > precedence(stack.peek())) {                            push(symbol);                        } else {                            while (precedence(symbol) <= precedence(stack.peek())) {                                postfix.append(pop());                                j++;                            }                            push(symbol);                        }                    }                }            }        }        while (stack.peek() != '#') {            postfix.append(pop());            j++;        }    }    // evaluates postfix expression    static int evaluate(String postfix) {        Stack<Integer> stackInt = new Stack<>();        int operand1, operand2;        for (char ch : postfix.toCharArray()) {            if (Character.isDigit(ch)) {                stackInt.push(ch - '0'); // Push the operand            } else {                // Operator, pop two operands                operand2 = stackInt.pop();                operand1 = stackInt.pop();                switch (ch) {                    case '+':                        stackInt.push(operand1 + operand2);                        break;                    case '-':                        stackInt.push(operand1 - operand2);                        break;                    case '*':                        stackInt.push(operand1 * operand2);                        break;                    case '/':                        stackInt.push(operand1 / operand2);                        break;                }            }        }        return stackInt.peek();    }    public static void main(String[] args) {        String infix = "1*(2+3)";        StringBuilder postfix = new StringBuilder();        convert(infix, postfix);        System.out.println("Infix expression is: " + infix);        System.out.println("Postfix expression is: " + postfix);        System.out.println("Evaluated expression is: " + evaluate(postfix.toString()));    }}

Infix expression is: 1*(2+3)Postfix expression is: 123+*Evaluated expression is: 5

class Main:    stack = []    @staticmethod    def push(item):        Main.stack.append(item)    @staticmethod    def pop():        return Main.stack.pop()    #returns precedence of operators    @staticmethod    def precedence(symbol):        if symbol in ['+', '-']:            return 2        elif symbol in ['*', '/']:            return 3        elif symbol == '^':            return 4        elif symbol in ['(', ')', '#']:            return 1        return 0    #check whether the symbol is an operator    @staticmethod    def is_operator(symbol):        return symbol in ['+', '-', '*', '/', '^', '(', ')']    @staticmethod    def convert(infix):        postfix = ""        j = 0        Main.push('#')        for symbol in infix:            if not Main.is_operator(symbol):                postfix += symbol                j += 1            else:                if symbol == '(':                    Main.push(symbol)                else:                    if symbol == ')':                        while Main.stack[-1] != '(':                            postfix += Main.pop()                            j += 1                        Main.pop()  # pop out '('                    else:                        if Main.precedence(symbol) > Main.precedence(Main.stack[-1]):                            Main.push(symbol)                        else:                            while Main.precedence(symbol) <= Main.precedence(Main.stack[-1]):                                postfix += Main.pop()                                j += 1                            Main.push(symbol)        while Main.stack[-1] != '#':            postfix += Main.pop()            j += 1        return postfix    @staticmethod    def evaluate(postfix):        stack_int = []        for ch in postfix:            if ch.isdigit():                stack_int.append(int(ch))            else:                operand2 = stack_int.pop()                operand1 = stack_int.pop()                if ch == '+':                    stack_int.append(operand1 + operand2)                elif ch == '-':                    stack_int.append(operand1 - operand2)                elif ch == '*':                    stack_int.append(operand1 * operand2)                elif ch == '/':                    stack_int.append(operand1 / operand2)        return stack_int[0]    @staticmethod    def main():        infix = "1*(2+3)"        postfix = Main.convert(infix)        print("Infix expression is:", infix)        print("Postfix expression is:", postfix)        print("Evaluated expression is:", Main.evaluate(postfix))Main.main()

Output

Infix expression is: 1*(2+3)Postfix expression is: 123+*Evaluated expression is: 5

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;bool isFull(){   return itemCount == MAX;}bool isEmpty(){   return itemCount == 0;}int removeData(){   int data = intArray[front++];   if(front == MAX) {      front = 0;   }   itemCount--;   return data;}void insert(int data){   if(!isFull()) {      if(rear == MAX-1) {         rear = -1;      }      intArray[++rear] = data;      itemCount++;   }}int main(){   insert(3);   insert(5);   insert(9);   insert(1);   insert(12);   insert(15);   printf("Queue: ");   while(!isEmpty()) {      int n = removeData();      printf("%d ",n);   }}

Output

Queue: 3 5 9 1 12 15

#include <iostream>#include <string>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;bool isFull(){   return itemCount == MAX;}bool isEmpty(){   return itemCount == 0;}int removeData(){   int data = intArray[front++];   if(front == MAX) {      front = 0;   }   itemCount--;   return data;}void insert(int data){   if(!isFull()) {      if(rear == MAX-1) {         rear = -1;      }      intArray[++rear] = data;      itemCount++;   }}int main(){   insert(3);   insert(5);   insert(9);   insert(1);   insert(12);   insert(15);   printf("Queue: ");   while(!isEmpty()) {      int n = removeData();      printf("%d ",n);   }}

Output

Queue: 3 5 9 1 12 15

import java.util.LinkedList;import java.util.Queue;public class QueueExample {   public static void main(String[] args) {      Queue<Integer> q = new LinkedList<>();      q.add(6);      q.add(1);      q.add(8);      q.add(4);      q.add(7);      System.out.println("The queue is: " + q);   }}

Output

The queue is: [6, 1, 8, 4, 7]

class Queue:   def __init__(self):      self.queue = list()   def __str__(self):      return str(self.queue)   def addtoqueue(self,data):   # Insert method to add element      if data not in self.queue:         self.queue.insert(0,data)         return True      return Falseq = Queue()q.addtoqueue("36")q.addtoqueue("24")q.addtoqueue("48")q.addtoqueue("12")q.addtoqueue("66")print("Queue:")print(q)

Output

Queue:['66', '12', '48', '24', '36']

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;bool isFull(){   return itemCount == MAX;}bool isEmpty(){   return itemCount == 0;}void insert(int data){   if(!isFull()) {      if(rear == MAX-1) {         rear = -1;      }      intArray[++rear] = data;      itemCount++;   }}int removeData(){   int data = intArray[front++];   if(front == MAX) {      front = 0;   }   itemCount--;   return data;}int main(){   int i;      /* insert 5 items */   insert(3);   insert(5);   insert(9);   insert(1);   insert(12);   insert(15);   printf("Queue: ");   for(i = 0; i < MAX; i++)      printf("%d ", intArray[i]);   // remove one item   int num = removeData();   printf("\nElement removed: %d\n",num);   printf("Updated Queue: ");   while(!isEmpty()) {      int n = removeData();      printf("%d ",n);   }}

Output

Queue: 3 5 9 1 12 15 Element removed: 3Updated Queue: 5 9 1 12 15

#include <iostream>#include <string>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;bool isFull(){   return itemCount == MAX;}bool isEmpty(){   return itemCount == 0;}void insert(int data){   if(!isFull()) {      if(rear == MAX-1) {         rear = -1;      }      intArray[++rear] = data;      itemCount++;   }}int removeData(){   int data = intArray[front++];   if(front == MAX) {      front = 0;   }   itemCount--;   return data;}int main(){   int i;      /* insert 5 items */   insert(3);   insert(5);   insert(9);   insert(1);   insert(12);   insert(15);   printf("Queue: ");   for(i = 0; i < MAX; i++)      printf("%d ", intArray[i]);      // remove one item   int num = removeData();   printf("\nElement removed: %d\n",num);   printf("Updated Queue: ");   while(!isEmpty()) {      int n = removeData();      printf("%d ",n);   }}

Output

Queue: 3 5 9 1 12 15 Element removed: 3Updated Queue: 5 9 1 12 15

import java.util.LinkedList;import java.util.Queue;public class QueueExample {   public static void main(String[] args) {      Queue<Integer> q = new LinkedList<>();      q.add(6);      q.add(1);      q.add(8);      q.add(4);      q.add(7);      System.out.println("The queue is: " + q);      int n = q.remove();      System.out.println("The element deleted is: " + n);      System.out.println("Queue after deletion: " + q);   }}

Output

The queue is: [6, 1, 8, 4, 7]The element deleted is: 6Queue after deletion: [1, 8, 4, 7]

class Queue:   def __init__(self):      self.queue = list()   def __str__(self):      return str(self.queue)   def addtoqueue(self,data):   # Insert method to add element      if data not in self.queue:         self.queue.insert(0,data)         return True      return False   def removefromqueue(self):      if len(self.queue)>0:         return self.queue.pop()      return ("Queue is empty")q = Queue()q.addtoqueue("36")q.addtoqueue("24")q.addtoqueue("48")q.addtoqueue("12")q.addtoqueue("66")print("Queue:")print(q)print("Element deleted from queue: ",q.removefromqueue())

Output

Queue:['66', '12', '48', '24', '36']Element deleted from queue:  36

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;int peek(){   return intArray[front];}bool isFull(){   return itemCount == MAX;}void insert(int data){   if(!isFull()) {      if(rear == MAX-1) {         rear = -1;      }      intArray[++rear] = data;      itemCount++;   }}int main(){   int i;      /* insert 5 items */   insert(3);   insert(5);   insert(9);   insert(1);   insert(12);   insert(15);   printf("Queue: ");   for(i = 0; i < MAX; i++)      printf("%d ", intArray[i]);   printf("\nElement at front: %d\n",peek());}

Output

Queue: 3 5 9 1 12 15 Element at front: 3

#include <iostream>#include <string>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;int peek(){   return intArray[front];}bool isFull(){   return itemCount == MAX;}void insert(int data){   if(!isFull()) {      if(rear == MAX-1) {         rear = -1;      }      intArray[++rear] = data;      itemCount++;   }}int main(){   int i;   /* insert 5 items */   insert(3);   insert(5);   insert(9);   insert(1);   insert(12);   insert(15);   printf("Queue: ");   for(i = 0; i < MAX; i++)      printf("%d ", intArray[i]);   printf("\nElement at front: %d\n",peek());}

Output

Queue: 3 5 9 1 12 15 Element at front: 3

import java.util.LinkedList;import java.util.Queue;public class QueueExample {   public static void main(String[] args) {      Queue<Integer> q = new LinkedList<>();      q.add(6);      q.add(1);      q.add(8);      q.add(4);      q.add(7);      System.out.println("The queue is: " + q);   }}

Output

The queue is: [6, 1, 8, 4, 7]

class Queue:   def __init__(self):      self.queue = list()   def __str__(self):      return str(self.queue)   def addtoqueue(self,data):      # Insert method to add element      if data not in self.queue:         self.queue.insert(0,data)         return True      return False   def peek(self):      return self.queue[-1]q = Queue()q.addtoqueue("36")q.addtoqueue("24")q.addtoqueue("48")q.addtoqueue("12")q.addtoqueue("66")print("Queue:")print(q)print("The frontmost element of the queue: ",q.peek())

Output

Queue:['66', '12', '48', '24', '36']The frontmost element of the queue:  36

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;bool isFull(){   return itemCount == MAX;}void insert(int data){   if(!isFull()) {      if(rear == MAX-1) {         rear = -1;      }      intArray[++rear] = data;      itemCount++;   }}int main(){   int i;   /* insert 5 items */   insert(3);   insert(5);   insert(9);   insert(1);   insert(12);   insert(15);   printf("Queue: ");   for(i = 0; i < MAX; i++)      printf("%d ", intArray[i]);   printf("\n");   if(isFull()) {      printf("Queue is full!\n");   }}

Output

Queue: 3 5 9 1 12 15 Queue is full!

#include <iostream>#include <string>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;bool isFull(){   return itemCount == MAX;}void insert(int data){   if(!isFull()) {      if(rear == MAX-1) {         rear = -1;      }      intArray[++rear] = data;      itemCount++;   }}int main(){   int i;      /* insert 5 items */   insert(3);   insert(5);   insert(9);   insert(1);   insert(12);   insert(15);   printf("Queue: ");   for(i = 0; i < MAX; i++)      printf("%d ", intArray[i]);   printf("\n");   if(isFull()) {      printf("Queue is full!\n");   }}

Output

Queue: 3 5 9 1 12 15 Queue is full!

import java.io.*;public class QueueExample {   private int intArray[];   private int front;   private int rear;   private int itemCount;   private int MAX;   QueueExample(int size) {      intArray = new int[size];      front = 0;      rear = -1;      MAX = size;      itemCount = 0;   }   public boolean isFull() {      return itemCount == MAX;   }   public void insert(int key) {      if(!isFull()) {         if(rear == MAX-1) {            rear = -1;         }         intArray[++rear] = key;         itemCount++;      }   }   public static void main (String[] args) {      QueueExample q = new QueueExample(5);      q.insert(1); // inserting 1 in the stack      q.insert(2);      q.insert(3);      q.insert(4);      q.insert(5);      System.out.println("Stack Full? " + q.isFull());   }}

Output

Stack Full? true

#python code for isFull in QueueMAX = 6intArray = [None] * MAXfront = 0rear = -1itemCount = 0def isFull():    return itemCount == MAXdef insert(data):    global rear, itemCount    if not isFull():        if rear == MAX-1:            rear = -1        rear += 1        intArray[rear] = data        itemCount += 1#inserting 5 items into the Queueinsert(3)insert(5)insert(9)insert(1)insert(12)insert(15)print("Queue: ", end="")for i in range(MAX):    print(intArray[i], end=" ")print()if isFull():    print("Queue is full!")

Output

Queue: 3 5 9 1 12 15 Queue is full!

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;bool isEmpty(){   return itemCount == 0;}int main(){   int i;   printf("Queue: ");   for(i = 0; i < MAX; i++)      printf("%d ", intArray[i]);   printf("\n");   if(isEmpty()) {      printf("Queue is Empty!\n");   }}

Output

Queue: 0 0 0 0 0 0 Queue is Empty!

#include <iostream>#include <string>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;bool isEmpty(){   return itemCount == 0;}int main(){   int i;   printf("Queue: ");   for(i = 0; i < MAX; i++)      printf("%d ", intArray[i]);   printf("\n");   if(isEmpty()) {      printf("Queue is Empty!\n");   }}

Output

Queue: 0 0 0 0 0 0 Queue is Empty!

import java.io.*;public class QueueExample {   private int intArray[];   private int front;   private int rear;   private int itemCount;   private int MAX;   QueueExample(int size) {      intArray = new int[size];      front = 0;      rear = -1;      MAX = size;      itemCount = 0;   }   public boolean isEmpty() {      return itemCount == 0;   }   public static void main (String[] args) {      QueueExample q = new QueueExample(5);      System.out.println("Stack Empty? " + q.isEmpty());   }}

Output

Stack Empty? true

#python code for isFull in QueueMAX = 6intArray = [None] * MAXfront = 0rear = -1itemCount = 0def isEmpty():    return itemCount == 0print("Queue: ", end="")for i in range(MAX):    print(intArray[i], end=" ")print()if isEmpty():    print("Queue is empty!")

Output

Queue: None None None None None None Queue is empty!

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <stdbool.h>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;int peek(){   return intArray[front];}bool isEmpty(){   return itemCount == 0;}bool isFull(){   return itemCount == MAX;}int size(){   return itemCount;}void insert(int data){   if(!isFull()) {      if(rear == MAX-1) {         rear = -1;      }      intArray[++rear] = data;      itemCount++;   }}int removeData(){   int data = intArray[front++];   if(front == MAX) {      front = 0;   }   itemCount--;   return data;}int main(){      /* insert 5 items */   insert(3);   insert(5);   insert(9);   insert(1);   insert(12);   // front : 0   // rear : 4   // ------------------   // index : 0 1 2 3 4   // ------------------   // queue : 3 5 9 1 12   insert(15);   // front : 0   // rear : 5   // ---------------------   // index : 0 1 2 3 4 5   // ---------------------   // queue : 3 5 9 1 12 15   if(isFull()) {      printf("Queue is full!\n");   }   // remove one item   int num = removeData();   printf("Element removed: %d\n",num);   // front : 1   // rear : 5   // -------------------   // index : 1 2 3 4 5   // -------------------   // queue : 5 9 1 12 15   // insert more items   insert(16);      // front : 1   // rear : -1   // ----------------------   // index : 0 1 2 3 4 5   // ----------------------   // queue : 16 5 9 1 12 15   // As queue is full, elements will not be inserted.   insert(17);   insert(18);   // ----------------------   // index : 0 1 2 3 4 5   // ----------------------   // queue : 16 5 9 1 12 15   printf("Element at front: %d\n",peek());   printf("----------------------\n");   printf("index : 5 4 3 2 1 0\n");   printf("----------------------\n");   printf("Queue: ");   while(!isEmpty()) {      int n = removeData();      printf("%d ",n);   }}

Output

Queue is full!Element removed: 3Element at front: 5----------------------index : 5 4 3 2 1 0----------------------Queue: 5 9 1 12 15 16

#include <iostream>#include <string>#define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;int peek(){   return intArray[front];}bool isEmpty(){   return itemCount == 0;}bool isFull(){   return itemCount == MAX;}int size(){   return itemCount;}void insert(int data){   if(!isFull()) {      if(rear == MAX-1) {         rear = -1;      }      intArray[++rear] = data;      itemCount++;   }}int removeData(){   int data = intArray[front++];   if(front == MAX) {      front = 0;   }   itemCount--;   return data;}int main(){      /* insert 5 items */   insert(3);   insert(5);   insert(9);   insert(1);   insert(12);   // front : 0   // rear : 4   // ------------------   // index : 0 1 2 3 4   // ------------------   // queue : 3 5 9 1 12   insert(15);   // front : 0   // rear : 5   // ---------------------   // index : 0 1 2 3 4 5   // ---------------------   // queue : 3 5 9 1 12 15   if(isFull()) {      printf("Queue is full!\n");   }   // remove one item   int num = removeData();   printf("Element removed: %d\n",num);   // front : 1   // rear : 5   // -------------------   // index : 1 2 3 4 5   // -------------------   // queue : 5 9 1 12 15   // insert more items   insert(16);   // front : 1   // rear : -1   // ----------------------   // index : 0 1 2 3 4 5   // ----------------------   // queue : 16 5 9 1 12 15   // As queue is full, elements will not be inserted.   insert(17);   insert(18);   // ----------------------   // index : 0 1 2 3 4 5   // ----------------------   // queue : 16 5 9 1 12 15   printf("Element at front: %d\n",peek());   printf("----------------------\n");   printf("index : 5 4 3 2 1 0\n");   printf("----------------------\n");   printf("Queue: ");   while(!isEmpty()) {      int n = removeData();      printf("%d ",n);   }}

Output

Queue is full!Element removed: 3Element at front: 5----------------------index : 5 4 3 2 1 0----------------------Queue: 5 9 1 12 15 16

import java.util.LinkedList;import java.util.Queue;public class QueueExample {   public static void main(String[] args) {      Queue<Integer> q = new LinkedList<>();      q.add(6);      q.add(1);      q.add(8);      q.add(4);      q.add(7);      System.out.println("The queue is: " + q);      int n = q.remove();      System.out.println("The element deleted is: " + n);      System.out.println("Queue after deletion: " + q);      int size = q.size();      System.out.println("Size of the queue is: " + size);   }}

Output

The queue is: [6, 1, 8, 4, 7]The element deleted is: 6Queue after deletion: [1, 8, 4, 7]Size of the queue is: 4

class Queue:   def __init__(self):      self.queue = list()   def addtoqueue(self,data):   # Insert method to add element      if data not in self.queue:         self.queue.insert(0,data)         return True      return False   def size(self):      return len(self.queue)   def removefromqueue(self):      if len(self.queue)>0:         return self.queue.pop()      return ("Queue is empty")q = Queue()q.addtoqueue("36")q.addtoqueue("24")q.addtoqueue("48")q.addtoqueue("12")q.addtoqueue("66")print("size of the queue: ",q.size())print("Element deleted from queue: ",q.removefromqueue())print("size of the queue after deletion: ",q.size())

Output

size of the queue:  5Element deleted from queue:  36size of the queue after deletion:  4

#include <stdio.h>#include<stdlib.h>#include <stdlib.h>#define V 5 // Maximum number of vertices in the graphstruct graph {       // declaring graph data structure   struct vertex *point[V];};struct vertex {       // declaring vertices   int end;   struct vertex *next;};struct Edge {       // declaring edges   int end, start;};struct graph *create_graph (struct Edge edges[], int x){   int i;   struct graph *graph = (struct graph *) malloc (sizeof (struct graph));   for (i = 0; i < V; i++) {      graph->point[i] = NULL;   }   for (i = 0; i < x; i++) {      int start = edges[i].start;      int end = edges[i].end;      struct vertex *v = (struct vertex *) malloc (sizeof (struct vertex));      v->end = end;      v->next = graph->point[start];      graph->point[start] = v;   }   return graph;}int main (){   struct Edge edges[] = { {0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 4}, {2, 4}, {2, 3}, {3, 1} };   int n = sizeof (edges) / sizeof (edges[0]);   struct graph *graph = create_graph (edges, n);   int i;   for (i = 0; i < V; i++) {      struct vertex *ptr = graph->point[i];      while (ptr != NULL) {         printf ("(%d -> %d)\t", i, ptr->end);         ptr = ptr->next;      }      printf ("\n");   }   return 0;}

Output

(1 -> 3)(1 -> 0)(2 -> 1)(2 -> 0)(3 -> 2)(3 -> 0)(4 -> 2)(4 -> 1)

#include <bits/stdc++.h>using namespace std;#define V 5 // Maximum number of vertices in the graphstruct graph {       // declaring graph data structure   struct vertex *point[V];};struct vertex {       // declaring vertices   int end;   struct vertex *next;};struct Edge {       // declaring edges   int end, start;};struct graph *create_graph (struct Edge edges[], int x){   int i;   struct graph *graph = (struct graph *) malloc (sizeof (struct graph));   for (i = 0; i < V; i++) {      graph->point[i] = NULL;   }   for (i = 0; i < x; i++) {      int start = edges[i].start;      int end = edges[i].end;      struct vertex *v = (struct vertex *) malloc (sizeof (struct vertex));      v->end = end;      v->next = graph->point[start];      graph->point[start] = v;   }   return graph;}int main (){   struct Edge edges[] = { {0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 4}, {2, 4}, {2, 3}, {3, 1} };   int n = sizeof (edges) / sizeof (edges[0]);   struct graph *graph = create_graph (edges, n);   int i;   for (i = 0; i < V; i++) {      struct vertex *ptr = graph->point[i];      while (ptr != NULL) {         cout << "(" << i << " -> " << ptr->end << ")\t";         ptr = ptr->next;      }      cout << endl;   }   return 0;}

Output

(1 -> 3)(1 -> 0)(2 -> 1)(2 -> 0)(3 -> 2)(3 -> 0)(4 -> 2)(4 -> 1)

import java.util.*;//class to store edges of the graphclass Edge {      int src, dest;   Edge(int src, int dest) {      this.src = src;      this.dest = dest;   }}// Graph classpublic class Graph {      // node of adjacency list   static class vertex {      int v;      vertex(int v) {        this.v = v;      }   };   // define adjacency list to represent the graph   List<List<vertex>> adj_list = new ArrayList<>();      //Graph Constructor   public Graph(List<Edge> edges){            // adjacency list memory allocation      for (int i = 0; i < edges.size(); i++)      adj_list.add(i, new ArrayList<>());            // add edges to the graph      for (Edge e : edges){                // allocate new node in adjacency List from src to dest        adj_list.get(e.src).add(new vertex(e.dest));      }   }   public static void main (String[] args) {            // define edges of the graph      List<Edge> edges = Arrays.asList(new Edge(0, 1),new Edge(0, 2),      new Edge(0, 3),new Edge(1, 2), new Edge(1, 4),      new Edge(2, 4), new Edge(2, 3),new Edge(3, 1));            // call graph class Constructor to construct a graph      Graph graph = new Graph(edges);            // print the graph as an adjacency list      int src = 0;      int lsize = graph.adj_list.size();      System.out.println("The graph created is:");      while (src < lsize) {               //traverse through the adjacency list and print the edges         for (vertex edge : graph.adj_list.get(src)) {            System.out.print(src + " -> " + edge.v + "\t");         }         System.out.println();         src++;      }   }}

Output

The graph created is:0 -> 10 -> 20 -> 31 -> 21 -> 42 -> 42 -> 33 -> 1

#Python code for Graph Data StrutureV = 5#Maximum number of vertices in th graph#Declaring verticesclass Vertex:    def __init__(self, end):        self.end = end        self.next = None#Declaring Edgesclass Edge:    def __init__(self, start, end):        self.start = start        self.end = end#Declaring graph data structureclass Graph:    def __init__(self):        self.point = [None] * Vdef create_graph(edges, x):    graph = Graph()    for i in range(V):        graph.point[i] = None    for i in range(x):        start = edges[i].start        end = edges[i].end        v = Vertex(end)        v.next = graph.point[start]        graph.point[start] = v    return graphedges = [Edge(0, 1), Edge(0, 2), Edge(0, 3), Edge(1, 2), Edge(1, 4), Edge(2, 4), Edge(2, 3), Edge(3, 1)]n = len(edges)graph = create_graph(edges, n)#Rangefor i in range(V):    ptr = graph.point[i]    while ptr is not None:        print("({} -> {})".format(i, ptr.end), end="\t")        ptr = ptr.next    print()

Output

(0 -> 3)(0 -> 2)(0 -> 1)(1 -> 4)(1 -> 2)(2 -> 3)(2 -> 4)(3 -> 1)

#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#define MAX 5struct Vertex {   char label;   bool visited;};//stack variablesint stack[MAX]; int top = -1; //graph variables//array of verticesstruct Vertex* lstVertices[MAX];//adjacency matrixint adjMatrix[MAX][MAX];//vertex countint vertexCount = 0;//stack functionsvoid push(int item) {    stack[++top] = item; } int pop() {    return stack[top--]; } int peek() {   return stack[top];}bool isStackEmpty() {   return top == -1;}//graph functions//add vertex to the vertex listvoid addVertex(char label) {   struct Vertex* vertex = (struct Vertex*) malloc(sizeof(struct Vertex));   vertex->label = label;     vertex->visited = false;        lstVertices[vertexCount++] = vertex;}//add edge to edge arrayvoid addEdge(int start,int end) {   adjMatrix[start][end] = 1;   adjMatrix[end][start] = 1;}//display the vertexvoid displayVertex(int vertexIndex) {   printf("%c ",lstVertices[vertexIndex]->label);}       //get the adjacent unvisited vertexint getAdjUnvisitedVertex(int vertexIndex) {   int i;   for(i = 0; i < vertexCount; i++) {      if(adjMatrix[vertexIndex][i] == 1 && lstVertices[i]->visited == false) {         return i;      }   }   return -1;}void depthFirstSearch() {   int i;   //mark first node as visited   lstVertices[0]->visited = true;   //display the vertex   displayVertex(0);      //push vertex index in stack   push(0);   while(!isStackEmpty()) {      //get the unvisited vertex of vertex which is at top of the stack      int unvisitedVertex = getAdjUnvisitedVertex(peek());      //no adjacent vertex found      if(unvisitedVertex == -1) {         pop();      } else {         lstVertices[unvisitedVertex]->visited = true;         displayVertex(unvisitedVertex);         push(unvisitedVertex);      }   }   //stack is empty, search is complete, reset the visited flag           for(i = 0;i < vertexCount;i++) {      lstVertices[i]->visited = false;   }        }int main() {   int i, j;   for(i = 0; i < MAX; i++) {   // set adjacency      for(j = 0; j < MAX; j++) // matrix to 0         adjMatrix[i][j] = 0;   }   addVertex('S');   // 0   addVertex('A');   // 1   addVertex('B');   // 2   addVertex('C');   // 3   addVertex('D');   // 4   addEdge(0, 1);    // S - A   addEdge(0, 2);    // S - B   addEdge(0, 3);    // S - C   addEdge(1, 4);    // A - D   addEdge(2, 4);    // B - D   addEdge(3, 4);    // C - D   printf("Depth First Search: ");   depthFirstSearch();    return 0;   }

Output

Depth First Search: S A D B C

//C++ code for Depth First Traversal#include <iostream>#include <array>#include <vector>constexpr int MAX = 5;struct Vertex {   char label;   bool visited;};//stack variablesstd::array<int, MAX> stack;int top = -1;//graph variables//array of vertices std::array<Vertex*, MAX> lstVertices;//adjacency matrixstd::array<std::array<int, MAX>, MAX> adjMatrix;//vertex countint vertexCount = 0;//stack functionsvoid push(int item) {   stack[++top] = item;}int pop() {   return stack[top--];}int peek() {   return stack[top];}bool isStackEmpty() {   return top == -1;}//graph functions//add vertex to the vertex listvoid addVertex(char label) {   Vertex* vertex = new Vertex;   vertex->label = label;   vertex->visited = false;   lstVertices[vertexCount++] = vertex;}//add edge to edge arrayvoid addEdge(int start, int end) {   adjMatrix[start][end] = 1;   adjMatrix[end][start] = 1;}//display the vertexvoid displayVertex(int vertexIndex) {   std::cout << lstVertices[vertexIndex]->label << " ";}//get the adjacent unvisited vertexint getAdjUnvisitedVertex(int vertexIndex) {   for (int i = 0; i < vertexCount; i++) {      if (adjMatrix[vertexIndex][i] == 1 && !lstVertices[i]->visited) {         return i;      }   }   return -1;}//mark first node as visitedvoid depthFirstSearch() {   lstVertices[0]->visited = true;   //display the vertex   displayVertex(0);   //push vertex index in stack   push(0);   while (!isStackEmpty()) {       //get the unvisited vertex of vertex which is at top of the stack      int unvisitedVertex = getAdjUnvisitedVertex(peek());      //no adjacent vertex found      if (unvisitedVertex == -1) {         pop();      } else {         lstVertices[unvisitedVertex]->visited = true;         displayVertex(unvisitedVertex);         push(unvisitedVertex);      }   }   //stack is empty, search is complete, reset the visited flag   for (int i = 0; i < vertexCount; i++) {      lstVertices[i]->visited = false;   }}int main() {   for (int i = 0; i < MAX; i++) {   //set adjacency      for (int j = 0; j < MAX; j++) {    // matrix to 0         adjMatrix[i][j] = 0;      }   }   addVertex('S');   addVertex('A');   addVertex('B');   addVertex('C');   addVertex('D');   addEdge(0, 1);   addEdge(0, 2);   addEdge(0, 3);   addEdge(1, 4);   addEdge(2, 4);   addEdge(3, 4);   std::cout << "Depth First Search: ";   depthFirstSearch();   return 0;}

Output

Depth First Search: S A D B C

//Java program for Depth First Traversalpublic class DepthFirstSearch {    private static final int MAX = 5;    private static class Vertex {        char label;        boolean visited;    }    private static int[] stack = new int[MAX];    private static int top = -1;    private static Vertex[] lstVertices = new Vertex[MAX];    private static int[][] adjMatrix = new int[MAX][MAX];    private static int vertexCount = 0;    private static void push(int item) {        stack[++top] = item;    }    private static int pop() {        return stack[top--];    }    private static int peek() {        return stack[top];    }    private static boolean isStackEmpty() {        return top == -1;    }    private static void addVertex(char label) {        Vertex vertex = new Vertex();        vertex.label = label;        vertex.visited = false;        lstVertices[vertexCount++] = vertex;    }    private static void addEdge(int start, int end) {        adjMatrix[start][end] = 1;        adjMatrix[end][start] = 1;    }    private static void displayVertex(int vertexIndex) {        System.out.print(lstVertices[vertexIndex].label + " ");    }    private static int getAdjUnvisitedVertex(int vertexIndex) {        for (int i = 0; i < vertexCount; i++) {            if (adjMatrix[vertexIndex][i] == 1 && !lstVertices[i].visited) {                return i;            }        }        return -1;    }    private static void depthFirstSearch() {        lstVertices[0].visited = true;        displayVertex(0);        push(0);        while (!isStackEmpty()) {            int unvisitedVertex = getAdjUnvisitedVertex(peek());            if (unvisitedVertex == -1) {                pop();            } else {                lstVertices[unvisitedVertex].visited = true;                displayVertex(unvisitedVertex);                push(unvisitedVertex);            }        }        for (int i = 0; i < vertexCount; i++) {            lstVertices[i].visited = false;        }    }    public static void main(String[] args) {        for (int i = 0; i < MAX; i++) {            for (int j = 0; j < MAX; j++) {                adjMatrix[i][j] = 0;            }        }        addVertex('S');   // 0        addVertex('A');   // 1        addVertex('B');   // 2        addVertex('C');   // 3        addVertex('D');   // 4        addEdge(0, 1);    // S - A        addEdge(0, 2);    // S - B        addEdge(0, 3);    // S - C        addEdge(1, 4);    // A - D        addEdge(2, 4);    // B - D        addEdge(3, 4);    // C - D        System.out.print("Depth First Search: ");        depthFirstSearch();    }}

Output

Depth First Search: S A D B C

#Python program for Depth First TraversalMAX = 5class Vertex:    def __init__(self, label):        self.label = label        self.visited = False#stack variablesstack = []top = -1#graph variables#array of verticeslstVertices = [None] * MAX#adjacency matrixadjMatrix = [[0] * MAX for _ in range(MAX)]#vertex countvertexCount = 0#stack functionsdef push(item):    global top    top += 1    stack.append(item)def pop():    global top    item = stack[top]    del stack[top]    top -= 1    return itemdef peek():    return stack[top]def isStackEmpty():    return top == -1#graph functions#add vertex to the vertex listdef addVertex(label):    global vertexCount    vertex = Vertex(label)    lstVertices[vertexCount] = vertex    vertexCount += 1#add edge to edge arraydef addEdge(start, end):    adjMatrix[start][end] = 1    adjMatrix[end][start] = 1#Display the Vertexdef displayVertex(vertexIndex):    print(lstVertices[vertexIndex].label, end=' ')def getAdjUnvisitedVertex(vertexIndex):    for i in range(vertexCount):        if adjMatrix[vertexIndex][i] == 1 and not lstVertices[i].visited:            return i    return -1def depthFirstSearch():    lstVertices[0].visited = True    displayVertex(0)    push(0)    while not isStackEmpty():        unvisitedVertex = getAdjUnvisitedVertex(peek())        if unvisitedVertex == -1:            pop()        else:            lstVertices[unvisitedVertex].visited = True            displayVertex(unvisitedVertex)            push(unvisitedVertex)    for i in range(vertexCount):        lstVertices[i].visited = Falsefor i in range(MAX):    for j in range(MAX):        adjMatrix[i][j] = 0addVertex('S')   # 0addVertex('A')   # 1addVertex('B')   # 2addVertex('C')   # 3addVertex('D')   # 4addEdge(0, 1)    # S - AaddEdge(0, 2)    # S - BaddEdge(0, 3)    # S - CaddEdge(1, 4)    # A - DaddEdge(2, 4)    # B - DaddEdge(3, 4)    # C - Dprint("Depth First Search:", end=' ')depthFirstSearch()

Output

Depth First Search: S A D B C

#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#define MAX 5struct Vertex {   char label;   bool visited;};//queue variablesint queue[MAX];int rear = -1;int front = 0;int queueItemCount = 0;//graph variables//array of verticesstruct Vertex* lstVertices[MAX];//adjacency matrixint adjMatrix[MAX][MAX];//vertex countint vertexCount = 0;//queue functionsvoid insert(int data) {   queue[++rear] = data;   queueItemCount++;}int removeData() {   queueItemCount--;   return queue[front++]; }bool isQueueEmpty() {   return queueItemCount == 0;}//graph functions//add vertex to the vertex listvoid addVertex(char label) {   struct Vertex* vertex = (struct Vertex*) malloc(sizeof(struct Vertex));   vertex->label = label;     vertex->visited = false;        lstVertices[vertexCount++] = vertex;}//add edge to edge arrayvoid addEdge(int start,int end) {   adjMatrix[start][end] = 1;   adjMatrix[end][start] = 1;}//display the vertexvoid displayVertex(int vertexIndex) {   printf("%c ",lstVertices[vertexIndex]->label);}       //get the adjacent unvisited vertexint getAdjUnvisitedVertex(int vertexIndex) {   int i;   for(i = 0; i<vertexCount; i++) {      if(adjMatrix[vertexIndex][i] == 1 && lstVertices[i]->visited == false)         return i;   }   return -1;}void breadthFirstSearch() {   int i;   //mark first node as visited   lstVertices[0]->visited = true;   //display the vertex   displayVertex(0);      //insert vertex index in queue   insert(0);   int unvisitedVertex;   while(!isQueueEmpty()) {      //get the unvisited vertex of vertex which is at front of the queue      int tempVertex = removeData();         //no adjacent vertex found      while((unvisitedVertex = getAdjUnvisitedVertex(tempVertex)) != -1) {             lstVertices[unvisitedVertex]->visited = true;         displayVertex(unvisitedVertex);         insert(unvisitedVertex);                     }   }      //queue is empty, search is complete, reset the visited flag           for(i = 0;i<vertexCount;i++) {      lstVertices[i]->visited = false;   }    }int main() {   int i, j;   for(i = 0; i<MAX; i++) { // set adjacency       for(j = 0; j<MAX; j++) // matrix to 0         adjMatrix[i][j] = 0;   }   addVertex('S');   // 0   addVertex('A');   // 1   addVertex('B');   // 2   addVertex('C');   // 3   addVertex('D');   // 4   addEdge(0, 1);    // S - A   addEdge(0, 2);    // S - B   addEdge(0, 3);    // S - C   addEdge(1, 4);    // A - D   addEdge(2, 4);    // B - D   addEdge(3, 4);    // C - D   printf("\nBreadth First Search: ");   breadthFirstSearch();   return 0;}

Output

Breadth First Search: S A B C D

//C++ code for Breadth First Traversal#include <iostream>#include <stdlib.h>#include <stdbool.h>#define MAX 5struct Vertex {   char label;   bool visited;};//queue variablesint queue[MAX];int rear = -1;int front = 0;int queueItemCount = 0;//graph variables//array of verticesstruct Vertex* lstVertices[MAX];//adjacency matrixint adjMatrix[MAX][MAX];//vertex countint vertexCount = 0;//queue functionsvoid insert(int data) {   queue[++rear] = data;   queueItemCount++;}int removeData() {   queueItemCount--;   return queue[front++]; }bool isQueueEmpty() {   return queueItemCount == 0;}//graph functions//add vertex to the vertex listvoid addVertex(char label) {   struct Vertex* vertex = (struct Vertex*) malloc(sizeof(struct Vertex));   vertex->label = label;     vertex->visited = false;        lstVertices[vertexCount++] = vertex;}//add edge to edge arrayvoid addEdge(int start,int end) {   adjMatrix[start][end] = 1;   adjMatrix[end][start] = 1;}//display the vertexvoid displayVertex(int vertexIndex) {   std::cout << lstVertices[vertexIndex]->label << " ";}       //get the adjacent unvisited vertexint getAdjUnvisitedVertex(int vertexIndex) {   int i;   for(i = 0; i<vertexCount; i++) {      if(adjMatrix[vertexIndex][i] == 1 && lstVertices[i]->visited == false)         return i;   }   return -1;}void breadthFirstSearch() {   int i;   //mark first node as visited   lstVertices[0]->visited = true;  //display the vertex   displayVertex(0);      //insert vertex index in queue   insert(0);   int unvisitedVertex;   while(!isQueueEmpty()) {      //get the unvisited vertex of vertex which is at front of the queue      int tempVertex = removeData();         //no adjacent vertex found      while((unvisitedVertex = getAdjUnvisitedVertex(tempVertex)) != -1) {             lstVertices[unvisitedVertex]->visited = true;         displayVertex(unvisitedVertex);         insert(unvisitedVertex);                     }   }      //queue is empty, search is complete, reset the visited flag           for(i = 0;i<vertexCount;i++) {      lstVertices[i]->visited = false;   }    }int main() {   int i, j;   for(i = 0; i<MAX; i++) { // set adjacency       for(j = 0; j<MAX; j++) // matrix to 0         adjMatrix[i][j] = 0;   }   addVertex('S');   // 0   addVertex('A');   // 1   addVertex('B');   // 2   addVertex('C');   // 3   addVertex('D');   // 4   addEdge(0, 1);    // S - A   addEdge(0, 2);    // S - B   addEdge(0, 3);    // S - C   addEdge(1, 4);    // A - D   addEdge(2, 4);    // B - D   addEdge(3, 4);    // C - D   std::cout << "Breadth First Search: ";   breadthFirstSearch();   return 0;}

Output

Breadth First Search: S A B C D

//Java code for Breadth First Traversalimport java.util.LinkedList;import java.util.Queue;class Vertex {    char label;    boolean visited;    public Vertex(char label) {        this.label = label;        visited = false;    }}public class Graph {    private static final int MAX = 5;    private Vertex[] lstVertices;    private int[][] adjMatrix;    private int vertexCount;    public Graph() {        lstVertices = new Vertex[MAX];        adjMatrix = new int[MAX][MAX];        vertexCount = 0;    }    private void addVertex(char label) {        Vertex vertex = new Vertex(label);        lstVertices[vertexCount++] = vertex;    }    private void addEdge(int start, int end) {        adjMatrix[start][end] = 1;        adjMatrix[end][start] = 1;    }    private void displayVertex(int vertexIndex) {        System.out.print(lstVertices[vertexIndex].label + " ");    }    private int getAdjUnvisitedVertex(int vertexIndex) {        for (int i = 0; i < vertexCount; i++) {            if (adjMatrix[vertexIndex][i] == 1 && !lstVertices[i].visited)                return i;        }        return -1;    }    private void breadthFirstSearch() {        lstVertices[0].visited = true;        displayVertex(0);        Queue<Integer> queue = new LinkedList<>();        queue.add(0);        while (!queue.isEmpty()) {            int tempVertex = queue.poll();            int unvisitedVertex;            while ((unvisitedVertex = getAdjUnvisitedVertex(tempVertex)) != -1) {                lstVertices[unvisitedVertex].visited = true;                displayVertex(unvisitedVertex);                queue.add(unvisitedVertex);            }        }        // Reset the visited flag        for (int i = 0; i < vertexCount; i++) {            lstVertices[i].visited = false;        }    }    public static void main(String[] args) {        Graph graph = new Graph();        for (int i = 0; i < MAX; i++) {            for (int j = 0; j < MAX; j++)                graph.adjMatrix[i][j] = 0;        }        graph.addVertex('S');   // 0        graph.addVertex('A');   // 1        graph.addVertex('B');   // 2        graph.addVertex('C');   // 3        graph.addVertex('D');   // 4        graph.addEdge(0, 1);    // S - A        graph.addEdge(0, 2);    // S - B        graph.addEdge(0, 3);    // S - C        graph.addEdge(1, 4);    // A - D        graph.addEdge(2, 4);    // B - D        graph.addEdge(3, 4);    // C - D        System.out.print("Breadth First Search: ");        graph.breadthFirstSearch();    }}

Output

Breadth First Search: S A B C D

#Python program for Breadth First Search# defining MAX 5MAX = 5class Vertex:   def __init__(self, label):      self.label = label      self.visited = False# queue variablesqueue = [0] * MAXrear = -1front = 0queueItemCount = 0# graph variables#array of verticeslstVertices = [None] * MAX#adjacency matrixadjMatrix = [[0] * MAX for _ in range(MAX)]#vertex countvertexCount = 0# queue functionsdef insert(data):   global rear, queueItemCount   rear += 1   queue[rear] = data   queueItemCount += 1def removeData():   global front, queueItemCount   queueItemCount -= 1   data = queue[front]   front += 1   return datadef isQueueEmpty():   return queueItemCount == 0# graph functions#add vertex to the vertex listdef addVertex(label):   global vertexCount   vertex = Vertex(label)   lstVertices[vertexCount] = vertex   vertexCount += 1#add edge to edge arraydef addEdge(start, end):   adjMatrix[start][end] = 1   adjMatrix[end][start] = 1#Display the vertexdef displayVertex(vertexIndex):   print(lstVertices[vertexIndex].label, end=" ")#Get the adjacent unvisited vertexdef getAdjUnvisitedVertex(vertexIndex):   for i in range(vertexCount):      if adjMatrix[vertexIndex][i] == 1 and not lstVertices[i].visited:         return i   return -1def breadthFirstSearch():    #mark first node as visited   lstVertices[0].visited = True   #Display the vertex   displayVertex(0)   #insert vertex index in queue   insert(0)   while not isQueueEmpty():    #get the unvisited vertex of vertex which is at front of the queue      tempVertex = removeData()           #no adjacent vertex found      unvisitedVertex = getAdjUnvisitedVertex(tempVertex)      while unvisitedVertex != -1:         lstVertices[unvisitedVertex].visited = True         displayVertex(unvisitedVertex)         insert(unvisitedVertex)         unvisitedVertex = getAdjUnvisitedVertex(tempVertex)         #queue is empty, search is complete, reset the visited flag    for i in range(vertexCount):      lstVertices[i].visited = False# main functionif __name__ == "__main__":    #set adjacency   for i in range(MAX):       #matrix to 0       for j in range(MAX):         adjMatrix[i][j] = 0   addVertex('S')   addVertex('A')   addVertex('B')   addVertex('C')   addVertex('D')   addEdge(0, 1)   addEdge(0, 2)   addEdge(0, 3)   addEdge(1, 4)   addEdge(2, 4)   addEdge(3, 4)   print("Breadth First Search: ", end="")   breadthFirstSearch()

Output

Breadth First Search: S A B C D

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild;   struct node *rightChild;};struct node *root = NULL;void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;   //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;         //go to left of the tree         if(data < parent->data) {            current = current->leftChild;            //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;            //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}void inorder_traversal(struct node* root){   if(root != NULL) {      inorder_traversal(root->leftChild);      printf("%d ",root->data);      inorder_traversal(root->rightChild);   }}int main(){   int i;   int array[7] = { 27, 14, 35, 10, 19, 31, 42 };   for(i = 0; i < 7; i++)      insert(array[i]);   printf("\nInorder traversal: ");   inorder_traversal(root);   return 0;}

Output

Inorder traversal: 10 14 19 27 31 35 42

#include <iostream>struct node {   int data;   struct node *leftChild;   struct node *rightChild;};struct node *root = NULL;void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;   //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;         //go to left of the tree         if(data < parent->data) {            current = current->leftChild;            //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;            //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}void inorder_traversal(struct node* root){   if(root != NULL) {      inorder_traversal(root->leftChild);      printf("%d ",root->data);      inorder_traversal(root->rightChild);   }}int main(){   int i;   int array[7] = { 27, 14, 35, 10, 19, 31, 42 };   for(i = 0; i < 7; i++)      insert(array[i]);   printf("\nInorder traversal: ");   inorder_traversal(root);   return 0;}

Output

Inorder traversal: 10 14 19 27 31 35 42

class Node {   int data;   Node leftChild;   Node rightChild;   public Node(int key) {      data = key;      leftChild = rightChild = null;   }}public class TreeDataStructure {   Node root = null;   void inorder_traversal(Node node) {      if(node != null) {         inorder_traversal(node.leftChild);         System.out.print(node.data + " ");         inorder_traversal(node.rightChild);      }   }   public static void main(String args[]) {      TreeDataStructure tree = new TreeDataStructure();      tree.root = new Node(27);      tree.root.leftChild = new Node(12);      tree.root.rightChild = new Node(3);      tree.root.leftChild.leftChild = new Node(44);      tree.root.leftChild.rightChild = new Node(17);      tree.root.rightChild.leftChild = new Node(56);      System.out.println("\nInorder traversal: ");      tree.inorder_traversal(tree.root);   }}

Output

Inorder traversal: 44 12 17 27 56 3

class Node:   def __init__(self, key):      self.leftChild = None      self.rightChild = None      self.data = key# Create a function to perform inorder tree traversaldef InorderTraversal(root):   if root:      InorderTraversal(root.leftChild)      print(root.data)      InorderTraversal(root.rightChild)# Main classif __name__ == "__main__":   root = Node(3)   root.leftChild = Node(26)   root.rightChild = Node(42)   root.leftChild.leftChild = Node(54)   root.leftChild.rightChild = Node(65)   root.rightChild.leftChild = Node(12)   # Function call   print("\nInorder traversal of binary tree is")   InorderTraversal(root)

Output

Inorder traversal of binary tree is54266531242

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild;   struct node *rightChild;};struct node *root = NULL;void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;   //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;         //go to left of the tree         if(data < parent->data) {            current = current->leftChild;            //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;            //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}void pre_order_traversal(struct node* root){   if(root != NULL) {      printf("%d ",root->data);      pre_order_traversal(root->leftChild);      pre_order_traversal(root->rightChild);   }}int main(){   int i;   int array[7] = { 27, 14, 35, 10, 19, 31, 42 };   for(i = 0; i < 7; i++)      insert(array[i]);   printf("\nPreorder traversal: ");   pre_order_traversal(root);   return 0;}

Output

Preorder traversal: 27 14 10 19 35 31 42

#include <iostream>struct node {   int data;   struct node *leftChild;   struct node *rightChild;};struct node *root = NULL;void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;   //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;         //go to left of the tree         if(data < parent->data) {            current = current->leftChild;            //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;            //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}void pre_order_traversal(struct node* root){   if(root != NULL) {      printf("%d ",root->data);      pre_order_traversal(root->leftChild);      pre_order_traversal(root->rightChild);   }}int main(){   int i;   int array[7] = { 27, 14, 35, 10, 19, 31, 42 };   for(i = 0; i < 7; i++)      insert(array[i]);   printf("\nPreorder traversal: ");   pre_order_traversal(root);   return 0;}

Output

Preorder traversal: 27 14 10 19 35 31 42

class Node {   int data;   Node leftChild;   Node rightChild;   public Node(int key) {      data = key;      leftChild = rightChild = null;   }}public class TreeDataStructure {   Node root = null;   void pre_order_traversal(Node node) {      if(node != null) {         System.out.print(node.data + " ");         pre_order_traversal(node.leftChild);         pre_order_traversal(node.rightChild);      }   }   public static void main(String args[]) {      TreeDataStructure tree = new TreeDataStructure();      tree.root = new Node(27);      tree.root.leftChild = new Node(12);      tree.root.rightChild = new Node(3);      tree.root.leftChild.leftChild = new Node(44);      tree.root.leftChild.rightChild = new Node(17);      tree.root.rightChild.leftChild = new Node(56);      System.out.println("\nPreorder traversal: ");      tree.pre_order_traversal(tree.root);   }}

Output

Preorder traversal: 27 12 44 17 3 56

class Node:   def __init__(self, key):      self.leftChild = None      self.rightChild = None      self.data = key# Create a function to perform postorder tree traversaldef PreorderTraversal(root):   if root:      print(root.data)      PreorderTraversal(root.leftChild)      PreorderTraversal(root.rightChild)# Main classif __name__ == "__main__":   root = Node(3)   root.leftChild = Node(26)   root.rightChild = Node(42)   root.leftChild.leftChild = Node(54)   root.leftChild.rightChild = Node(65)   root.rightChild.leftChild = Node(12)   print("\nPreorder traversal of binary tree is")   PreorderTraversal(root)

Output

Preorder traversal of binary tree is32654654212

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild;   struct node *rightChild;};struct node *root = NULL;void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;   //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;         //go to left of the tree         if(data < parent->data) {            current = current->leftChild;            //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;            //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}void post_order_traversal(struct node* root){   if(root != NULL) {      post_order_traversal(root->leftChild);      post_order_traversal(root->rightChild);      printf("%d ", root->data);   }}int main(){   int i;   int array[7] = { 27, 14, 35, 10, 19, 31, 42 };   for(i = 0; i < 7; i++)      insert(array[i]);   printf("\nPost order traversal: ");   post_order_traversal(root);   return 0;}

Output

Post order traversal: 10 19 14 31 42 35 27

#include <iostream>struct node {   int data;   struct node *leftChild;   struct node *rightChild;};struct node *root = NULL;void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;   //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;         //go to left of the tree         if(data < parent->data) {            current = current->leftChild;            //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;            //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}void post_order_traversal(struct node* root){   if(root != NULL) {      post_order_traversal(root->leftChild);      post_order_traversal(root->rightChild);      printf("%d ", root->data);   }}int main(){   int i;   int array[7] = { 27, 14, 35, 10, 19, 31, 42 };   for(i = 0; i < 7; i++)      insert(array[i]);   printf("\nPost order traversal: ");   post_order_traversal(root);   return 0;}

Output

Post order traversal: 10 19 14 31 42 35 27

class Node {   int data;   Node leftChild;   Node rightChild;   public Node(int key) {      data = key;      leftChild = rightChild = null;   }}public class TreeDataStructure {   Node root = null;   void post_order_traversal(Node node) {      if(node != null) {         post_order_traversal(node.leftChild);         post_order_traversal(node.rightChild);         System.out.print(node.data + " ");      }   }   public static void main(String args[]) {      TreeDataStructure tree = new TreeDataStructure();      tree.root = new Node(27);      tree.root.leftChild = new Node(12);      tree.root.rightChild = new Node(3);      tree.root.leftChild.leftChild = new Node(44);      tree.root.leftChild.rightChild = new Node(17);      tree.root.rightChild.leftChild = new Node(56);      System.out.println("\nPost order traversal: ");      tree.post_order_traversal(tree.root);   }}

Output

Post order traversal: 44 17 12 56 3 27

class Node:   def __init__(self, key):      self.leftChild = None      self.rightChild = None      self.data = key# Create a function to perform preorder tree traversaldef PostorderTraversal(root):   if root:      PostorderTraversal(root.leftChild)      PostorderTraversal(root.rightChild)      print(root.data)# Main classif __name__ == "__main__":   root = Node(3)   root.leftChild = Node(26)   root.rightChild = Node(42)   root.leftChild.leftChild = Node(54)   root.leftChild.rightChild = Node(65)   root.rightChild.leftChild = Node(12)   print("\nPostorder traversal of binary tree is")   PostorderTraversal(root)

Output

Postorder traversal of binary tree is54652612423

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild;   struct node *rightChild;};struct node *root = NULL;void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;//if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;         //go to left of the tree         if(data < parent->data) {            current = current->leftChild;            //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;            //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}void pre_order_traversal(struct node* root){   if(root != NULL) {      printf("%d ",root->data);      pre_order_traversal(root->leftChild);      pre_order_traversal(root->rightChild);   }}void inorder_traversal(struct node* root){   if(root != NULL) {      inorder_traversal(root->leftChild);      printf("%d ",root->data);      inorder_traversal(root->rightChild);   }}void post_order_traversal(struct node* root){   if(root != NULL) {      post_order_traversal(root->leftChild);      post_order_traversal(root->rightChild);      printf("%d ", root->data);   }}int main(){   int i;   int array[7] = { 27, 14, 35, 10, 19, 31, 42 };   for(i = 0; i < 7; i++)      insert(array[i]);   printf("\nPreorder traversal: ");   pre_order_traversal(root);   printf("\nInorder traversal: ");   inorder_traversal(root);   printf("\nPost order traversal: ");   post_order_traversal(root);   return 0;}

Output

Preorder traversal: 27 14 10 19 35 31 42 Inorder traversal: 10 14 19 27 31 35 42 Post order traversal: 10 19 14 31 42 35 27

#include <iostream>struct node {   int data;   struct node *leftChild;   struct node *rightChild;};struct node *root = NULL;void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;   //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;         //go to left of the tree         if(data < parent->data) {            current = current->leftChild;            //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;            //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}void pre_order_traversal(struct node* root){   if(root != NULL) {      printf("%d ",root->data);      pre_order_traversal(root->leftChild);      pre_order_traversal(root->rightChild);   }}void inorder_traversal(struct node* root){   if(root != NULL) {      inorder_traversal(root->leftChild);      printf("%d ",root->data);      inorder_traversal(root->rightChild);   }}void post_order_traversal(struct node* root){   if(root != NULL) {      post_order_traversal(root->leftChild);      post_order_traversal(root->rightChild);      printf("%d ", root->data);   }}int main(){   int i;   int array[7] = { 27, 14, 35, 10, 19, 31, 42 };   for(i = 0; i < 7; i++)      insert(array[i]);   printf("\nPreorder traversal: ");   pre_order_traversal(root);   printf("\nInorder traversal: ");   inorder_traversal(root);   printf("\nPost order traversal: ");   post_order_traversal(root);   return 0;}

Output

Preorder traversal: 27 14 10 19 35 31 42 Inorder traversal: 10 14 19 27 31 35 42 Post order traversal: 10 19 14 31 42 35 27

class Node {   int data;   Node leftChild;   Node rightChild;   public Node(int key) {      data = key;      leftChild = rightChild = null;   }}public class TreeDataStructure {   Node root = null;   void inorder_traversal(Node node) {      if(node != null) {         inorder_traversal(node.leftChild);         System.out.print(node.data + " ");         inorder_traversal(node.rightChild);      }   }   void pre_order_traversal(Node node) {      if(node != null) {         System.out.print(node.data + " ");         pre_order_traversal(node.leftChild);         pre_order_traversal(node.rightChild);      }   }   void post_order_traversal(Node node) {      if(node != null) {         post_order_traversal(node.leftChild);         post_order_traversal(node.rightChild);         System.out.print(node.data + " ");      }   }   public static void main(String args[]) {      TreeDataStructure tree = new TreeDataStructure();      tree.root = new Node(27);      tree.root.leftChild = new Node(12);      tree.root.rightChild = new Node(3);      tree.root.leftChild.leftChild = new Node(44);      tree.root.leftChild.rightChild = new Node(17);      tree.root.rightChild.leftChild = new Node(56);      System.out.println("\nInorder traversal: ");      tree.inorder_traversal(tree.root);      System.out.println("\nPreorder traversal: ");      tree.pre_order_traversal(tree.root);      System.out.println("\nPost order traversal: ");      tree.post_order_traversal(tree.root);   }}

Output

Inorder traversal: 44 12 17 27 56 3 Preorder traversal: 27 12 44 17 3 56 Post order traversal: 44 17 12 56 3 27

class Node:   def __init__(self, key):      self.leftChild = None      self.rightChild = None      self.data = key# Create a function to perform inorder tree traversaldef InorderTraversal(root):   if root:      InorderTraversal(root.leftChild)      print(root.data)      InorderTraversal(root.rightChild)# Create a function to perform preorder tree traversaldef PostorderTraversal(root):   if root:      PostorderTraversal(root.leftChild)      PostorderTraversal(root.rightChild)      print(root.data)# Create a function to perform postorder tree traversaldef PreorderTraversal(root):   if root:      print(root.data)      PreorderTraversal(root.leftChild)      PreorderTraversal(root.rightChild)# Main classif __name__ == "__main__":   root = Node(3)   root.leftChild = Node(26)   root.rightChild = Node(42)   root.leftChild.leftChild = Node(54)   root.leftChild.rightChild = Node(65)   root.rightChild.leftChild = Node(12)   # Function call   print("\nInorder traversal of binary tree is")   InorderTraversal(root)   print("\nPreorder traversal of binary tree is")   PreorderTraversal(root)   print("\nPostorder traversal of binary tree is")   PostorderTraversal(root)

Output

Inorder traversal of binary tree is54266531242Preorder traversal of binary tree is32654654212Postorder traversal of binary tree is54652612423

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild, *rightChild;};struct node *root = NULL;struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->data = item;   temp->leftChild = temp->rightChild = NULL;   return temp;}void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;      //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;                  //go to left of the tree         if(data < parent->data) {            current = current->leftChild;                        //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;                        //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}struct node* search(int data){   struct node *current = root;   printf("\nVisiting elements: ");   while(current->data != data) {      if(current != NULL) {         printf("%d ",current->data);                  //go to left tree         if(current->data > data) {            current = current->leftChild;         }//else go to right tree         else {            current = current->rightChild;         }                  //not found         if(current == NULL) {            return NULL;         }      }   }   return current;}void printTree(struct node* Node){   if(Node == NULL)      return;   printTree(Node->leftChild);   printf(" --%d", Node->data);   printTree(Node->rightChild);}int main(){   insert(55);   insert(20);   insert(90);   insert(50);   insert(35);   insert(15);   insert(65);   printf("Insertion done\n");   printTree(root);   struct node* k;   k = search(35);   if(k != NULL)      printf("\nElement %d found", k->data);   else      printf("\nElement not found");   return 0;}

Output

Insertion done --15 --20 --35 --50 --55 --65 --90Visiting elements: 55 20 50 Element 35 found

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild, *rightChild;};struct node *root = NULL;struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->data = item;   temp->leftChild = temp->rightChild = NULL;   return temp;}void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;      //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;                  //go to left of the tree         if(data < parent->data) {            current = current->leftChild;                        //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;                        //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}struct node* search(int data){   struct node *current = root;   printf("\nVisiting elements: ");   while(current->data != data) {      if(current != NULL) {         printf("%d ",current->data);                  //go to left tree         if(current->data > data) {            current = current->leftChild;         }//else go to right tree         else {            current = current->rightChild;         }                  //not found         if(current == NULL) {            return NULL;         }      }   }   return current;}void printTree(struct node* Node){   if(Node == NULL)      return;   printTree(Node->leftChild);   printf(" --%d", Node->data);   printTree(Node->rightChild);}int main(){   insert(55);   insert(20);   insert(90);   insert(50);   insert(35);   insert(15);   insert(65);   printf("Insertion done\n");   printTree(root);   struct node* k;   k = search(35);   if(k != NULL)      printf("\nElement %d found", k->data);   else      printf("\nElement not found");   return 0;}

Output

Insertion done --15 --20 --35 --50 --55 --65 --90Visiting elements: 55 20 50 Element 35 found

import java.util.Scanner;class BSTNode {   BSTNode left, right;   int data;   public BSTNode(int n) {      left = null;      right = null;      data = n;   }}public class BST {   static BSTNode root;   public BST() {      root = null;   }   private BSTNode insert(BSTNode node, int data) {      if(node == null)         node = new BSTNode(data);      else {         if(data <= node.data)            node.left = insert(node.left, data);         else            node.right = insert(node.right, data);      }      return node;   }   private boolean search(BSTNode r, int val) {      boolean found = false;      while ((r != null) && !found) {         int rval = r.data;         if(val < rval)            r = r.left;         else if (val > rval)            r = r.right;         else {            found = true;            break;         }         found = search(r, val);      }      return found;   }   void printTree(BSTNode node, String prefix) {      if(node == null)         return;      printTree(node.left , " " + prefix);      System.out.println(prefix + "--" + node.data);      printTree(node.right , prefix + " ");   }   public static void main(String args[]) {      Scanner sc = new Scanner(System.in);      BST bst = new BST();      root = bst.insert(root, 55);      root = bst.insert(root, 20);      root = bst.insert(root, 90);      root = bst.insert(root, 80);      root = bst.insert(root, 50);      root = bst.insert(root, 35);      root = bst.insert(root, 15);      root = bst.insert(root, 65);      bst.printTree(root, " ");      System.out.println("Element found = " + bst.search(root, 80));   }}

Output

--15  --20--35   --50 --55    --65   --80  --90Element found = true

class Node:   def __init__(self, data):      self.left = None      self.right = None      self.data = data# Insert method to create nodes   def insert(self, data):      if self.data:         if data < self.data:            if self.left is None:               self.left = Node(data)            else:               self.left.insert(data)         elif data > self.data:            if self.right is None:               self.right = Node(data)            else:               self.right.insert(data)         else:            self.data = data# search method to compare the value with nodes   def search(self, key):      if key < self.data:         if self.left is None:            return str(key)+" Not Found"         return self.left.search(key)      elif key > self.data:         if self.right is None:            return str(key)+" Not Found"         return self.right.search(key)      else:         print(str(self.data) + ' is found')root = Node(54)root.insert(34)root.insert(46)root.insert(12)root.insert(23)root.insert(5)print(root.search(17))print(root.search(12))

Output

17 Not Found12 is foundNone

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild, *rightChild;};struct node *root = NULL;struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->data = item;   temp->leftChild = temp->rightChild = NULL;   return temp;}void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;      //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;                  //go to left of the tree         if(data < parent->data) {            current = current->leftChild;                        //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;                        //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}void printTree(struct node* Node){   if(Node == NULL)      return;   printTree(Node->leftChild);   printf(" --%d", Node->data);   printTree(Node->rightChild);}int main(){   insert(55);   insert(20);   insert(90);   insert(50);   insert(35);   insert(15);   insert(65);   printf("Insertion done\n");   printTree(root);   return 0;}

Output

Insertion done --15 --20 --35 --50 --55 --65 --90

#include <iostream>struct node {   int data;   struct node *leftChild, *rightChild;};struct node *root = NULL;struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->data = item;   temp->leftChild = temp->rightChild = NULL;   return temp;}void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;      //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;                  //go to left of the tree         if(data < parent->data) {            current = current->leftChild;                        //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;                        //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}void printTree(struct node* Node){   if(Node == NULL)      return;   printTree(Node->leftChild);   printf(" --%d", Node->data);   printTree(Node->rightChild);}int main(){   insert(55);   insert(20);   insert(90);   insert(50);   insert(35);   insert(15);   insert(65);   printf("Insertion done\n");   printTree(root);   return 0;}

Output

Insertion done --15 --20 --35 --50 --55 --65 --90

import java.util.Scanner;class BSTNode {   BSTNode left, right;   int data;   public BSTNode(int n) {      left = null;      right = null;      data = n;   }}public class BST {   static BSTNode root;   public BST() {      root = null;   }   private BSTNode insert(BSTNode node, int data) {      if(node == null)         node = new BSTNode(data);      else {         if(data <= node.data)            node.left = insert(node.left, data);         else            node.right = insert(node.right, data);      }      return node;   }   void printTree(BSTNode node, String prefix) {      if(node == null)         return;      printTree(node.left , " " + prefix);      System.out.println(prefix + "--" + node.data);      printTree(node.right , prefix + " ");   }   public static void main(String args[]) {      Scanner sc = new Scanner(System.in);      BST bst = new BST();      root = bst.insert(root, 55);      root = bst.insert(root, 20);      root = bst.insert(root, 90);      root = bst.insert(root, 80);      root = bst.insert(root, 50);      root = bst.insert(root, 35);      root = bst.insert(root, 15);      root = bst.insert(root, 65);      bst.printTree(root, " ");   }}

Output

--15  --20--35   --50 --55    --65   --80  --90

class Node:   def __init__(self, data):      self.left = None      self.right = None      self.data = data# Insert method to create nodes   def insert(self, data):      if self.data:         if data < self.data:            if self.left is None:               self.left = Node(data)            else:               self.left.insert(data)         elif data > self.data:            if self.right is None:               self.right = Node(data)            else:               self.right.insert(data)         else:            self.data = dataroot = Node(54)root.insert(34)root.insert(46)root.insert(12)root.insert(23)root.insert(5)print("Insertion Done")

Output

Insertion Done

#include <stdio.h>#include <stdlib.h>struct node {   int key;   struct node *left, *right;};struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->key = item;   temp->left = temp->right = NULL;   return temp;}// Inorder Traversalvoid inorder(struct node *root){   if (root != NULL) {      inorder(root->left);      printf("%d -> ", root->key);      inorder(root->right);   }}// Insertion operationstruct node *insert(struct node *node, int key){   if (node == NULL) return newNode(key);   if (key < node->key)      node->left = insert(node->left, key);   else      node->right = insert(node->right, key);   return node;}int main(){   struct node *root = NULL;   root = insert(root, 55);   root = insert(root, 20);   root = insert(root, 90);   root = insert(root, 50);   root = insert(root, 35);   root = insert(root, 15);   root = insert(root, 65);   printf("Inorder traversal: ");   inorder(root);}

Output

Inorder traversal: 15 -> 20 -> 35 -> 50 -> 55 -> 65 -> 90 ->

#include <iostream>struct node {   int key;   struct node *left, *right;};struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->key = item;   temp->left = temp->right = NULL;   return temp;}// Inorder Traversalvoid inorder(struct node *root){   if (root != NULL) {     inorder(root->left);     printf("%d -> ", root->key);     inorder(root->right);   }}// Insertion operationstruct node *insert(struct node *node, int key){   if (node == NULL) return newNode(key);   if (key < node->key)     node->left = insert(node->left, key);   else     node->right = insert(node->right, key);   return node;}int main(){   struct node *root = NULL;   root = insert(root, 55);   root = insert(root, 20);   root = insert(root, 90);   root = insert(root, 50);   root = insert(root, 35);   root = insert(root, 15);   root = insert(root, 65);   printf("Inorder traversal: ");   inorder(root);}

Output

Inorder traversal: 15 -> 20 -> 35 -> 50 -> 55 -> 65 -> 90 ->

class Node {   int data;   Node leftChild;   Node rightChild;   public Node(int key) {      data = key;      leftChild = rightChild = null;   }}public class TreeDataStructure {   Node root = null;   void inorder_traversal(Node node) {      if(node != null) {         inorder_traversal(node.leftChild);         System.out.print(node.data + " ");         inorder_traversal(node.rightChild);      }   }   public static void main(String args[]) {      TreeDataStructure tree = new TreeDataStructure();      tree.root = new Node(27);      tree.root.leftChild = new Node(12);      tree.root.rightChild = new Node(30);      tree.root.leftChild.leftChild = new Node(4);      tree.root.leftChild.rightChild = new Node(17);      tree.root.rightChild.leftChild = new Node(56);      System.out.println("\nInorder traversal: ");      tree.inorder_traversal(tree.root);   }}

Output

Inorder traversal:4 12 17 27 56 30

class Node:   def __init__(self, data):      self.left = None      self.right = None      self.data = data# Insert method to create nodes   def insert(self, data):      if self.data:         if data < self.data:            if self.left is None:               self.left = Node(data)            else:               self.left.insert(data)         elif data > self.data:            if self.right is None:               self.right = Node(data)            else:               self.right.insert(data)         else:            self.data = data# Print the tree   def Inorder(self):      if self.left:         self.left.Inorder()         print(self.data)      if self.right:         self.right.Inorder()root = Node(54)root.insert(34)root.insert(46)root.insert(12)root.insert(23)root.insert(5)print("Inorder Traversal of Binary Search Tree: ")root.Inorder()

Output

Inorder Traversal of Binary Search Tree: 123454

#include <stdio.h>#include <stdlib.h>struct node {   int key;   struct node *left, *right;};struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->key = item;   temp->left = temp->right = NULL;   return temp;}// Preorder Traversalvoid preorder(struct node *root){   if (root != NULL) {      printf("%d -> ", root->key);      preorder(root->left);      preorder(root->right);   }}// Insertion operationstruct node *insert(struct node *node, int key){   if (node == NULL) return newNode(key);   if (key < node->key)      node->left = insert(node->left, key);   else      node->right = insert(node->right, key);   return node;}int main(){   struct node *root = NULL;   root = insert(root, 55);   root = insert(root, 20);   root = insert(root, 90);   root = insert(root, 50);   root = insert(root, 35);   root = insert(root, 15);   root = insert(root, 65);   printf("Preorder traversal: ");   preorder(root);}

Output

Preorder traversal: 55 -> 20 -> 15 -> 50 -> 35 -> 90 -> 65 ->

#include <iostream>struct node {   int key;   struct node *left, *right;};struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->key = item;   temp->left = temp->right = NULL;   return temp;}// Preorder Traversalvoid preorder(struct node *root){   if (root != NULL) {      printf("%d -> ", root->key);      preorder(root->left);      preorder(root->right);   }}// Insertion operationstruct node *insert(struct node *node, int key){   if (node == NULL) return newNode(key);   if (key < node->key)      node->left = insert(node->left, key);   else      node->right = insert(node->right, key);   return node;}int main(){   struct node *root = NULL;   root = insert(root, 55);   root = insert(root, 20);   root = insert(root, 90);   root = insert(root, 50);   root = insert(root, 35);   root = insert(root, 15);   root = insert(root, 65);   printf("Preorder traversal: ");   preorder(root);}

Output

Preorder traversal: 55 -> 20 -> 15 -> 50 -> 35 -> 90 -> 65 ->

class Node {    int data;    Node leftChild;    Node rightChild;    public Node(int key) {        data = key;        leftChild = rightChild = null;    }}public class TreeDataStructure {    Node root = null;    void preorder_traversal(Node node) {        if(node != null) {            System.out.print(node.data + " ");            preorder_traversal(node.leftChild);            preorder_traversal(node.rightChild);        }    }    public static void main(String args[]) {        TreeDataStructure tree = new TreeDataStructure();        tree.root = new Node(27);        tree.root.leftChild = new Node(12);        tree.root.rightChild = new Node(30);        tree.root.leftChild.leftChild = new Node(4);        tree.root.leftChild.rightChild = new Node(17);        tree.root.rightChild.leftChild = new Node(56);        System.out.println("\nPreorder traversal: ");        tree.preorder_traversal(tree.root);    }}

Output

Preorder traversal: 27 12 4 17 30 56

class Node:   def __init__(self, data):      self.left = None      self.right = None      self.data = data# Insert method to create nodes   def insert(self, data):      if self.data:         if data < self.data:            if self.left is None:               self.left = Node(data)            else:               self.left.insert(data)         elif data > self.data:            if self.right is None:               self.right = Node(data)            else:               self.right.insert(data)         else:            self.data = data# Print the tree   def Preorder(self):      print(self.data)      if self.left:         self.left.Preorder()      if self.right:         self.right.Preorder()root = Node(54)root.insert(34)root.insert(46)root.insert(12)root.insert(23)root.insert(5)print("Preorder Traversal of Binary Search Tree: ")root.Preorder()

Output

Preorder Traversal of Binary Search Tree: 54341252346

#include <stdio.h>#include <stdlib.h>struct node {   int key;   struct node *left, *right;};struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->key = item;   temp->left = temp->right = NULL;   return temp;}// Postorder Traversalvoid postorder(struct node *root){   if (root != NULL) {      printf("%d -> ", root->key);      postorder(root->left);      postorder(root->right);   }}// Insertion operationstruct node *insert(struct node *node, int key){   if (node == NULL) return newNode(key);   if (key < node->key)      node->left = insert(node->left, key);   else      node->right = insert(node->right, key);   return node;}int main(){   struct node *root = NULL;   root = insert(root, 55);   root = insert(root, 20);   root = insert(root, 90);   root = insert(root, 50);   root = insert(root, 35);   root = insert(root, 15);   root = insert(root, 65);   printf("Postorder traversal: ");   postorder(root);}

Output

Postorder traversal: 55 -> 20 -> 15 -> 50 -> 35 -> 90 > 65 ->

#include <iostream>struct node {   int key;   struct node *left, *right;};struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->key = item;   temp->left = temp->right = NULL;   return temp;}// Postorder Traversalvoid postorder(struct node *root){   if (root != NULL) {      printf("%d -> ", root->key);      postorder(root->left);      postorder(root->right);   }}// Insertion operationstruct node *insert(struct node *node, int key){   if (node == NULL) return newNode(key);   if (key < node->key)      node->left = insert(node->left, key);   else      node->right = insert(node->right, key);   return node;}int main(){   struct node *root = NULL;   root = insert(root, 55);   root = insert(root, 20);   root = insert(root, 90);   root = insert(root, 50);   root = insert(root, 35);   root = insert(root, 15);   root = insert(root, 65);   printf("Postorder traversal: ");   postorder(root);}

Output

Postorder traversal: 55 -> 20 -> 15 -> 50 -> 35 -> 90 -> 65 ->

class Node {    int data;    Node leftChild;    Node rightChild;    public Node(int key) {        data = key;        leftChild = rightChild = null;    }}public class TreeDataStructure {    Node root = null;    void postorder_traversal(Node node) {        if(node != null) {            postorder_traversal(node.leftChild);            postorder_traversal(node.rightChild);            System.out.print(node.data + " ");        }    }    public static void main(String args[]) {        TreeDataStructure tree = new TreeDataStructure();        tree.root = new Node(27);        tree.root.leftChild = new Node(12);        tree.root.rightChild = new Node(30);        tree.root.leftChild.leftChild = new Node(4);        tree.root.leftChild.rightChild = new Node(17);        tree.root.rightChild.leftChild = new Node(56);        System.out.println("\nPostorder traversal: ");        tree.postorder_traversal(tree.root);    }}

Output

Postorder traversal: 4 17 12 56 30 27

class Node:   def __init__(self, data):      self.left = None      self.right = None      self.data = data# Insert method to create nodes   def insert(self, data):      if self.data:         if data < self.data:            if self.left is None:               self.left = Node(data)            else:               self.left.insert(data)         elif data > self.data:            if self.right is None:               self.right = Node(data)            else:               self.right.insert(data)      else:         self.data = data# Print the tree   def Postorder(self):      if self.left:         self.left.Postorder()      if self.right:         self.right.Postorder()      print(self.data)root = Node(54)root.insert(34)root.insert(46)root.insert(12)root.insert(23)root.insert(5)print("Postorder Traversal of Binary Search Tree: ")root.Postorder()

Output

Postorder Traversal of Binary Search Tree: 52312463454

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild, *rightChild;};struct node *root = NULL;struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->data = item;   temp->leftChild = temp->rightChild = NULL;   return temp;}void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;   //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;         //go to left of the tree         if(data < parent->data) {            current = current->leftChild;            //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;                        //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}struct node* search(int data){   struct node *current = root;   printf("\n\nVisiting elements: ");   while(current->data != data) {      if(current != NULL) {         printf("%d ",current->data);         //go to left tree         if(current->data > data) {            current = current->leftChild;         }//else go to right tree         else {            current = current->rightChild;         }         //not found         if(current == NULL) {            return NULL;         }      }   }   return current;}// Inorder Traversalvoid inorder(struct node *root){   if (root != NULL) {      inorder(root->leftChild);      printf("%d -> ", root->data);      inorder(root->rightChild);   }}// Preorder Traversalvoid preorder(struct node *root){   if (root != NULL) {      printf("%d -> ", root->data);      preorder(root->leftChild);      preorder(root->rightChild);   }}// Postorder Traversalvoid postorder(struct node *root){   if (root != NULL) {      printf("%d -> ", root->data);      postorder(root->leftChild);      postorder(root->rightChild);   }}int main(){   insert(55);   insert(20);   insert(90);   insert(50);   insert(35);   insert(15);   insert(65);   printf("Insertion done\n");   printf("\nPreorder Traversal: ");   preorder(root);   printf("\nInorder Traversal: ");   inorder(root);   printf("\nPostorder Traversal: ");   postorder(root);   struct node* k;   k = search(35);   if(k != NULL)      printf("\nElement %d found", k->data);   else      printf("\nElement not found");   return 0;}

Output

Insertion donePreorder Traversal: 55 -> 20 -> 15 -> 50 -> 35 -> 90 -> 65 -> Inorder Traversal: 15 -> 20 -> 35 -> 50 -> 55 -> 65 -> 90 -> Postorder Traversal: 55 -> 20 -> 15 -> 50 -> 35 -> 90 -> 65 -> Visiting elements: 55 20 50 Element 35 found

#include <iostream>struct node {   int data;   struct node *leftChild, *rightChild;};struct node *root = NULL;struct node *newNode(int item){   struct node *temp = (struct node *)malloc(sizeof(struct node));   temp->data = item;   temp->leftChild = temp->rightChild = NULL;   return temp;}void insert(int data){   struct node *tempNode = (struct node*) malloc(sizeof(struct node));   struct node *current;   struct node *parent;   tempNode->data = data;   tempNode->leftChild = NULL;   tempNode->rightChild = NULL;      //if tree is empty   if(root == NULL) {      root = tempNode;   } else {      current = root;      parent = NULL;      while(1) {         parent = current;         //go to left of the tree         if(data < parent->data) {            current = current->leftChild;            //insert to the left            if(current == NULL) {               parent->leftChild = tempNode;               return;            }         }//go to right of the tree         else {            current = current->rightChild;                        //insert to the right            if(current == NULL) {               parent->rightChild = tempNode;               return;            }         }      }   }}struct node* search(int data){   struct node *current = root;   printf("\n\nVisiting elements: ");   while(current->data != data) {      if(current != NULL) {         printf("%d ",current->data);                  //go to left tree         if(current->data > data) {            current = current->leftChild;         }//else go to right tree         else {            current = current->rightChild;         }                  //not found         if(current == NULL) {            return NULL;         }      }   }   return current;}// Inorder Traversalvoid inorder(struct node *root){   if (root != NULL) {      inorder(root->leftChild);      printf("%d -> ", root->data);      inorder(root->rightChild);   }}// Preorder Traversalvoid preorder(struct node *root){   if (root != NULL) {      printf("%d -> ", root->data);      preorder(root->leftChild);      preorder(root->rightChild);   }}// Postorder Traversalvoid postorder(struct node *root){   if (root != NULL) {      printf("%d -> ", root->data);      postorder(root->leftChild);      postorder(root->rightChild);   }}int main(){   insert(55);   insert(20);   insert(90);   insert(50);   insert(35);   insert(15);   insert(65);   printf("Insertion done\n");   printf("\nPreorder Traversal: ");   preorder(root);   printf("\nInorder Traversal: ");   inorder(root);   printf("\nPostorder Traversal: ");   postorder(root);   struct node* k;   k = search(35);   if(k != NULL)      printf("\nElement %d found", k->data);   else      printf("\nElement not found");   return 0;}

Output

Insertion donePreorder Traversal: 55 -> 20 -> 15 -> 50 -> 35 -> 90 -> 65 -> Inorder Traversal: 15 -> 20 -> 35 -> 50 -> 55 -> 65 -> 90 ->Postorder Traversal: 55 -> 20 -> 15 -> 50 -> 35 -> 90 -> 65 -> Visiting elements: 55 20 50 Element 35 found

import java.util.Scanner;class BSTNode {   BSTNode left, right;   int data;   public BSTNode(int n) {      left = null;      right = null;      data = n;   }}public class BST {   static BSTNode root;   public BST() {      root = null;   }   public boolean isEmpty() {      return root == null;   }   private BSTNode insert(BSTNode node, int data) {      if(node == null)         node = new BSTNode(data);      else {         if(data <= node.data)            node.left = insert(node.left, data);         else            node.right = insert(node.right, data);      }      return node;   }   public void delete(int k) {      if(isEmpty ())         System.out.println("TREE EMPTY");      else if(search (k) == false)         System.out.println("SORRY " + k + " IS NOT PRESENT");      else {         root=delete(root,k);         System.out.println(k + " DELETED FROM THE TREE");      }   }   public BSTNode delete(BSTNode root, int k) {      BSTNode p, p2, n;      if(root.data == k) {         BSTNode lt, rt;         lt = root.left;         rt = root.right;         if(lt == null && rt == null) {            return null;         } else if(lt == null) {            p = rt;            return p;         } else if(rt == null) {            p = lt;            return p;         } else {            p2 = rt;            p = rt;            while(p.left != null)               p = p.left;            p.left = lt;            return p2;         }      }      if (k < root.data) {         n = delete(root.left, k);         root.left = n;      } else {         n = delete(root.right, k);         root.right = n;      }      return root;   }   public boolean search(int val) {      return search(root, val);   }   private boolean search(BSTNode r, int val) {      boolean found = false;      while ((r != null) && !found) {         int rval = r.data;         if(val < rval)            r = r.left;         else if (val > rval)            r = r.right;         else {            found = true;            break;         }         found = search(r, val);      }      return found;   }   void printTree(BSTNode node, String prefix) {      if(node == null)         return;      printTree(node.left , " " + prefix);      System.out.println(prefix + "--" + node.data);      printTree(node.right , prefix + " ");   }   public static void main(String args[]) {      Scanner sc = new Scanner(System.in);      BST bst = new BST();      root = bst.insert(root, 55);      root = bst.insert(root, 20);      root = bst.insert(root, 90);      root = bst.insert(root, 80);      root = bst.insert(root, 50);      root = bst.insert(root, 35);      root = bst.insert(root, 15);      root = bst.insert(root, 65);      bst.printTree(root, " ");      bst.delete(55);      System.out.println("Element found = " + bst.search(80));      System.out.println("Is Tree Empty? " + bst.isEmpty());   }}

Output

--15  --20--35   --50 --55    --65   --80  --9055 DELETED FROM THE TREEElement found = trueIs Tree Empty? false

class Node:   def __init__(self, data):     self.left = None     self.right = None     self.data = data# Insert method to create nodes   def insert(self, data):     if self.data:       if data < self.data:         if self.left is None:            self.left = Node(data)         else:            self.left.insert(data)       elif data > self.data:         if self.right is None:            self.right = Node(data)         else:            self.right.insert(data)       else:         self.data = data# search method to compare the value with nodes   def search(self, key):     if key < self.data:       if self.left is None:         return str(key)+" Not Found"       return self.left.search(key)     elif key > self.data:       if self.right is None:         return str(key)+" Not Found"       return self.right.search(key)     else:       print(str(self.data) + ' is found')# Print the tree   def Inorder(self):     if self.left:       self.left.Inorder()     print(self.data)     if self.right:       self.right.Inorder()# Print the tree   def Preorder(self):     print(self.data)     if self.left:       self.left.Preorder()     if self.right:       self.right.Preorder()# Print the tree   def Postorder(self):     if self.left:       self.left.Postorder()     if self.right:       self.right.Postorder()     print(self.data)root = Node(54)root.insert(34)root.insert(46)root.insert(12)root.insert(23)root.insert(5)print("Preorder Traversal of Binary Search Tree: ")root.Preorder()print("Inorder Traversal of Binary Search Tree: ")root.Inorder()print("Postorder Traversal of Binary Search Tree: ")root.Postorder()print(root.search(17))print(root.search(12))

Output

Preorder Traversal of Binary Search Tree: 54341252346Inorder Traversal of Binary Search Tree: 51223344654Postorder Traversal of Binary Search Tree: 5231246345417 Not Found12 is foundNone

#include <stdio.h>#include <stdlib.h>struct Node {   int data;   struct Node *leftChild;   struct Node *rightChild;   int height;};int max(int a, int b);int height(struct Node *N){   if (N == NULL)      return 0;   return N->height;}int max(int a, int b){   return (a > b) ? a : b;}struct Node *newNode(int data){   struct Node *node = (struct Node *) malloc(sizeof(struct Node));   node->data = data;   node->leftChild = NULL;   node->rightChild = NULL;   node->height = 1;   return (node);}struct Node *rightRotate(struct Node *y){   struct Node *x = y->leftChild;   struct Node *T2 = x->rightChild;   x->rightChild = y;   y->leftChild = T2;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   return x;}struct Node *leftRotate(struct Node *x){   struct Node *y = x->rightChild;   struct Node *T2 = y->leftChild;   y->leftChild = x;   x->rightChild = T2;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   return y;}int getBalance(struct Node *N){   if (N == NULL)      return 0;   return height(N->leftChild) - height(N->rightChild);}struct Node *insertNode(struct Node *node, int data){   if (node == NULL)      return (newNode(data));   if (data < node->data)      node->leftChild = insertNode(node->leftChild, data);   else if (data > node->data)      node->rightChild = insertNode(node->rightChild, data);   else      return node;   node->height = 1 + max(height(node->leftChild),                     height(node->rightChild));   int balance = getBalance(node);   if (balance > 1 && data < node->leftChild->data)      return rightRotate(node);   if (balance < -1 && data > node->rightChild->data)      return leftRotate(node);   if (balance > 1 && data > node->leftChild->data) {      node->leftChild = leftRotate(node->leftChild);      return rightRotate(node);   }   if (balance < -1 && data < node->rightChild->data) {      node->rightChild = rightRotate(node->rightChild);      return leftRotate(node);   }   return node;}struct Node *minValueNode(struct Node *node){   struct Node *current = node;   while (current->leftChild != NULL)      current = current->leftChild;   return current;}void printTree(struct Node *root){   if (root == NULL)      return;   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->rightChild);   }}int main(){   struct Node *root = NULL;   root = insertNode(root, 22);   root = insertNode(root, 14);   root = insertNode(root, 72);   root = insertNode(root, 44);   root = insertNode(root, 25);   root = insertNode(root, 63);   root = insertNode(root, 98);   printf("AVL Tree: ");   printTree(root);   return 0;}

Output

AVL Tree: 14 22 25 44 63 72 98

#include <iostream>struct Node {   int data;   struct Node *leftChild;   struct Node *rightChild;   int height;};int max(int a, int b);int height(struct Node *N){   if (N == NULL)      return 0;   return N->height;}int max(int a, int b){   return (a > b) ? a : b;}struct Node *newNode(int data){   struct Node *node = (struct Node *) malloc(sizeof(struct Node));   node->data = data;   node->leftChild = NULL;   node->rightChild = NULL;   node->height = 1;   return (node);}struct Node *rightRotate(struct Node *y){   struct Node *x = y->leftChild;   struct Node *T2 = x->rightChild;   x->rightChild = y;   y->leftChild = T2;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   return x;}struct Node *leftRotate(struct Node *x){   struct Node *y = x->rightChild;   struct Node *T2 = y->leftChild;   y->leftChild = x;   x->rightChild = T2;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   return y;}int getBalance(struct Node *N){   if (N == NULL)      return 0;   return height(N->leftChild) - height(N->rightChild);}struct Node *insertNode(struct Node *node, int data){   if (node == NULL)      return (newNode(data));   if (data < node->data)      node->leftChild = insertNode(node->leftChild, data);   else if (data > node->data)      node->rightChild = insertNode(node->rightChild, data);   else      return node;   node->height = 1 + max(height(node->leftChild),                     height(node->rightChild));   int balance = getBalance(node);   if (balance > 1 && data < node->leftChild->data)      return rightRotate(node);   if (balance < -1 && data > node->rightChild->data)      return leftRotate(node);   if (balance > 1 && data > node->leftChild->data) {      node->leftChild = leftRotate(node->leftChild);      return rightRotate(node);   }   if (balance < -1 && data < node->rightChild->data) {      node->rightChild = rightRotate(node->rightChild);      return leftRotate(node);   }   return node;}struct Node *minValueNode(struct Node *node){   struct Node *current = node;   while (current->leftChild != NULL)      current = current->leftChild;   return current;}void printTree(struct Node *root){   if (root == NULL)      return;   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->leftChild);   }}int main(){   struct Node *root = NULL;   root = insertNode(root, 22);   root = insertNode(root, 14);   root = insertNode(root, 72);   root = insertNode(root, 44);   root = insertNode(root, 25);   root = insertNode(root, 63);   root = insertNode(root, 98);   printf("AVL Tree: ");   printTree(root);   return 0;}

Output

AVL Tree: 14 22 14 44 14 22 14

import java.util.*;import java.io.*;class Node {   int key, height;   Node left, right;   Node (int d) {      key = d;      height = 1;   }}public class AVLTree {   Node root;   int height (Node N) {      if (N == null)         return 0;      return N.height;   }   int max (int a, int b) {      return (a > b) ? a : b;   }   Node rightRotate (Node y) {      Node x = y.left;      Node T2 = x.right;      x.right = y;      y.left = T2;      y.height = max (height (y.left), height (y.right)) + 1;      x.height = max (height (x.left), height (x.right)) + 1;      return x;   }   Node leftRotate (Node x) {      Node y = x.right;      Node T2 = y.left;      y.left = x;      x.right = T2;      x.height = max (height (x.left), height (x.right)) + 1;      y.height = max (height (y.left), height (y.right)) + 1;      return y;   }   int getBalance (Node N) {      if (N == null)         return 0;      return height (N.left) - height (N.right);   }   Node insert (Node node, int key) {      if (node == null)         return (new Node (key));      if (key < node.key)         node.left = insert (node.left, key);      else if (key > node.key)         node.right = insert (node.right, key);      else         return node;      node.height = 1 + max (height (node.left), height (node.right));      int balance = getBalance (node);      if (balance > 1 && key < node.left.key)         return rightRotate (node);      if (balance < -1 && key > node.right.key)         return leftRotate (node);      if (balance > 1 && key > node.left.key) {         node.left = leftRotate (node.left);         return rightRotate (node);      }      if (balance < -1 && key < node.right.key) {         node.right = rightRotate (node.right);         return leftRotate (node);      }      return node;   }   void printTree(Node root){   if (root == null)      return;   if (root != null) {      printTree(root.left);      System.out.print(root.key + " ");      printTree(root.left);   }}   public static void main(String args[]) {      AVLTree tree = new AVLTree();      tree.root = tree.insert(tree.root, 10);       tree.root = tree.insert(tree.root, 11);       tree.root = tree.insert(tree.root, 12);       tree.root = tree.insert(tree.root, 13);       tree.root = tree.insert(tree.root, 14);       tree.root = tree.insert(tree.root, 15);       System.out.println("AVL Tree: ");      tree.printTree(tree.root);   }}

Output

AVL Tree: 10 11 10 13 10 11 10

class Node(object):   def __init__(self, data):      self.data = data      self.left = None      self.right = None      self.height = 1class AVLTree(object):   def insert(self, root, key):      if not root:         return Node(key)      elif key < root.data:         root.left = self.insert(root.left, key)      else:         root.right = self.insert(root.right, key)      root.h = 1 + max(self.getHeight(root.left),         self.getHeight(root.right))      b = self.getBalance(root)      if b > 1 and key < root.left.data:         return self.rightRotate(root)      if b < -1 and key > root.right.data:         return self.leftRotate(root)      if b > 1 and key > root.left.data:         root.left = self.lefttRotate(root.left)         return self.rightRotate(root)      if b < -1 and key < root.right.data:         root.right = self.rightRotate(root.right)         return self.leftRotate(root)      return root   def leftRotate(self, z):      y = z.right      T2 = y.left      y.left = z      z.right = T2      z.height = 1 + max(self.getHeight(z.left),         self.getHeight(z.right))      y.height = 1 + max(self.getHeight(y.left),         self.getHeight(y.right))      return y   def rightRotate(self, z):      y = z.left      T3 = y.right      y.right = z      z.left = T3      z.height = 1 + max(self.getHeight(z.left),         self.getHeight(z.right))      y.height = 1 + max(self.getHeight(y.left),         self.getHeight(y.right))      return y   def getHeight(self, root):      if not root:         return 0      return root.height   def getBalance(self, root):      if not root:         return 0      return self.getHeight(root.left) - self.getHeight(root.right)   def Inorder(self, root):      if root.left:         self.Inorder(root.left)      print(root.data)      if root.right:         self.Inorder(root.right)Tree = AVLTree()root = Noneroot = Tree.insert(root, 10)root = Tree.insert(root, 13)root = Tree.insert(root, 11)root = Tree.insert(root, 14)root = Tree.insert(root, 12)root = Tree.insert(root, 15)# Inorder Traversalprint("Inorder traversal of the AVL tree is")Tree.Inorder(root)

Output

Inorder traversal of the AVL tree is101112131415

#include <stdio.h>#include <stdlib.h>struct Node {   int data;   struct Node *leftChild;   struct Node *rightChild;   int height;};int max(int a, int b);int height(struct Node *N){   if (N == NULL)      return 0;   return N->height;}int max(int a, int b){   return (a > b) ? a : b;}struct Node *newNode(int data){   struct Node *node = (struct Node *) malloc(sizeof(struct Node));   node->data = data;   node->leftChild = NULL;   node->rightChild = NULL;   node->height = 1;   return (node);}struct Node *rightRotate(struct Node *y){   struct Node *x = y->leftChild;   struct Node *T2 = x->rightChild;   x->rightChild = y;   y->leftChild = T2;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   return x;}struct Node *leftRotate(struct Node *x){   struct Node *y = x->rightChild;   struct Node *T2 = y->leftChild;   y->leftChild = x;   x->rightChild = T2;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   return y;}int getBalance(struct Node *N){   if (N == NULL)      return 0;   return height(N->leftChild) - height(N->rightChild);}struct Node *insertNode(struct Node *node, int data){   if (node == NULL)      return (newNode(data));   if (data < node->data)      node->leftChild = insertNode(node->leftChild, data);   else if (data > node->data)      node->rightChild = insertNode(node->rightChild, data);   else      return node;   node->height = 1 + max(height(node->leftChild),                     height(node->rightChild));   int balance = getBalance(node);   if (balance > 1 && data < node->leftChild->data)      return rightRotate(node);   if (balance < -1 && data > node->rightChild->data)      return leftRotate(node);   if (balance > 1 && data > node->leftChild->data) {      node->leftChild = leftRotate(node->leftChild);      return rightRotate(node);   }   if (balance < -1 && data < node->rightChild->data) {      node->rightChild = rightRotate(node->rightChild);      return leftRotate(node);   }   return node;}struct Node *minValueNode(struct Node *node){   struct Node *current = node;   while (current->leftChild != NULL)      current = current->leftChild;   return current;}struct Node *deleteNode(struct Node *root, int data){   if (root == NULL)      return root;   if (data < root->data)      root->leftChild = deleteNode(root->leftChild, data);   else if (data > root->data)      root->rightChild = deleteNode(root->rightChild, data);   else {      if ((root->leftChild == NULL) || (root->rightChild == NULL)) {         struct Node *temp = root->leftChild ? root->leftChild : root->rightChild;         if (temp == NULL) {            temp = root;            root = NULL;         } else            *root = *temp;         free(temp);      } else {         struct Node *temp = minValueNode(root->rightChild);         root->data = temp->data;         root->rightChild = deleteNode(root->rightChild, temp->data);      }   }   if (root == NULL)      return root;   root->height = 1 + max(height(root->leftChild),                     height(root->rightChild));   int balance = getBalance(root);   if (balance > 1 && getBalance(root->leftChild) >= 0)      return rightRotate(root);   if (balance > 1 && getBalance(root->leftChild) < 0) {      root->leftChild = leftRotate(root->leftChild);      return rightRotate(root);   }   if (balance < -1 && getBalance(root->rightChild) <= 0)      return leftRotate(root);   if (balance < -1 && getBalance(root->rightChild) > 0) {      root->rightChild = rightRotate(root->rightChild);      return leftRotate(root);   }   return root;}// Print the treevoid printTree(struct Node *root){   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->rightChild);   }}int main(){   struct Node *root = NULL;   root = insertNode(root, 22);   root = insertNode(root, 14);   root = insertNode(root, 72);   root = insertNode(root, 44);   root = insertNode(root, 25);   root = insertNode(root, 63);   root = insertNode(root, 98);   printf("AVL Tree: ");   printTree(root);   root = deleteNode(root, 25);   printf("\nAfter deletion: ");   printTree(root);   return 0;}

Output

AVL Tree: 14 22 25 44 63 72 98 After deletion: 14 22 44 63 72 98

#include <iostream>struct Node {   int data;   struct Node *leftChild;   struct Node *rightChild;   int height;};int max(int a, int b);int height(struct Node *N){   if (N == NULL)      return 0;   return N->height;}int max(int a, int b){   return (a > b) ? a : b;}struct Node *newNode(int data){   struct Node *node = (struct Node *) malloc(sizeof(struct Node));   node->data = data;   node->leftChild = NULL;   node->rightChild = NULL;   node->height = 1;   return (node);}struct Node *rightRotate(struct Node *y){   struct Node *x = y->leftChild;   struct Node *T2 = x->rightChild;   x->rightChild = y;   y->leftChild = T2;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   return x;}struct Node *leftRotate(struct Node *x){   struct Node *y = x->rightChild;   struct Node *T2 = y->leftChild;   y->leftChild = x;   x->rightChild = T2;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   return y;}int getBalance(struct Node *N){   if (N == NULL)      return 0;   return height(N->leftChild) - height(N->rightChild);}struct Node *insertNode(struct Node *node, int data){   if (node == NULL)      return (newNode(data));   if (data < node->data)      node->leftChild = insertNode(node->leftChild, data);   else if (data > node->data)      node->rightChild = insertNode(node->rightChild, data);   else      return node;   node->height = 1 + max(height(node->leftChild),                     height(node->rightChild));   int balance = getBalance(node);   if (balance > 1 && data < node->leftChild->data)      return rightRotate(node);   if (balance < -1 && data > node->rightChild->data)      return leftRotate(node);   if (balance > 1 && data > node->leftChild->data) {      node->leftChild = leftRotate(node->leftChild);      return rightRotate(node);   }   if (balance < -1 && data < node->rightChild->data) {      node->rightChild = rightRotate(node->rightChild);      return leftRotate(node);   }   return node;}struct Node *minValueNode(struct Node *node){   struct Node *current = node;   while (current->leftChild != NULL)      current = current->leftChild;   return current;}struct Node *deleteNode(struct Node *root, int data){   if (root == NULL)      return root;   if (data < root->data)      root->leftChild = deleteNode(root->leftChild, data);   else if (data > root->data)      root->rightChild = deleteNode(root->rightChild, data);   else {      if ((root->leftChild == NULL) || (root->rightChild == NULL)) {         struct Node *temp = root->leftChild ? root->leftChild : root->rightChild;         if (temp == NULL) {            temp = root;            root = NULL;         } else            *root = *temp;         free(temp);      } else {         struct Node *temp = minValueNode(root->rightChild);         root->data = temp->data;         root->rightChild = deleteNode(root->rightChild, temp->data);      }   }   if (root == NULL)      return root;   root->height = 1 + max(height(root->leftChild),                     height(root->rightChild));   int balance = getBalance(root);   if (balance > 1 && getBalance(root->leftChild) >= 0)      return rightRotate(root);   if (balance > 1 && getBalance(root->leftChild) < 0) {      root->leftChild = leftRotate(root->leftChild);      return rightRotate(root);   }   if (balance < -1 && getBalance(root->rightChild) <= 0)      return leftRotate(root);   if (balance < -1 && getBalance(root->rightChild) > 0) {      root->rightChild = rightRotate(root->rightChild);      return leftRotate(root);   }   return root;}// Print the treevoid printTree(struct Node *root){   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->rightChild);   }}int main(){   struct Node *root = NULL;   root = insertNode(root, 22);   root = insertNode(root, 14);   root = insertNode(root, 72);   root = insertNode(root, 44);   root = insertNode(root, 25);   root = insertNode(root, 63);   root = insertNode(root, 98);   printf("AVL Tree: ");   printTree(root);   root = deleteNode(root, 25);   printf("\nAfter deletion: ");   printTree(root);   return 0;}

Output

AVL Tree: 14 22 25 44 63 72 98 After deletion: 14 22 44 63 72 98

import java.util.*;import java.io.*;class Node {   int key, height;   Node left, right;   Node (int d) {      key = d;      height = 1;   }}public class AVLTree {   Node root;   int height (Node N) {      if (N == null)         return 0;      return N.height;   }   int max (int a, int b) {      return (a > b) ? a : b;   }   Node rightRotate (Node y) {      Node x = y.left;      Node T2 = x.right;      x.right = y;      y.left = T2;      y.height = max (height (y.left), height (y.right)) + 1;      x.height = max (height (x.left), height (x.right)) + 1;      return x;   }   Node leftRotate (Node x) {      Node y = x.right;      Node T2 = y.left;      y.left = x;      x.right = T2;      x.height = max (height (x.left), height (x.right)) + 1;      y.height = max (height (y.left), height (y.right)) + 1;      return y;   }   int getBalance (Node N) {      if (N == null)         return 0;      return height (N.left) - height (N.right);   }   Node minValueNode (Node node) {      Node current = node;      while (current.left != null)         current = current.left;      return current;   }   Node deleteNode (Node root, int key) {      if (root == null)         return root;      if (key < root.key)         root.left = deleteNode (root.left, key);      else if (key > root.key)         root.right = deleteNode (root.right, key);      else {         if ((root.left == null) || (root.right == null)) {            Node temp = null;            if (temp == root.left)               temp = root.right;            else               temp = root.left;            if (temp == null) {               temp = root;               root = null;            } else               root = temp;         } else {            Node temp = minValueNode (root.right);            root.key = temp.key;            root.right = deleteNode (root.right, temp.key);         }      }      if (root == null)         return root;      root.height = max (height (root.left), height (root.right)) + 1;      int balance = getBalance (root);      if (balance > 1 && getBalance (root.left) >= 0)         return rightRotate (root);      if (balance > 1 && getBalance (root.left) < 0) {         root.left = leftRotate (root.left);         return rightRotate (root);      }      if (balance < -1 && getBalance (root.right) <= 0)         return leftRotate (root);      if (balance < -1 && getBalance (root.right) > 0) {         root.right = rightRotate (root.right);         return leftRotate (root);      }      return root;   }   public void printTree(Node root) {      if (root == null) return;      printTree(root.left);      System.out.print(root.key + " ");      printTree(root.right);   }   public static void main (String[]args) {      AVLTree tree = new AVLTree();      tree.root = new Node(13);      tree.root.left = new Node(12);      tree.root.left.left = new Node(11);      tree.root.left.left.left = new Node(10);      tree.root.right = new Node(14);      tree.root.right.right = new Node(15);      System.out.println("The AVL Tree is: ");      tree.printTree(tree.root);      tree.root = tree.deleteNode (tree.root, 10);      System.out.println("\n----------------------------------------------\n");      System.out.println("The AVL Tree after deleting 10 is: ");      tree.printTree(tree.root);      System.out.println ("");   }}

Output

The AVL Tree is: 10 11 12 13 14 15 ----------------------------------------------The AVL Tree after deleting 10 is: 11 12 13 14 15

class Node(object):   def __init__(self, data):      self.data = data      self.left = None      self.right = None      self.height = 1class AVLTree(object):   def insert(self, root, key):      if not root:         return Node(key)      elif key < root.data:         root.left = self.insert(root.left, key)      else:         root.right = self.insert(root.right, key)      root.h = 1 + max(self.getHeight(root.left),         self.getHeight(root.right))      b = self.getBalance(root)      if b > 1 and key < root.left.data:         return self.rightRotate(root)      if b < -1 and key > root.right.data:         return self.leftRotate(root)      if b > 1 and key > root.left.data:         root.left = self.lefttRotate(root.left)         return self.rightRotate(root)      if b < -1 and key < root.right.data:          root.right = self.rightRotate(root.right)          return self.leftRotate(root)      return root   def delete(self, root, key):      if not root:         return root      elif key < root.data:         root.left = self.delete(root.left, key)      elif key > root.data:         root.right = self.delete(root.right, key)      else:         if root.left is None:            temp = root.right            root = None            return temp         elif root.right is None:            temp = root.left            root = None            return temp         temp = self.getMindataueNode(root.right)         root.data = temp.data         root.right = self.delete(root.right, temp.data)      if root is None:         return root      root.height = 1 + max(self.getHeight(root.left), self.getHeight(root.right))      balance = self.getBalance(root)      if balance > 1 and self.getBalance(root.left) >= 0:         return self.rightRotate(root)      if balance < -1 and self.getBalance(root.right) <= 0:         return self.leftRotate(root)      if balance > 1 and self.getBalance(root.left) < 0:         root.left = self.leftRotate(root.left)         return self.rightRotate(root)      if balance < -1 and self.getBalance(root.right) > 0:         root.right = self.rightRotate(root.right)         return self.leftRotate(root)      return root   def leftRotate(self, z):      y = z.right      T2 = y.left      y.left = z      z.right = T2      z.height = 1 + max(self.getHeight(z.left),         self.getHeight(z.right))      y.height = 1 + max(self.getHeight(y.left),         self.getHeight(y.right))      return y   def rightRotate(self, z):      y = z.left      T3 = y.right      y.right = z      z.left = T3      z.height = 1 + max(self.getHeight(z.left),         self.getHeight(z.right))      y.height = 1 + max(self.getHeight(y.left),         self.getHeight(y.right))      return y   def getHeight(self, root):      if not root:         return 0      return root.height   def getBalance(self, root):      if not root:         return 0      return self.getHeight(root.left) - self.getHeight(root.right)   def Inorder(self, root):      if root.left:         self.Inorder(root.left)      print(root.data)      if root.right:         self.Inorder(root.right)Tree = AVLTree()root = Noneroot = Tree.insert(root, 10)root = Tree.insert(root, 13)root = Tree.insert(root, 11)root = Tree.insert(root, 14)root = Tree.insert(root, 12)root = Tree.insert(root, 15)# Inorder Traversalprint("Inorder traversal of the AVL tree is")Tree.Inorder(root)root = Tree.delete(root, 14)print("Inorder traversal of the modified AVL tree is")Tree.Inorder(root)

Output

Inorder traversal of the AVL tree is101112131415Inorder traversal of the modified AVL tree is1011121315

#include <stdio.h>#include <stdlib.h>struct Node {   int data;   struct Node *leftChild;   struct Node *rightChild;   int height;};int max(int a, int b);int height(struct Node *N){   if (N == NULL)      return 0;   return N->height;}int max(int a, int b){   return (a > b) ? a : b;}struct Node *newNode(int data){   struct Node *node = (struct Node *) malloc(sizeof(struct Node));   node->data = data;   node->leftChild = NULL;   node->rightChild = NULL;   node->height = 1;   return (node);}struct Node *rightRotate(struct Node *y){   struct Node *x = y->leftChild;   struct Node *T2 = x->rightChild;   x->rightChild = y;   y->leftChild = T2;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   return x;}struct Node *leftRotate(struct Node *x){   struct Node *y = x->rightChild;   struct Node *T2 = y->leftChild;   y->leftChild = x;   x->rightChild = T2;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   return y;}int getBalance(struct Node *N){   if (N == NULL)      return 0;   return height(N->leftChild) - height(N->rightChild);}struct Node *insertNode(struct Node *node, int data){   if (node == NULL)      return (newNode(data));   if (data < node->data)      node->leftChild = insertNode(node->leftChild, data);   else if (data > node->data)      node->rightChild = insertNode(node->rightChild, data);   else      return node;   node->height = 1 + max(height(node->leftChild),                     height(node->rightChild));   int balance = getBalance(node);   if (balance > 1 && data < node->leftChild->data)      return rightRotate(node);   if (balance < -1 && data > node->rightChild->data)      return leftRotate(node);   if (balance > 1 && data > node->leftChild->data) {      node->leftChild = leftRotate(node->leftChild);      return rightRotate(node);   }   if (balance < -1 && data < node->rightChild->data) {      node->rightChild = rightRotate(node->rightChild);      return leftRotate(node);   }   return node;}struct Node *minValueNode(struct Node *node){   struct Node *current = node;   while (current->leftChild != NULL)      current = current->leftChild;   return current;}struct Node *deleteNode(struct Node *root, int data){   if (root == NULL)      return root;   if (data < root->data)      root->leftChild = deleteNode(root->leftChild, data);   else if (data > root->data)      root->rightChild = deleteNode(root->rightChild, data);   else {      if ((root->leftChild == NULL) || (root->rightChild == NULL)) {         struct Node *temp = root->leftChild ? root->leftChild : root->rightChild;         if (temp == NULL) {            temp = root;            root = NULL;         } else            *root = *temp;         free(temp);      } else {         struct Node *temp = minValueNode(root->rightChild);         root->data = temp->data;         root->rightChild = deleteNode(root->rightChild, temp->data);      }   }   if (root == NULL)      return root;   root->height = 1 + max(height(root->leftChild),                     height(root->rightChild));   int balance = getBalance(root);   if (balance > 1 && getBalance(root->leftChild) >= 0)      return rightRotate(root);   if (balance > 1 && getBalance(root->leftChild) < 0) {      root->leftChild = leftRotate(root->leftChild);      return rightRotate(root);   }   if (balance < -1 && getBalance(root->rightChild) <= 0)      return leftRotate(root);   if (balance < -1 && getBalance(root->rightChild) > 0) {      root->rightChild = rightRotate(root->rightChild);      return leftRotate(root);   }   return root;}// Print the treevoid printTree(struct Node *root){   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->rightChild);   }}int main(){   struct Node *root = NULL;   root = insertNode(root, 22);   root = insertNode(root, 14);   root = insertNode(root, 72);   root = insertNode(root, 44);   root = insertNode(root, 25);   root = insertNode(root, 63);   root = insertNode(root, 98);   printf("AVL Tree: ");   printTree(root);   root = deleteNode(root, 25);   printf("\nAfter deletion: ");   printTree(root);   return 0;}

Output

AVL Tree: 14 22 25 44 63 72 98 After deletion: 14 22 44 63 72 98

#include <iostream>struct Node {   int data;   struct Node *leftChild;   struct Node *rightChild;   int height;};int max(int a, int b);int height(struct Node *N){   if (N == NULL)      return 0;   return N->height;}int max(int a, int b){   return (a > b) ? a : b;}struct Node *newNode(int data){   struct Node *node = (struct Node *) malloc(sizeof(struct Node));   node->data = data;   node->leftChild = NULL;   node->rightChild = NULL;   node->height = 1;   return (node);}struct Node *rightRotate(struct Node *y){   struct Node *x = y->leftChild;   struct Node *T2 = x->rightChild;   x->rightChild = y;   y->leftChild = T2;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   return x;}struct Node *leftRotate(struct Node *x){   struct Node *y = x->rightChild;   struct Node *T2 = y->leftChild;   y->leftChild = x;   x->rightChild = T2;   x->height = max(height(x->leftChild), height(x->rightChild)) + 1;   y->height = max(height(y->leftChild), height(y->rightChild)) + 1;   return y;}int getBalance(struct Node *N){   if (N == NULL)      return 0;   return height(N->leftChild) - height(N->rightChild);}struct Node *insertNode(struct Node *node, int data){   if (node == NULL)      return (newNode(data));   if (data < node->data)      node->leftChild = insertNode(node->leftChild, data);   else if (data > node->data)      node->rightChild = insertNode(node->rightChild, data);   else      return node;   node->height = 1 + max(height(node->leftChild),                     height(node->rightChild));   int balance = getBalance(node);   if (balance > 1 && data < node->leftChild->data)      return rightRotate(node);   if (balance < -1 && data > node->rightChild->data)      return leftRotate(node);   if (balance > 1 && data > node->leftChild->data) {      node->leftChild = leftRotate(node->leftChild);      return rightRotate(node);   }   if (balance < -1 && data < node->rightChild->data) {      node->rightChild = rightRotate(node->rightChild);      return leftRotate(node);   }   return node;}struct Node *minValueNode(struct Node *node){   struct Node *current = node;   while (current->leftChild != NULL)      current = current->leftChild;   return current;}struct Node *deleteNode(struct Node *root, int data){   if (root == NULL)      return root;   if (data < root->data)      root->leftChild = deleteNode(root->leftChild, data);   else if (data > root->data)      root->rightChild = deleteNode(root->rightChild, data);   else {      if ((root->leftChild == NULL) || (root->rightChild == NULL)) {         struct Node *temp = root->leftChild ? root->leftChild : root->rightChild;         if (temp == NULL) {            temp = root;            root = NULL;         } else            *root = *temp;         free(temp);      } else {         struct Node *temp = minValueNode(root->rightChild);         root->data = temp->data;         root->rightChild = deleteNode(root->rightChild, temp->data);      }   }   if (root == NULL)      return root;   root->height = 1 + max(height(root->leftChild),                     height(root->rightChild));   int balance = getBalance(root);   if (balance > 1 && getBalance(root->leftChild) >= 0)      return rightRotate(root);   if (balance > 1 && getBalance(root->leftChild) < 0) {      root->leftChild = leftRotate(root->leftChild);      return rightRotate(root);   }   if (balance < -1 && getBalance(root->rightChild) <= 0)      return leftRotate(root);   if (balance < -1 && getBalance(root->rightChild) > 0) {      root->rightChild = rightRotate(root->rightChild);      return leftRotate(root);   }   return root;}// Print the treevoid printTree(struct Node *root){   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->rightChild);   }}int main(){   struct Node *root = NULL;   root = insertNode(root, 22);   root = insertNode(root, 14);   root = insertNode(root, 72);   root = insertNode(root, 44);   root = insertNode(root, 25);   root = insertNode(root, 63);   root = insertNode(root, 98);   printf("AVL Tree: ");   printTree(root);   root = deleteNode(root, 25);   printf("\nAfter deletion: ");   printTree(root);   return 0;}

Output

AVL Tree: 14 22 25 44 63 72 98 After deletion: 14 22 44 63 72 98

import java.util.*;import java.io.*;class Node {   int key, height;   Node left, right;   Node (int d) {      key = d;      height = 1;   }}public class AVLTree {   Node root;   int height (Node N) {      if (N == null)         return 0;      return N.height;   }   int max (int a, int b) {      return (a > b) ? a : b;   }   Node rightRotate (Node y) {      Node x = y.left;      Node T2 = x.right;      x.right = y;      y.left = T2;      y.height = max (height (y.left), height (y.right)) + 1;      x.height = max (height (x.left), height (x.right)) + 1;      return x;   }   Node leftRotate (Node x) {      Node y = x.right;      Node T2 = y.left;      y.left = x;      x.right = T2;      x.height = max (height (x.left), height (x.right)) + 1;      y.height = max (height (y.left), height (y.right)) + 1;      return y;   }   int getBalance (Node N) {      if (N == null)         return 0;      return height (N.left) - height (N.right);   }   Node insert (Node node, int key) {      if (node == null)         return (new Node (key));      if (key < node.key)         node.left = insert (node.left, key);      else if (key > node.key)         node.right = insert (node.right, key);      else         return node;      node.height = 1 + max (height (node.left), height (node.right));      int balance = getBalance (node);      if (balance > 1 && key < node.left.key)         return rightRotate (node);      if (balance < -1 && key > node.right.key)         return leftRotate (node);      if (balance > 1 && key > node.left.key) {         node.left = leftRotate (node.left);         return rightRotate (node);      }      if (balance < -1 && key < node.right.key) {         node.right = rightRotate (node.right);         return leftRotate (node);      }      return node;   }   Node minValueNode (Node node) {      Node current = node;      while (current.left != null)         current = current.left;      return current;   }   Node deleteNode (Node root, int key) {      if (root == null)         return root;      if (key < root.key)         root.left = deleteNode (root.left, key);      else if (key > root.key)         root.right = deleteNode (root.right, key);      else {         if ((root.left == null) || (root.right == null)) {            Node temp = null;            if (temp == root.left)               temp = root.right;            else               temp = root.left;            if (temp == null) {               temp = root;               root = null;            } else               root = temp;         } else {            Node temp = minValueNode (root.right);            root.key = temp.key;            root.right = deleteNode (root.right, temp.key);         }      }      if (root == null)         return root;      root.height = max (height (root.left), height (root.right)) + 1;      int balance = getBalance (root);      if (balance > 1 && getBalance (root.left) >= 0)         return rightRotate (root);      if (balance > 1 && getBalance (root.left) < 0) {         root.left = leftRotate (root.left);         return rightRotate (root);      }      if (balance < -1 && getBalance (root.right) <= 0)         return leftRotate (root);      if (balance < -1 && getBalance (root.right) > 0) {         root.right = rightRotate (root.right);         return leftRotate (root);      }      return root;   }   public void printTree(Node root) {      if (root == null) return;      printTree(root.left);      System.out.println(root.key);      printTree(root.right);   }   public static void main (String[]args) {      AVLTree tree = new AVLTree();      tree.root = tree.insert (tree.root, 10);      tree.root = tree.insert (tree.root, 11);      tree.root = tree.insert (tree.root, 12);      tree.root = tree.insert (tree.root, 13);      tree.root = tree.insert (tree.root, 14);      tree.root = tree.insert (tree.root, 15);      System.out.println("The AVL Tree is: ");      tree.printTree(tree.root);      tree.root = tree.deleteNode (tree.root, 10);      System.out.println("\n----------------------------------------------\n");      System.out.println("The AVL Tree after deleting 10 is: ");      tree.printTree(tree.root);      System.out.println ("");   }}

Output

The AVL Tree is:101112131415----------------------------------------------The AVL Tree after deleting 10 is:1112131415

class Node(object):   def __init__(self, data):      self.data = data      self.left = None      self.right = None      self.height = 1class AVLTree(object):   def insert(self, root, key):      if not root:         return Node(key)      elif key < root.data:         root.left = self.insert(root.left, key)      else:         root.right = self.insert(root.right, key)      root.h = 1 + max(self.getHeight(root.left),         self.getHeight(root.right))      b = self.getBalance(root)      if b > 1 and key < root.left.data:         return self.rightRotate(root)      if b < -1 and key > root.right.data:         return self.leftRotate(root)      if b > 1 and key > root.left.data:         root.left = self.lefttRotate(root.left)         return self.rightRotate(root)      if b < -1 and key < root.right.data:         root.right = self.rightRotate(root.right)         return self.leftRotate(root)      return root   def delete(self, root, key):      if not root:         return root      elif key < root.data:         root.left = self.delete(root.left, key)      elif key > root.data:         root.right = self.delete(root.right, key)      else:         if root.left is None:            temp = root.right            root = None            return temp         elif root.right is None:            temp = root.left            root = None            return temp         temp = self.getMindataueNode(root.right)         root.data = temp.data         root.right = self.delete(root.right, temp.data)      if root is None:         return root      root.height = 1 + max(self.getHeight(root.left), self.getHeight(root.right))      balance = self.getBalance(root)      if balance > 1 and self.getBalance(root.left) >= 0:         return self.rightRotate(root)      if balance < -1 and self.getBalance(root.right) <= 0:         return self.leftRotate(root)      if balance > 1 and self.getBalance(root.left) < 0:         root.left = self.leftRotate(root.left)         return self.rightRotate(root)      if balance < -1 and self.getBalance(root.right) > 0:         root.right = self.rightRotate(root.right)         return self.leftRotate(root)      return root   def leftRotate(self, z):      y = z.right      T2 = y.left      y.left = z      z.right = T2      z.height = 1 + max(self.getHeight(z.left),         self.getHeight(z.right))      y.height = 1 + max(self.getHeight(y.left),         self.getHeight(y.right))      return y   def rightRotate(self, z):      y = z.left      T3 = y.right      y.right = z      z.left = T3      z.height = 1 + max(self.getHeight(z.left),         self.getHeight(z.right))      y.height = 1 + max(self.getHeight(y.left),         self.getHeight(y.right))      return y   def getHeight(self, root):      if not root:         return 0      return root.height   def getBalance(self, root):      if not root:         return 0      return self.getHeight(root.left) - self.getHeight(root.right)   def Inorder(self, root):      if root.left:         self.Inorder(root.left)      print(root.data)      if root.right:         self.Inorder(root.right)Tree = AVLTree()root = Noneroot = Tree.insert(root, 10)root = Tree.insert(root, 13)root = Tree.insert(root, 11)root = Tree.insert(root, 14)root = Tree.insert(root, 12)root = Tree.insert(root, 15)# Inorder Traversalprint("Inorder traversal of the AVL tree is")Tree.Inorder(root)root = Tree.delete(root, 14)print("Inorder traversal of the modified AVL tree is")Tree.Inorder(root)

Output

Inorder traversal of the AVL tree is101112131415Inorder traversal of the modified AVL tree is1011121315

Output

// C++ program for Red black trees algorithmn#include <iostream>using namespace std;struct Node {  int data;  Node *parent;  Node *left;  Node *right;  int color;};typedef Node *NodePtr;class RedBlackTree {   private:  NodePtr root;  NodePtr TNULL;  void initializeNULLNode(NodePtr node, NodePtr parent) {    node->data = 0;    node->parent = parent;    node->left = nullptr;    node->right = nullptr;    node->color = 0;  }  // Preorder  void preOrderHelper(NodePtr node) {    if (node != TNULL) {      cout << node->data << " ";      preOrderHelper(node->left);      preOrderHelper(node->right);    }  }  // Inorder  void inOrderHelper(NodePtr node) {    if (node != TNULL) {      inOrderHelper(node->left);      cout << node->data << " ";      inOrderHelper(node->right);    }  }  // Post order  void postOrderHelper(NodePtr node) {    if (node != TNULL) {      postOrderHelper(node->left);      postOrderHelper(node->right);      cout << node->data << " ";    }  }  NodePtr searchTreeHelper(NodePtr node, int key) {    if (node == TNULL || key == node->data) {      return node;    }    if (key < node->data) {      return searchTreeHelper(node->left, key);    }    return searchTreeHelper(node->right, key);  }  // For balancing the tree after deletion  void deleteFix(NodePtr x) {    NodePtr s;    while (x != root && x->color == 0) {      if (x == x->parent->left) {        s = x->parent->right;        if (s->color == 1) {          s->color = 0;          x->parent->color = 1;          leftRotate(x->parent);          s = x->parent->right;        }        if (s->left->color == 0 && s->right->color == 0) {          s->color = 1;          x = x->parent;        } else {          if (s->right->color == 0) {            s->left->color = 0;            s->color = 1;            rightRotate(s);            s = x->parent->right;          }          s->color = x->parent->color;          x->parent->color = 0;          s->right->color = 0;          leftRotate(x->parent);          x = root;        }      } else {        s = x->parent->left;        if (s->color == 1) {          s->color = 0;          x->parent->color = 1;          rightRotate(x->parent);          s = x->parent->left;        }        if (s->right->color == 0 && s->right->color == 0) {          s->color = 1;          x = x->parent;        } else {          if (s->left->color == 0) {            s->right->color = 0;            s->color = 1;            leftRotate(s);            s = x->parent->left;          }          s->color = x->parent->color;          x->parent->color = 0;          s->left->color = 0;          rightRotate(x->parent);          x = root;        }      }    }    x->color = 0;  }  void rbTransplant(NodePtr u, NodePtr v) {    if (u->parent == nullptr) {      root = v;    } else if (u == u->parent->left) {      u->parent->left = v;    } else {      u->parent->right = v;    }    v->parent = u->parent;  }  void deleteNodeHelper(NodePtr node, int key) {    NodePtr z = TNULL;    NodePtr x, y;    while (node != TNULL) {      if (node->data == key) {        z = node;      }      if (node->data <= key) {        node = node->right;      } else {        node = node->left;      }    }    if (z == TNULL) {      cout << "Key not found in the tree" << endl;      return;    }    y = z;    int y_original_color = y->color;    if (z->left == TNULL) {      x = z->right;      rbTransplant(z, z->right);    } else if (z->right == TNULL) {      x = z->left;      rbTransplant(z, z->left);    } else {      y = minimum(z->right);      y_original_color = y->color;      x = y->right;      if (y->parent == z) {        x->parent = y;      } else {        rbTransplant(y, y->right);        y->right = z->right;        y->right->parent = y;      }      rbTransplant(z, y);      y->left = z->left;      y->left->parent = y;      y->color = z->color;    }    delete z;    if (y_original_color == 0) {      deleteFix(x);    }  }  // For balancing the tree after insertion  void insertFix(NodePtr k) {    NodePtr u;    while (k->parent->color == 1) {      if (k->parent == k->parent->parent->right) {        u = k->parent->parent->left;        if (u->color == 1) {          u->color = 0;          k->parent->color = 0;          k->parent->parent->color = 1;          k = k->parent->parent;        } else {          if (k == k->parent->left) {            k = k->parent;            rightRotate(k);          }          k->parent->color = 0;          k->parent->parent->color = 1;          leftRotate(k->parent->parent);        }      } else {        u = k->parent->parent->right;        if (u->color == 1) {          u->color = 0;          k->parent->color = 0;          k->parent->parent->color = 1;          k = k->parent->parent;        } else {          if (k == k->parent->right) {            k = k->parent;            leftRotate(k);          }          k->parent->color = 0;          k->parent->parent->color = 1;          rightRotate(k->parent->parent);        }      }      if (k == root) {        break;      }    }    root->color = 0;  }  void printHelper(NodePtr root, string indent, bool last) {    if (root != TNULL) {      cout << indent;      if (last) {        cout << "R----";        indent += "   ";      } else {        cout << "L----";        indent += "|  ";      }      string sColor = root->color ? "RED" : "BLACK";      cout << root->data << "(" << sColor << ")" << endl;      printHelper(root->left, indent, false);      printHelper(root->right, indent, true);    }  }   public:  RedBlackTree() {    TNULL = new Node;    TNULL->color = 0;    TNULL->left = nullptr;    TNULL->right = nullptr;    root = TNULL;  }  void preorder() {    preOrderHelper(this->root);  }  void inorder() {    inOrderHelper(this->root);  }  void postorder() {    postOrderHelper(this->root);  }  NodePtr searchTree(int k) {    return searchTreeHelper(this->root, k);  }  NodePtr minimum(NodePtr node) {    while (node->left != TNULL) {      node = node->left;    }    return node;  }  NodePtr maximum(NodePtr node) {    while (node->right != TNULL) {      node = node->right;    }    return node;  }  NodePtr successor(NodePtr x) {    if (x->right != TNULL) {      return minimum(x->right);    }    NodePtr y = x->parent;    while (y != TNULL && x == y->right) {      x = y;      y = y->parent;    }    return y;  }  NodePtr predecessor(NodePtr x) {    if (x->left != TNULL) {      return maximum(x->left);    }    NodePtr y = x->parent;    while (y != TNULL && x == y->left) {      x = y;      y = y->parent;    }    return y;  }  void leftRotate(NodePtr x) {    NodePtr y = x->right;    x->right = y->left;    if (y->left != TNULL) {      y->left->parent = x;    }    y->parent = x->parent;    if (x->parent == nullptr) {      this->root = y;    } else if (x == x->parent->left) {      x->parent->left = y;    } else {      x->parent->right = y;    }    y->left = x;    x->parent = y;  }  void rightRotate(NodePtr x) {    NodePtr y = x->left;    x->left = y->right;    if (y->right != TNULL) {      y->right->parent = x;    }    y->parent = x->parent;    if (x->parent == nullptr) {      this->root = y;    } else if (x == x->parent->right) {      x->parent->right = y;    } else {      x->parent->left = y;    }    y->right = x;    x->parent = y;  }  // Inserting a node  void insert(int key) {    NodePtr node = new Node;    node->parent = nullptr;    node->data = key;    node->left = TNULL;    node->right = TNULL;    node->color = 1;    NodePtr y = nullptr;    NodePtr x = this->root;    while (x != TNULL) {      y = x;      if (node->data < x->data) {        x = x->left;      } else {        x = x->right;      }    }    node->parent = y;    if (y == nullptr) {      root = node;    } else if (node->data < y->data) {      y->left = node;    } else {      y->right = node;    }    if (node->parent == nullptr) {      node->color = 0;      return;    }    if (node->parent->parent == nullptr) {      return;    }    insertFix(node);  }  NodePtr getRoot() {    return this->root;  }  void deleteNode(int data) {    deleteNodeHelper(this->root, data);  }  void printTree() {    if (root) {      printHelper(this->root, "", true);    }  }};int main() {  RedBlackTree V;    V.insert(24);    V.insert(33);    V.insert(42);    V.insert(51);    V.insert(60);    V.insert(40);    V.insert(22);  V.printTree();  cout << endl     << "After deleting an element" << endl;  V.deleteNode(40);  V.printTree();}

Output

R----33(BLACK)   L----24(BLACK)   |  L----22(RED)   R----51(RED)      L----42(BLACK)      |  L----40(RED)      R----60(BLACK)After deleting an elementR----33(BLACK)   L----24(BLACK)   |  L----22(RED)   R----51(RED)      L----42(BLACK)      R----60(BLACK)

// Implementing Red-Black Tree in Javaclass Node {    int data;    Node parent;    Node left;    Node right;    int color;}public class RedBlackTree {    private Node root;    private Node TNULL;    // Preorder    private void preOrderHelper(Node node) {        if (node != TNULL) {            System.out.print(node.data + " ");            preOrderHelper(node.left);            preOrderHelper(node.right);        }    }    // Inorder    private void inOrderHelper(Node node) {        if (node != TNULL) {            inOrderHelper(node.left);            System.out.print(node.data + " ");            inOrderHelper(node.right);        }    }    // Post order    private void postOrderHelper(Node node) {        if (node != TNULL) {            postOrderHelper(node.left);            postOrderHelper(node.right);            System.out.print(node.data + " ");        }    }    // Search the tree    private Node searchTreeHelper(Node node, int key) {        if (node == TNULL || key == node.data) {            return node;        }        if (key < node.data) {            return searchTreeHelper(node.left, key);        }        return searchTreeHelper(node.right, key);    }    // Balance the tree after deletion of a node    private void fixDelete(Node x) {        Node s;        while (x != root && x.color == 0) {            if (x == x.parent.left) {                s = x.parent.right;                if (s.color == 1) {                    s.color = 0;                    x.parent.color = 1;                    leftRotate(x.parent);                    s = x.parent.right;                }                if (s.left.color == 0 && s.right.color == 0) {                    s.color = 1;                    x = x.parent;                } else {                    if (s.right.color == 0) {                        s.left.color = 0;                        s.color = 1;                        rightRotate(s);                        s = x.parent.right;                    }                    s.color = x.parent.color;                    x.parent.color = 0;                    s.right.color = 0;                    leftRotate(x.parent);                    x = root;                }            } else {                s = x.parent.left;                if (s.color == 1) {                    s.color = 0;                    x.parent.color = 1;                    rightRotate(x.parent);                    s = x.parent.left;                }                if (s.right.color == 0 && s.right.color == 0) {                    s.color = 1;                    x = x.parent;                } else {                    if (s.left.color == 0) {                        s.right.color = 0;                        s.color = 1;                        leftRotate(s);                        s = x.parent.left;                    }                    s.color = x.parent.color;                    x.parent.color = 0;                    s.left.color = 0;                    rightRotate(x.parent);                    x = root;                }            }        }        x.color = 0;    }    private void rbTransplant(Node u, Node v) {        if (u.parent == null) {            root = v;        } else if (u == u.parent.left) {            u.parent.left = v;        } else {            u.parent.right = v;        }        v.parent = u.parent;    }    private void deleteNodeHelper(Node node, int key) {        Node z = TNULL;        Node x, y;        while (node != TNULL) {            if (node.data == key) {                z = node;            }            if (node.data <= key) {                node = node.right;            } else {                node = node.left;            }        }        if (z == TNULL) {            System.out.println("Couldn't find key in the tree");            return;        }        y = z;        int yOriginalColor = y.color;        if (z.left == TNULL) {            x = z.right;            rbTransplant(z, z.right);        } else if (z.right == TNULL) {            x = z.left;            rbTransplant(z, z.left);        } else {            y = minimum(z.right);            yOriginalColor = y.color;            x = y.right;            if (y.parent == z) {                x.parent = y;            } else {                rbTransplant(y, y.right);                y.right = z.right;                y.right.parent = y;            }            rbTransplant(z, y);            y.left = z.left;            y.left.parent = y;            y.color = z.color;        }        if (yOriginalColor == 0) {            fixDelete(x);        }    }    // Balance the node after insertion    private void fixInsert(Node k) {        Node u;        while (k.parent.color == 1) {            if (k.parent == k.parent.parent.right) {                u = k.parent.parent.left;                if (u.color == 1) {                    u.color = 0;                    k.parent.color = 0;                    k.parent.parent.color = 1;                    k = k.parent.parent;                } else {                    if (k == k.parent.left) {                        k = k.parent;                        rightRotate(k);                    }                    k.parent.color = 0;                    k.parent.parent.color = 1;                    leftRotate(k.parent.parent);                }            } else {                u = k.parent.parent.right;                if (u.color == 1) {                    u.color = 0;                    k.parent.color = 0;                    k.parent.parent.color = 1;                    k = k.parent.parent;                } else {                    if (k == k.parent.right) {                        k = k.parent;                        leftRotate(k);                    }                    k.parent.color = 0;                    k.parent.parent.color = 1;                    rightRotate(k.parent.parent);                }            }            if (k == root) {                break;            }        }        root.color = 0;    }    private void printHelper(Node root, String indent, boolean last) {        if (root != TNULL) {            System.out.print(indent);            if (last) {                System.out.print("R----");                indent += "   ";            } else {                System.out.print("L----");                indent += "|  ";            }            String sColor = root.color == 1 ? "RED" : "BLACK";            System.out.println(root.data + "(" + sColor + ")");            printHelper(root.left, indent, false);            printHelper(root.right, indent, true);        }    }    public RedBlackTree() {        TNULL = new Node();        TNULL.color = 0;        TNULL.left = null;        TNULL.right = null;        root = TNULL;    }    public void preorder() {        preOrderHelper(this.root);    }    public void inorder() {        inOrderHelper(this.root);    }    public void postorder() {        postOrderHelper(this.root);    }    public Node searchTree(int k) {        return searchTreeHelper(this.root, k);    }    public Node minimum(Node node) {        while (node.left != TNULL) {            node = node.left;        }        return node;    }    public Node maximum(Node node) {        while (node.right != TNULL) {            node = node.right;        }        return node;    }    public Node successor(Node x) {        if (x.right != TNULL) {            return minimum(x.right);        }        Node y = x.parent;        while (y != TNULL && x == y.right) {            x = y;            y = y.parent;        }        return y;    }    public Node predecessor(Node x) {        if (x.left != TNULL) {            return maximum(x.left);        }        Node y = x.parent;        while (y != TNULL && x == y.left) {            x = y;            y = y.parent;        }        return y;    }    public void leftRotate(Node x) {        Node y = x.right;        x.right = y.left;        if (y.left != TNULL) {            y.left.parent = x;        }        y.parent = x.parent;        if (x.parent == null) {            this.root = y;        } else if (x == x.parent.left) {            x.parent.left = y;        } else {            x.parent.right = y;        }        y.left = x;        x.parent = y;    }    public void rightRotate(Node x) {        Node y = x.left;        x.left = y.right;        if (y.right != TNULL) {            y.right.parent = x;        }        y.parent = x.parent;        if (x.parent == null) {            this.root = y;        } else if (x == x.parent.right) {            x.parent.right = y;        } else {            x.parent.left = y;        }        y.right = x;        x.parent = y;    }    public void insert(int key) {        Node node = new Node();        node.parent = null;        node.data = key;        node.left = TNULL;        node.right = TNULL;        node.color = 1;        Node y = null;        Node x = this.root;        while (x != TNULL) {            y = x;            if (node.data < x.data) {                x = x.left;            } else {                x = x.right;            }        }        node.parent = y;        if (y == null) {            root = node;        } else if (node.data < y.data) {            y.left = node;        } else {            y.right = node;        }        if (node.parent == null) {            node.color = 0;            return;        }        if (node.parent.parent == null) {            return;        }        fixInsert(node);    }    public Node getRoot() {        return this.root;    }    public void deleteNode(int data) {        deleteNodeHelper(this.root, data);    }    public void printTree() {        printHelper(this.root, "", true);    }    public static void main(String[] args) {        RedBlackTree V = new RedBlackTree();        V.insert(24);        V.insert(33);        V.insert(42);        V.insert(51);        V.insert(60);        V.insert(40);        V.insert(22);        V.printTree();        System.out.println("\nAfter deleting an element:");        V.deleteNode(40);        V.printTree();    }}

Output

R----33(BLACK)   L----24(BLACK)   |  L----22(RED)R----51(RED)L----42(BLACK)|  L----40(RED)      R----60(BLACK)After deleting an element:R----33(BLACK)L----24(BLACK)   |  L----22(RED)R----51(RED)L----42(BLACK)R----60(BLACK)

#python program for Red black treesimport sys# Node creationclass Node():    def __init__(self, item):        self.item = item        self.parent = None        self.left = None        self.right = None        self.color = 1class RedBlackTree():    def __init__(self):        self.TNULL = Node(0)        self.TNULL.color = 0        self.TNULL.left = None        self.TNULL.right = None        self.root = self.TNULL    # Preorder    def pre_order_helper(self, node):        if node != TNULL:            sys.stdout.write(node.item + " ")            self.pre_order_helper(node.left)            self.pre_order_helper(node.right)    # Inorder    def in_order_helper(self, node):        if node != TNULL:            self.in_order_helper(node.left)            sys.stdout.write(node.item + " ")            self.in_order_helper(node.right)    # Postorder    def post_order_helper(self, node):        if node != TNULL:            self.post_order_helper(node.left)            self.post_order_helper(node.right)            sys.stdout.write(node.item + " ")    # Search the tree    def search_tree_helper(self, node, key):        if node == TNULL or key == node.item:            return node        if key < node.item:            return self.search_tree_helper(node.left, key)        return self.search_tree_helper(node.right, key)    # Balancing the tree after deletion    def delete_fix(self, x):        while x != self.root and x.color == 0:            if x == x.parent.left:                s = x.parent.right                if s.color == 1:                    s.color = 0                    x.parent.color = 1                    self.left_rotate(x.parent)                    s = x.parent.right                if s.left.color == 0 and s.right.color == 0:                    s.color = 1                    x = x.parent                else:                    if s.right.color == 0:                        s.left.color = 0                        s.color = 1                        self.right_rotate(s)                        s = x.parent.right                    s.color = x.parent.color                    x.parent.color = 0                    s.right.color = 0                    self.left_rotate(x.parent)                    x = self.root            else:                s = x.parent.left                if s.color == 1:                    s.color = 0                    x.parent.color = 1                    self.right_rotate(x.parent)                    s = x.parent.left                if s.right.color == 0 and s.right.color == 0:                    s.color = 1                    x = x.parent                else:                    if s.left.color == 0:                        s.right.color = 0                        s.color = 1                        self.left_rotate(s)                        s = x.parent.left                    s.color = x.parent.color                    x.parent.color = 0                    s.left.color = 0                    self.right_rotate(x.parent)                    x = self.root        x.color = 0    def __rb_transplant(self, u, v):        if u.parent == None:            self.root = v        elif u == u.parent.left:            u.parent.left = v        else:            u.parent.right = v        v.parent = u.parent    # Node deletion    def delete_node_helper(self, node, key):        z = self.TNULL        while node != self.TNULL:            if node.item == key:                z = node            if node.item <= key:                node = node.right            else:                node = node.left        if z == self.TNULL:            print("Cannot find key in the tree")            return        y = z        y_original_color = y.color        if z.left == self.TNULL:            x = z.right            self.__rb_transplant(z, z.right)        elif (z.right == self.TNULL):            x = z.left            self.__rb_transplant(z, z.left)        else:            y = self.minimum(z.right)            y_original_color = y.color            x = y.right            if y.parent == z:                x.parent = y            else:                self.__rb_transplant(y, y.right)                y.right = z.right                y.right.parent = y            self.__rb_transplant(z, y)            y.left = z.left            y.left.parent = y            y.color = z.color        if y_original_color == 0:            self.delete_fix(x)    # Balance the tree after insertion    def fix_insert(self, k):        while k.parent.color == 1:            if k.parent == k.parent.parent.right:                u = k.parent.parent.left                if u.color == 1:                    u.color = 0                    k.parent.color = 0                    k.parent.parent.color = 1                    k = k.parent.parent                else:                    if k == k.parent.left:                        k = k.parent                        self.right_rotate(k)                    k.parent.color = 0                    k.parent.parent.color = 1                    self.left_rotate(k.parent.parent)            else:                u = k.parent.parent.right                if u.color == 1:                    u.color = 0                    k.parent.color = 0                    k.parent.parent.color = 1                    k = k.parent.parent                else:                    if k == k.parent.right:                        k = k.parent                        self.left_rotate(k)                    k.parent.color = 0                    k.parent.parent.color = 1                    self.right_rotate(k.parent.parent)            if k == self.root:                break        self.root.color = 0    # Printing the tree    def __print_helper(self, node, indent, last):        if node != self.TNULL:            sys.stdout.write(indent)            if last:                sys.stdout.write("R----")                indent += "     "            else:                sys.stdout.write("L----")                indent += "|    "            s_color = "RED" if node.color == 1 else "BLACK"            print(str(node.item) + "(" + s_color + ")")            self.__print_helper(node.left, indent, False)            self.__print_helper(node.right, indent, True)    def preorder(self):        self.pre_order_helper(self.root)    def inorder(self):        self.in_order_helper(self.root)    def postorder(self):        self.post_order_helper(self.root)    def searchTree(self, k):        return self.search_tree_helper(self.root, k)    def minimum(self, node):        while node.left != self.TNULL:            node = node.left        return node    def maximum(self, node):        while node.right != self.TNULL:            node = node.right        return node    def successor(self, x):        if x.right != self.TNULL:            return self.minimum(x.right)        y = x.parent        while y != self.TNULL and x == y.right:            x = y            y = y.parent        return y    def predecessor(self,  x):        if (x.left != self.TNULL):            return self.maximum(x.left)        y = x.parent        while y != self.TNULL and x == y.left:            x = y            y = y.parent        return y    def left_rotate(self, x):        y = x.right        x.right = y.left        if y.left != self.TNULL:            y.left.parent = x        y.parent = x.parent        if x.parent == None:            self.root = y        elif x == x.parent.left:            x.parent.left = y        else:            x.parent.right = y        y.left = x        x.parent = y    def right_rotate(self, x):        y = x.left        x.left = y.right        if y.right != self.TNULL:            y.right.parent = x        y.parent = x.parent        if x.parent == None:            self.root = y        elif x == x.parent.right:            x.parent.right = y        else:            x.parent.left = y        y.right = x        x.parent = y    def insert(self, key):        node = Node(key)        node.parent = None        node.item = key        node.left = self.TNULL        node.right = self.TNULL        node.color = 1        y = None        x = self.root        while x != self.TNULL:            y = x            if node.item < x.item:                x = x.left            else:                x = x.right        node.parent = y        if y == None:            self.root = node        elif node.item < y.item:            y.left = node        else:            y.right = node        if node.parent == None:            node.color = 0            return        if node.parent.parent == None:            return        self.fix_insert(node)    def get_root(self):        return self.root    def delete_node(self, item):        self.delete_node_helper(self.root, item)    def print_tree(self):        self.__print_helper(self.root, "", True)if __name__ == "__main__":    V = RedBlackTree()    V.insert(24)    V.insert(33)    V.insert(42)    V.insert(51)    V.insert(60)    V.insert(40)    V.insert(22)    V.print_tree()    print("\nAfter deleting an element")    V.delete_node(40)    V.print_tree()

Output

R----33(BLACK)     L----24(BLACK)     |    L----22(RED)R----51(RED)          L----42(BLACK)          |    L----40(RED)          R----60(BLACK)After deleting an elementR----33(BLACK)     L----24(BLACK)     |    L----22(RED)     R----51(RED)          L----42(BLACK)          R----60(BLACK)

// C Program for B trees #include <stdio.h>#include <stdlib.h>struct BTree {    //node declaration   int *d;   struct BTree **child_ptr;   int l;   int n;};struct BTree *r = NULL;struct BTree *np = NULL;struct BTree *x = NULL;//creation of nodestruct BTree* init() {   int i;   np = (struct BTree*)malloc(sizeof(struct BTree));   //order 6   np->d = (int*)malloc(6 * sizeof(int));   np->child_ptr = (struct BTree**)malloc(7 * sizeof(struct BTree*));   np->l = 1;   np->n = 0;   for (i = 0; i < 7; i++) {      np->child_ptr[i] = NULL;   }   return np;}//traverse the treevoid traverse(struct BTree *p) {   printf("\n");   int i;   for (i = 0; i < p->n; i++) {      if (p->l == 0) {         traverse(p->child_ptr[i]);      }      printf(" %d", p->d[i]);   }   if (p->l == 0) {      traverse(p->child_ptr[i]);   }   printf("\n");}//sort the treevoid sort(int *p, int n) {   int i, j, t;   for (i = 0; i < n; i++) {      for (j = i; j <= n; j++) {         if (p[i] > p[j]) {            t = p[i];            p[i] = p[j];            p[j] = t;         }      }   }}int split_child(struct BTree *x, int i) {   int j, mid;   struct BTree *np1, *np3, *y;   np3 = init();   //create new node   np3->l = 1;   if (i == -1) {      mid = x->d[2];      //find mid      x->d[2] = 0;      x->n--;      np1 = init();      np1->l = 0;      x->l = 1;      for (j = 3; j < 6; j++) {         np3->d[j - 3] = x->d[j];         np3->child_ptr[j - 3] = x->child_ptr[j];         np3->n++;         x->d[j] = 0;         x->n--;      }      for (j = 0; j < 6; j++) {         x->child_ptr[j] = NULL;      }      np1->d[0] = mid;      np1->child_ptr[np1->n] = x;      np1->child_ptr[np1->n + 1] = np3;      np1->n++;      r = np1;   } else {      y = x->child_ptr[i];      mid = y->d[2];      y->d[2] = 0;      y->n--;      for (j = 3; j < 6; j++) {         np3->d[j - 3] = y->d[j];         np3->n++;         y->d[j] = 0;         y->n--;      }      x->child_ptr[i + 1] = y;      x->child_ptr[i + 1] = np3;   }   return mid;}void insert(int a) {   int i, t;   x = r;   if (x == NULL) {      r = init();      x = r;   } else {      if (x->l == 1 && x->n == 6) {         t = split_child(x, -1);         x = r;         for (i = 0; i < x->n; i++) {            if (a > x->d[i] && a < x->d[i + 1]) {               i++;               break;            } else if (a < x->d[0]) {               break;            } else {               continue;            }         }         x = x->child_ptr[i];      } else {         while (x->l == 0) {            for (i = 0; i < x->n; i++) {               if (a > x->d[i] && a < x->d[i + 1]) {                  i++;                  break;               } else if (a < x->d[0]) {                  break;               } else {                  continue;               }            }            if (x->child_ptr[i]->n == 6) {               t = split_child(x, i);               x->d[x->n] = t;               x->n++;               continue;            } else {               x = x->child_ptr[i];            }         }      }   }   x->d[x->n] = a;   sort(x->d, x->n);   x->n++;}int main() {   int i, n, t;   insert(10);   insert(20);   insert(30);   insert(40);   insert(50);   printf("B tree:\n");   traverse(r);   return 0;}

Output

B tree: 10 20 30 40 50

#include<iostream>using namespace std;struct BTree {//node declaration   int *d;   BTree **child_ptr;   bool l;   int n;}*r = NULL, *np = NULL, *x = NULL;BTree* init() {//creation of node   int i;   np = new BTree;   np->d = new int[6];//order 6   np->child_ptr = new BTree *[7];   np->l = true;   np->n = 0;   for (i = 0; i < 7; i++) {      np->child_ptr[i] = NULL;   }   return np;}void traverse(BTree *p) { //traverse the tree   cout<<endl;   int i;   for (i = 0; i < p->n; i++) {      if (p->l == false) {         traverse(p->child_ptr[i]);      }      cout << " " << p->d[i];   }   if (p->l == false) {      traverse(p->child_ptr[i]);   }   cout<<endl;}void sort(int *p, int n){ //sort the tree   int i, j, t;   for (i = 0; i < n; i++) {      for (j = i; j <= n; j++) {         if (p[i] >p[j]) {            t = p[i];            p[i] = p[j];            p[j] = t;         }      }   }}int split_child(BTree *x, int i) {   int j, mid;   BTree *np1, *np3, *y;   np3 = init();//create new node   np3->l = true;   if (i == -1) {      mid = x->d[2];//find mid      x->d[2] = 0;      x->n--;      np1 = init();      np1->l= false;      x->l= true;      for (j = 3; j < 6; j++) {         np3->d[j - 3] = x->d[j];         np3->child_ptr[j - 3] = x->child_ptr[j];         np3->n++;         x->d[j] = 0;         x->n--;      }      for (j = 0; j < 6; j++) {         x->child_ptr[j] = NULL;      }      np1->d[0] = mid;      np1->child_ptr[np1->n] = x;      np1->child_ptr[np1->n + 1] = np3;      np1->n++;      r = np1;   } else {      y = x->child_ptr[i];      mid = y->d[2];      y->d[2] = 0;      y->n--;      for (j = 3; j <6 ; j++) {         np3->d[j - 3] = y->d[j];         np3->n++;         y->d[j] = 0;         y->n--;      }      x->child_ptr[i + 1] = y;      x->child_ptr[i + 1] = np3;   }   return mid;}void insert(int a) {   int i, t;   x = r;   if (x == NULL) {      r = init();      x = r;   } else {      if (x->l== true && x->n == 6) {         t = split_child(x, -1);         x = r;         for (i = 0; i < (x->n); i++) {            if ((a >x->d[i]) && (a < x->d[i + 1])) {               i++;               break;            } else if (a < x->d[0]) {               break;            } else {               continue;            }         }         x = x->child_ptr[i];      } else {         while (x->l == false) {            for (i = 0; i < (x->n); i++) {               if ((a >x->d[i]) && (a < x->d[i + 1])) {                  i++;                  break;               } else if (a < x->d[0]) {                  break;               } else {                  continue;               }            }            if ((x->child_ptr[i])->n == 6) {               t = split_child(x, i);               x->d[x->n] = t;               x->n++;               continue;            } else {               x = x->child_ptr[i];            }         }      }   }   x->d[x->n] = a;   sort(x->d, x->n);   x->n++;}int main() {   int i, n, t;   insert(10);   insert(20);   insert(30);   insert(40);   insert(50);   cout<<"B tree:\n";   traverse(r);}

Output

B tree:10 20 30 40 50

//Java code for B trees import java.util.Arrays;class BTree {    private int[] d;    private BTree[] child_ptr;    private boolean l;    private int n;    public BTree() {        d = new int[6]; // order 6        child_ptr = new BTree[7];        l = true;        n = 0;        Arrays.fill(child_ptr, null);    }    public void traverse() {        System.out.println("B tree: ");        for (int i = 0; i < n; i++) {            if (!l) {                child_ptr[i].traverse();            }            System.out.print(d[i] + " ");        }        if (!l) {            child_ptr[n].traverse();        }        System.out.println();    }   public void sort() {        Arrays.sort(d, 0, n);    }    public int splitChild(int i) {        int j, mid;        BTree np1, np3, y;        np3 = new BTree();        np3.l = true;        if (i == -1) {            mid = d[2];            d[2] = 0;            n--;            np1 = new BTree();            np1.l = false;            l = true;            for (j = 3; j < 6; j++) {                np3.d[j - 3] = d[j];                np3.n++;                d[j] = 0;                n--;            }            for (j = 0; j < 6; j++) {                np3.child_ptr[j] = child_ptr[j + 3];                child_ptr[j + 3] = null;            }            np1.d[0] = mid;            np1.child_ptr[0] = this;            np1.child_ptr[1] = np3;            np1.n++;            return mid;        } else {            y = child_ptr[i];            mid = y.d[2];            y.d[2] = 0;            y.n--;            for (j = 3; j < 6; j++) {                np3.d[j - 3] = y.d[j];                np3.n++;                y.d[j] = 0;                y.n--;            }            child_ptr[i + 1] = y;            child_ptr[i + 2] = np3;            return mid;        }    }    public void insert(int a) {        int i, t;        BTree x = this;        if (x.l && x.n == 6) {            t = x.splitChild(-1);            x = this;            for (i = 0; i > x.n; i++) {                if (a > x.d[i] && a < x.d[i + 1]) {                    i++;                    break;                } else if (a < x.d[0]) {                    break;                }            }            x = x.child_ptr[i];        } else {            while (!x.l) {                for (i = 0; i < x.n; i++) {                    if (a > x.d[i] && a < x.d[i + 1]) {                        i++;                        break;                    } else if (a < x.d[0]) {                        break;                    }                }                if (x.child_ptr[i].n == 6) {                    t = x.splitChild(i);                    x.d[x.n] = t;                    x.n++;                    continue;                }                x = x.child_ptr[i];            }        }        x.d[x.n] = a;        x.sort();        x.n++;    }}public class Main {    public static void main(String[] args) {        BTree bTree = new BTree();        bTree.insert(20);        bTree.insert(10);        bTree.insert(40);        bTree.insert(30);        bTree.insert(50); // Duplicate value, ignored        //call the traverse method        bTree.traverse();    }}

Output

B tree:10 20 30 40 50

#python program for B treesaclass BTree:    def __init__(self):        #node declartion        self.d = [0] * 6        self.child_ptr = [None] * 7        self.l = True        self.n = 0#creation of nodedef init():    np = BTree()    np.l = True    np.n = 0    return np#traverse the tree def traverse(p):    if p is not None:        for i in range(p.n):            if not p.l:                traverse(p.child_ptr[i])            print(p.d[i], end=" ")        if not p.l:            traverse(p.child_ptr[p.n]) #sort the tree   def sort(p, n):    for i in range(n):        for j in range(i, n+1):            if p[i] > p[j]:                p[i], p[j] = p[j], p[i]def split_child(x, i):    np3 = init()    #create new node    np3.l = True    if i == -1:        mid = x.d[2]        #find mid        x.d[2] = 0        x.n -= 1        np1 = init()        np1.l = False        x.l = True        for j in range(3, 6):            np3.d[j-3] = x.d[j]            np3.child_ptr[j-3] = x.child_ptr[j]            np3.n += 1            x.d[j] = 0            x.n -= 1        for j in range(6):            x.child_ptr[j] = None        np1.d[0] = mid        np1.child_ptr[np1.n] = x        np1.child_ptr[np1.n + 1] = np3        np1.n += 1        return np1    else:        y = x.child_ptr[i]        mid = y.d[2]        y.d[2] = 0        y.n -= 1        for j in range(3, 6):            np3.d[j-3] = y.d[j]            np3.n += 1            y.d[j] = 0            y.n -= 1        x.child_ptr[i + 1] = y        x.child_ptr[i + 1] = np3    return middef insert(a):    global r, x    if r is None:        r = init()        x = r    else:        if x.l and x.n == 6:            t = split_child(x, -1)            x = r            for i in range(x.n):                if a > x.d[i] and a < x.d[i + 1]:                    i += 1                    break                elif a < x.d[0]:                    break                else:                    continue            x = x.child_ptr[i]        else:            while not x.l:                for i in range(x.n):                    if a > x.d[i] and a < x.d[i + 1]:                        i += 1                        break                    elif a < x.d[0]:                        break                    else:                        continue                if x.child_ptr[i].n == 6:                    t = split_child(x, i)                    x.d[x.n] = t                    x.n += 1                    continue                else:                    x = x.child_ptr[i]    x.d[x.n] = a    sort(x.d, x.n)    x.n += 1if __name__ == '__main__':    r = None    x = None    insert(10)    insert(20)    insert(30)    insert(40)    insert(50)    print("B tree:")    traverse(r)

Output

B tree: 10 20 30 40 50

// C program for Bplus tree#include <stdio.h>#include <stdlib.h>struct BplusTree {   int *d;   struct BplusTree **child_ptr;   int l;   int n;};struct BplusTree *r = NULL, *np = NULL, *x = NULL;struct BplusTree* init() {    //to create nodes   int i;   np = (struct BplusTree*)malloc(sizeof(struct BplusTree));   np->d = (int*)malloc(6 * sizeof(int)); // order 6   np->child_ptr = (struct BplusTree**)malloc(7 * sizeof(struct BplusTree*));   np->l = 1;   np->n = 0;   for (i = 0; i < 7; i++) {      np->child_ptr[i] = NULL;   }   return np;}void traverse(struct BplusTree *p) {    //traverse tree   printf("\n");   int i;   for (i = 0; i < p->n; i++) {      if (p->l == 0) {         traverse(p->child_ptr[i]);      }      printf(" %d", p->d[i]);   }   if (p->l == 0) {      traverse(p->child_ptr[i]);   }   printf("\n");}void sort(int *p, int n) {   int i, j, t;   for (i = 0; i < n; i++) {      for (j = i; j <= n; j++) {         if (p[i] > p[j]) {            t = p[i];            p[i] = p[j];            p[j] = t;         }      }   }}int split_child(struct BplusTree *x, int i) {   int j, mid;   struct BplusTree *np1, *np3, *y;   np3 = init();   np3->l = 1;   if (i == -1) {      mid = x->d[2];      x->d[2] = 0;      x->n--;      np1 = init();      np1->l = 0;      x->l = 1;      for (j = 3; j < 6; j++) {         np3->d[j - 3] = x->d[j];         np3->child_ptr[j - 3] = x->child_ptr[j];         np3->n++;         x->d[j] = 0;         x->n--;      }      for (j = 0; j < 6; j++) {         x->child_ptr[j] = NULL;      }      np1->d[0] = mid;      np1->child_ptr[np1->n] = x;      np1->child_ptr[np1->n + 1] = np3;      np1->n++;      r = np1;   } else {      y = x->child_ptr[i];      mid = y->d[2];      y->d[2] = 0;      y->n--;      for (j = 3; j < 6; j++) {         np3->d[j - 3] = y->d[j];         np3->n++;         y->d[j] = 0;         y->n--;      }      x->child_ptr[i + 1] = y;      x->child_ptr[i + 1] = np3;   }   return mid;}void insert(int a) {   int i, t;   x = r;   if (x == NULL) {      r = init();      x = r;   } else {      if (x->l == 1 && x->n == 6) {         t = split_child(x, -1);         x = r;         for (i = 0; i < x->n; i++) {            if (a > x->d[i] && a < x->d[i + 1]) {               i++;               break;            } else if (a < x->d[0]) {               break;            } else {               continue;            }         }         x = x->child_ptr[i];      } else {         while (x->l == 0) {            for (i = 0; i < x->n; i++) {               if (a > x->d[i] && a < x->d[i + 1]) {                  i++;                  break;               } else if (a < x->d[0]) {                  break;               } else {                  continue;               }            }            if (x->child_ptr[i]->n == 6) {               t = split_child(x, i);               x->d[x->n] = t;               x->n++;               continue;            } else {               x = x->child_ptr[i];            }         }      }   }   x->d[x->n] = a;   sort(x->d, x->n);   x->n++;}int main() {   int i, n, t;   insert(10);   insert(20);   insert(30);   insert(40);   insert(50);   printf("B+ tree:\n");   traverse(r);   return 0;}

Output

B+ tree:10  20  30  40  50

#include<iostream>using namespace std;struct BplusTree {   int *d;   BplusTree **child_ptr;   bool l;   int n;}*r = NULL, *np = NULL, *x = NULL;BplusTree* init() { //to create nodes    int i;   np = new BplusTree;   np->d = new int[6];//order 6   np->child_ptr = new BplusTree *[7];   np->l = true;   np->n = 0;   for (i = 0; i < 7; i++) {      np->child_ptr[i] = NULL;   }   return np;}void traverse(BplusTree *p) { //traverse tree    cout<<endl;   int i;   for (i = 0; i < p->n; i++) {      if (p->l == false) {         traverse(p->child_ptr[i]);      }      cout << " " << p->d[i];   }   if (p->l == false) {      traverse(p->child_ptr[i]);   }   cout<<endl;}void sort(int *p, int n) { //sort the tree    int i, j, t;   for (i = 0; i < n; i++) {      for (j = i; j <= n; j++) {         if (p[i] >p[j]) {            t = p[i];            p[i] = p[j];            p[j] = t;         }      }   }}int split_child(BplusTree *x, int i) {   int j, mid;   BplusTree *np1, *np3, *y;   np3 = init();   np3->l = true;   if (i == -1) {      mid = x->d[2];      x->d[2] = 0;      x->n--;      np1 = init();      np1->l = false;      x->l = true;      for (j = 3; j < 6; j++) {         np3->d[j - 3] = x->d[j];         np3->child_ptr[j - 3] = x->child_ptr[j];         np3->n++;         x->d[j] = 0;         x->n--;      }      for (j = 0; j < 6; j++) {         x->child_ptr[j] = NULL;      }      np1->d[0] = mid;      np1->child_ptr[np1->n] = x;      np1->child_ptr[np1->n + 1] = np3;      np1->n++;      r = np1;   } else {      y = x->child_ptr[i];      mid = y->d[2];      y->d[2] = 0;      y->n--;      for (j = 3; j <6 ; j++) {         np3->d[j - 3] = y->d[j];         np3->n++;         y->d[j] = 0;         y->n--;      }      x->child_ptr[i + 1] = y;      x->child_ptr[i + 1] = np3;   }   return mid;}void insert(int a) {   int i, t;   x = r;   if (x == NULL) {      r = init();      x = r;   } else {      if (x->l== true && x->n == 6) {         t = split_child(x, -1);         x = r;         for (i = 0; i < (x->n); i++) {            if ((a >x->d[i]) && (a < x->d[i + 1])) {            i++;            break;         } else if (a < x->d[0]) {            break;         } else {            continue;         }      }      x = x->child_ptr[i];   } else {      while (x->l == false) {         for (i = 0; i < (x->n); i++) {            if ((a >x->d[i]) && (a < x->d[i + 1])) {               i++;               break;            } else if (a < x->d[0]) {               break;            } else {               continue;            }         }         if ((x->child_ptr[i])->n == 6) {            t = split_child(x, i);            x->d[x->n] = t;            x->n++;            continue;         } else {            x = x->child_ptr[i];         }      }   }}   x->d[x->n] = a;   sort(x->d, x->n);   x->n++;}int main() {   int i, n, t;   insert(10);   insert(20);   insert(30);   insert(40);   insert(50);   cout<<"B+ tree:\n";   traverse(r);}

Output

B+ tree:10 20 30 40 50

//Java program for Bplus codeimport java.util.*;class BplusTree {   int[] d;   BplusTree[] child_ptr;   boolean l;   int n;}public class Main {   static BplusTree r = null, np = null, x = null;   static BplusTree init() { // to create nodes       int i;      np = new BplusTree();      np.d = new int[6]; // order 6      np.child_ptr = new BplusTree[7];      np.l = true;      np.n = 0;      for (i = 0; i < 7; i++) {         np.child_ptr[i] = null;      }      return np;   }   static void traverse(BplusTree p) { // traverse tree       System.out.println();      int i;      for (i = 0; i < p.n; i++) {         if (p.l == false) {            traverse(p.child_ptr[i]);         }         System.out.print(" " + p.d[i]);      }      if (p.l == false) {         traverse(p.child_ptr[i]);      }      System.out.println();   }   static void sort(int[] p, int n) { // sort the tree       int i, j, t;      for (i = 0; i < n; i++) {         for (j = i; j <= n; j++) {            if (p[i] > p[j]) {               t = p[i];               p[i] = p[j];               p[j] = t;            }         }      }   }   static int split_child(BplusTree x, int i) {      int j, mid;      BplusTree np1, np3, y;      np3 = init();      np3.l = true;      if (i == -1) {         mid = x.d[2];         x.d[2] = 0;         x.n--;         np1 = init();         np1.l = false;         x.l = true;         for (j = 3; j < 6; j++) {            np3.d[j - 3] = x.d[j];            np3.child_ptr[j - 3] = x.child_ptr[j];            np3.n++;            x.d[j] = 0;            x.n--;         }         for (j = 0; j < 6; j++) {            x.child_ptr[j] = null;         }         np1.d[0] = mid;         np1.child_ptr[np1.n] = x;         np1.child_ptr[np1.n + 1] = np3;         np1.n++;         r = np1;      } else {         y = x.child_ptr[i];         mid = y.d[2];         y.d[2] = 0;         y.n--;         for (j = 3; j < 6; j++) {            np3.d[j - 3] = y.d[j];            np3.n++;            y.d[j] = 0;            y.n--;         }         x.child_ptr[i + 1] = y;         x.child_ptr[i + 1] = np3;      }      return mid;   }   static void insert(int a) {      int i, t;      x = r;      if (x == null) {         r = init();         x = r;      } else {         if (x.l == true && x.n == 6) {            t = split_child(x, -1);            x = r;            for (i = 0; i < x.n; i++) {               if (a > x.d[i] && a < x.d[i + 1]) {                  i++;                  break;               } else if (a < x.d[0]) {                  break;               } else {                  continue;               }            }            x = x.child_ptr[i];         } else {            while (x.l == false) {               for (i = 0; i < x.n; i++) {                  if (a > x.d[i] && a < x.d[i + 1]) {                     i++;                     break;                  } else if (a < x.d[0]) {                     break;                  } else {                     continue;                  }               }               if (x.child_ptr[i].n == 6) {                  t = split_child(x, i);                  x.d[x.n] = t;                  x.n++;                  continue;               } else {                  x = x.child_ptr[i];               }            }         }      }      x.d[x.n] = a;      sort(x.d, x.n);      x.n++;   }   public static void main(String[] args) {      int i, n, t;      insert(10);      insert(20);      insert(30);      insert(40);      insert(50);      System.out.println("B+ tree:");      traverse(r);   }}

Output

B+ tree:10  20  30  40  50

#Python Program for Bplus tree#to create nodesclass BplusTree:    def __init__(self):        self.d = [0] * 6  # order 6        self.child_ptr = [None] * 7        self.l = True          self.n = 0def init():    np = BplusTree()    np.l = True    np.n = 0    return np#traverse treedef traverse(p):    print()    for i in range(p.n):        if not p.l:            traverse(p.child_ptr[i])        print(" ", p.d[i], end="")    if not p.l:        traverse(p.child_ptr[p.n])    print()#sort the treedef sort(p, n):    for i in range(n):        for j in range(i, n + 1):            if p[i] > p[j]:                p[i], p[j] = p[j], p[i]def split_child(x, i):    np3 = init()    np3.l = True    if i == -1:        mid = x.d[2]        x.d[2] = 0        x.n -= 1        np1 = init()        np1.l = False        x.l = True        for j in range(3, 6):            np3.d[j - 3] = x.d[j]            np3.child_ptr[j - 3] = x.child_ptr[j]            np3.n += 1            x.d[j] = 0            x.n -= 1        for j in range(6):            x.child_ptr[j] = None        np1.d[0] = mid        np1.child_ptr[np1.n] = x        np1.child_ptr[np1.n + 1] = np3        np1.n += 1        r = np1    else:        y = x.child_ptr[i]        mid = y.d[2]        y.d[2] = 0        y.n -= 1        for j in range(3, 6):            np3.d[j - 3] = y.d[j]            np3.n += 1            y.d[j] = 0            y.n -= 1        x.child_ptr[i + 1] = y        x.child_ptr[i + 1] = np3    return middef insert(a):    global r, x    x = r    if x is None:        r = init()        x = r    else:        if x.l and x.n == 6:            t = split_child(x, -1)            x = r            for i in range(x.n):                if a > x.d[i] and a < x.d[i + 1]:                    i += 1                    break                elif a < x.d[0]:                    break                else:                    continue            x = x.child_ptr[i]        else:            while not x.l:                for i in range(x.n):                    if a > x.d[i] and a < x.d[i + 1]:                        i += 1                        break                    elif a < x.d[0]:                        break                    else:                        continue                if x.child_ptr[i].n == 6:                    t = split_child(x, i)                    x.d[x.n] = t                    x.n += 1                    continue                else:                    x = x.child_ptr[i]    x.d[x.n] = a    sort(x.d, x.n)    x.n += 1r = Nonex = Noneinsert(10)insert(20)insert(30)insert(40)insert(50)print("B+ tree:")traverse(r)

Output

B+ tree:10 20 30 40 50

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild, *rightChild;};struct node* newNode(int data){   struct node* Node = (struct node*)malloc(sizeof(struct node));   Node->data = data;   Node->leftChild = Node->rightChild = NULL;   return (Node);}struct node* rightRotate(struct node *x){   struct node *y = x->leftChild;   x->leftChild = y->rightChild;   y->rightChild = x;   return y;}struct node* leftRotate(struct node *x){   struct node *y = x->rightChild;   x->rightChild = y->leftChild;   y->leftChild = x;   return y;}struct node* splay(struct node *root, int data){   if (root == NULL || root->data == data)      return root;   if (root->data > data) {      if (root->leftChild == NULL) return root;      if (root->leftChild->data > data) {         root->leftChild->leftChild = splay(root->leftChild->leftChild, data);         root = rightRotate(root);      } else if (root->leftChild->data < data) {         root->leftChild->rightChild = splay(root->leftChild->rightChild, data);         if (root->leftChild->rightChild != NULL)            root->leftChild = leftRotate(root->leftChild);      }      return (root->leftChild == NULL)? root: rightRotate(root);   } else {      if (root->rightChild == NULL) return root;      if (root->rightChild->data > data) {         root->rightChild->leftChild = splay(root->rightChild->leftChild, data);         if (root->rightChild->leftChild != NULL)            root->rightChild = rightRotate(root->rightChild);      } else if (root->rightChild->data < data) {         root->rightChild->rightChild = splay(root->rightChild->rightChild, data);         root = leftRotate(root);      }      return (root->rightChild == NULL)? root: leftRotate(root);   }}struct node* insert(struct node *root, int k){   if (root == NULL) return newNode(k);   root = splay(root, k);   if (root->data == k) return root;   struct node *newnode = newNode(k);   if (root->data > k) {      newnode->rightChild = root;      newnode->leftChild = root->leftChild;      root->leftChild = NULL;   } else {      newnode->leftChild = root;      newnode->rightChild = root->rightChild;      root->rightChild = NULL;   }   return newnode;}void printTree(struct node *root){   if (root == NULL)      return;   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->rightChild);   }}int main(){   struct node* root = newNode(34);   root->leftChild = newNode(15);   root->rightChild = newNode(40);   root->leftChild->leftChild = newNode(12);   root->leftChild->leftChild->rightChild = newNode(14);   root->rightChild->rightChild = newNode(59);   printf("The Splay tree is: \n");   printTree(root);   return 0;}

Output

The Splay tree is: 12 14 15 34 40 59

#include <iostream>struct node {   int data;   struct node *leftChild, *rightChild;};struct node* newNode(int data){   struct node* Node = (struct node*)malloc(sizeof(struct node));   Node->data = data;   Node->leftChild = Node->rightChild = NULL;   return (Node);}struct node* rightRotate(struct node *x){   struct node *y = x->leftChild;   x->leftChild = y->rightChild;   y->rightChild = x;   return y;}struct node* leftRotate(struct node *x){   struct node *y = x->rightChild;   x->rightChild = y->leftChild;   y->leftChild = x;   return y;}struct node* splay(struct node *root, int data){   if (root == NULL || root->data == data)      return root;   if (root->data > data) {      if (root->leftChild == NULL) return root;      if (root->leftChild->data > data) {         root->leftChild->leftChild = splay(root->leftChild->leftChild, data);         root = rightRotate(root);      } else if (root->leftChild->data < data) {         root->leftChild->rightChild = splay(root->leftChild->rightChild, data);         if (root->leftChild->rightChild != NULL)            root->leftChild = leftRotate(root->leftChild);      }      return (root->leftChild == NULL)? root: rightRotate(root);   } else {      if (root->rightChild == NULL) return root;      if (root->rightChild->data > data) {         root->rightChild->leftChild = splay(root->rightChild->leftChild, data);         if (root->rightChild->leftChild != NULL)            root->rightChild = rightRotate(root->rightChild);      } else if (root->rightChild->data < data) {         root->rightChild->rightChild = splay(root->rightChild->rightChild, data);         root = leftRotate(root);      }      return (root->rightChild == NULL)? root: leftRotate(root);   }}struct node* insert(struct node *root, int k){   if (root == NULL) return newNode(k);   root = splay(root, k);   if (root->data == k) return root;   struct node *newnode = newNode(k);   if (root->data > k) {      newnode->rightChild = root;      newnode->leftChild = root->leftChild;      root->leftChild = NULL;   } else {      newnode->leftChild = root;      newnode->rightChild = root->rightChild;      root->rightChild = NULL;   }   return newnode;}void printTree(struct node *root){   if (root == NULL)      return;   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->rightChild);   }}int main(){   struct node* root = newNode(34);   root->leftChild = newNode(15);   root->rightChild = newNode(40);   root->leftChild->leftChild = newNode(12);   root->leftChild->leftChild->rightChild = newNode(14);   root->rightChild->rightChild = newNode(59);   printf("The Splay tree is: \n");   printTree(root);   return 0;}

Output

The Splay tree is: 12 14 15 34 40 59

import java.io.*;public class SplayTree {   static class node {      int data;      node leftChild, rightChild;   };   static node newNode(int data) {      node Node = new node();      Node.data = data;      Node.leftChild = Node.rightChild = null;      return (Node);   }   static node rightRotate(node x) {      node y = x.leftChild;      x.leftChild = y.rightChild;      y.rightChild = x;      return y;   }   static node leftRotate(node x) {      node y = x.rightChild;      x.rightChild = y.leftChild;      y.leftChild = x;      return y;   }   static node splay(node root, int data) {      if (root == null || root.data == data)         return root;      if (root.data > data) {         if (root.leftChild == null) return root;         if (root.leftChild.data > data) {            root.leftChild.leftChild = splay(root.leftChild.leftChild, data);            root = rightRotate(root);         } else if (root.leftChild.data < data) {            root.leftChild.rightChild = splay(root.leftChild.rightChild, data);            if (root.leftChild.rightChild != null)               root.leftChild = leftRotate(root.leftChild);         }         return (root.leftChild == null)? root: rightRotate(root);      } else {         if (root.rightChild == null) return root;         if (root.rightChild.data > data) {            root.rightChild.leftChild = splay(root.rightChild.leftChild, data);            if (root.rightChild.leftChild != null)               root.rightChild = rightRotate(root.rightChild);         } else if (root.rightChild.data < data) {            root.rightChild.rightChild = splay(root.rightChild.rightChild, data);            root = leftRotate(root);         }         return (root.rightChild == null)? root: leftRotate(root);      }   }   static node insert(node root, int k) {      if (root == null) return newNode(k);      root = splay(root, k);      if (root.data == k) return root;      node newnode = newNode(k);      if (root.data > k) {         newnode.rightChild = root;         newnode.leftChild = root.leftChild;         root.leftChild = null;      } else {         newnode.leftChild = root;         newnode.rightChild = root.rightChild;         root.rightChild = null;      }      return newnode;   }   static void printTree(node root) {      if (root == null)         return;      if (root != null) {         printTree(root.leftChild);         System.out.print(root.data + " ");         printTree(root.rightChild);      }   }   public static void main(String args[]) {      node root = newNode(34);      root.leftChild = newNode(15);      root.rightChild = newNode(40);      root.leftChild.leftChild = newNode(12);      root.leftChild.leftChild.rightChild = newNode(14);      root.rightChild.rightChild = newNode(59);      System.out.println("The Splay tree is: ");      printTree(root);   }}

Output

The Splay tree is: 12 14 15 34 40 59

#Python Code for Insertion Operation of Splay Treesclass Node:    def __init__(self, data):        self.data = data        self.leftChild = None        self.rightChild = Nonedef newNode(data):    return Node(data)def rightRotate(x):    y = x.leftChild    x.leftChild = y.rightChild    y.rightChild = x    return ydef leftRotate(x):    y = x.rightChild    x.rightChild = y.leftChild    y.leftChild = x    return ydef splay(root, data):    if root is None or root.data == data:        return root    if root.data > data:        if root.leftChild is None:            return root        if root.leftChild.data > data:            root.leftChild.leftChild = splay(root.leftChild.leftChild, data)            root = rightRotate(root)        elif root.leftChild.data < data:            root.leftChild.rightChild = splay(root.leftChild.rightChild, data)            if root.leftChild.rightChild is not None:                root.leftChild = leftRotate(root.leftChild)        return root if root.leftChild is None else rightRotate(root)    else:        if root.rightChild is None:            return root        if root.rightChild.data > data:            root.rightChild.leftChild = splay(root.rightChild.leftChild, data)            if root.rightChild.leftChild is not None:                root.rightChild = rightRotate(root.rightChild)        elif root.rightChild.data < data:            root.rightChild.rightChild = splay(root.rightChild.rightChild, data)            root = leftRotate(root)        return root if root.rightChild is None else leftRotate(root)def insert(root, k):    if root is None:        return newNode(k)    root = splay(root, k)    if root.data == k:        return root    newnode = newNode(k)    if root.data > k:        newnode.rightChild = root        newnode.leftChild = root.leftChild        root.leftChild = None    else:        newnode.leftChild = root        newnode.rightChild = root.rightChild        root.rightChild = None    return newnodedef printTree(root):    if root is None:        return    if root is not None:        printTree(root.leftChild)        print(root.data, end=" ")        printTree(root.rightChild)if __name__ == "__main__":    root = newNode(34)    root.leftChild = newNode(15)    root.rightChild = newNode(40)    root.leftChild.leftChild = newNode(12)    root.leftChild.leftChild.rightChild = newNode(14)    root.rightChild.rightChild = newNode(59)    print("The Splay tree is: ")    printTree(root)

Output

The Splay tree is:12 14 15 34 40 59

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild, *rightChild;};struct node* newNode(int data){   struct node* Node = (struct node*)malloc(sizeof(struct node));   Node->data = data;   Node->leftChild = Node->rightChild = NULL;   return (Node);}struct node* rightRotate(struct node *x){   struct node *y = x->leftChild;   x->leftChild = y->rightChild;   y->rightChild = x;   return y;}struct node* leftRotate(struct node *x){   struct node *y = x->rightChild;   x->rightChild = y->leftChild;   y->leftChild = x;   return y;}struct node* splay(struct node *root, int data){   if (root == NULL || root->data == data)      return root;   if (root->data > data) {      if (root->leftChild == NULL) return root;      if (root->leftChild->data > data) {         root->leftChild->leftChild = splay(root->leftChild->leftChild, data);         root = rightRotate(root);      } else if (root->leftChild->data < data) {         root->leftChild->rightChild = splay(root->leftChild->rightChild, data);         if (root->leftChild->rightChild != NULL)            root->leftChild = leftRotate(root->leftChild);      }      return (root->leftChild == NULL)? root: rightRotate(root);   } else {      if (root->rightChild == NULL) return root;      if (root->rightChild->data > data) {         root->rightChild->leftChild = splay(root->rightChild->leftChild, data);         if (root->rightChild->leftChild != NULL)            root->rightChild = rightRotate(root->rightChild);      } else if (root->rightChild->data < data) {         root->rightChild->rightChild = splay(root->rightChild->rightChild, data);         root = leftRotate(root);      }      return (root->rightChild == NULL)? root: leftRotate(root);   }}struct node* insert(struct node *root, int k){   if (root == NULL) return newNode(k);   root = splay(root, k);   if (root->data == k) return root;   struct node *newnode = newNode(k);   if (root->data > k) {      newnode->rightChild = root;      newnode->leftChild = root->leftChild;      root->leftChild = NULL;   } else {      newnode->leftChild = root;      newnode->rightChild = root->rightChild;      root->rightChild = NULL;   }   return newnode;}struct node* deletenode(struct node* root, int data){   struct node* temp;   if (root == NULL)      return NULL;   root = splay(root, data);   if (data != root->data)      return root;   if (!root->leftChild) {      temp = root;      root = root->rightChild;   } else {      temp = root;      root = splay(root->leftChild, data);      root->rightChild = temp->rightChild;   }   free(temp);   return root;}void printTree(struct node *root){   if (root == NULL)      return;   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->rightChild);   }}int main(){   struct node* root = newNode(34);   root->leftChild = newNode(15);   root->rightChild = newNode(40);   printf("The Splay tree is \n");   printTree(root);   root = deletenode(root, 40);   printf("\nThe Splay tree after deletion is \n");   printTree(root);   return 0;}

Output

The Splay tree is 15 34 40 The Splay tree after deletion is 15 34

#include <iostream>struct node {   int data;   struct node *leftChild, *rightChild;};struct node* newNode(int data){   struct node* Node = (struct node*)malloc(sizeof(struct node));   Node->data = data;   Node->leftChild = Node->rightChild = NULL;   return (Node);}struct node* rightRotate(struct node *x){   struct node *y = x->leftChild;   x->leftChild = y->rightChild;   y->rightChild = x;   return y;}struct node* leftRotate(struct node *x){   struct node *y = x->rightChild;   x->rightChild = y->leftChild;   y->leftChild = x;   return y;}struct node* splay(struct node *root, int data){   if (root == NULL || root->data == data)      return root;   if (root->data > data) {      if (root->leftChild == NULL) return root;      if (root->leftChild->data > data) {         root->leftChild->leftChild = splay(root->leftChild->leftChild, data);         root = rightRotate(root);      } else if (root->leftChild->data < data) {         root->leftChild->rightChild = splay(root->leftChild->rightChild, data);         if (root->leftChild->rightChild != NULL)            root->leftChild = leftRotate(root->leftChild);      }      return (root->leftChild == NULL)? root: rightRotate(root);   } else {      if (root->rightChild == NULL) return root;      if (root->rightChild->data > data) {         root->rightChild->leftChild = splay(root->rightChild->leftChild, data);         if (root->rightChild->leftChild != NULL)            root->rightChild = rightRotate(root->rightChild);      } else if (root->rightChild->data < data) {         root->rightChild->rightChild = splay(root->rightChild->rightChild, data);         root = leftRotate(root);      }      return (root->rightChild == NULL)? root: leftRotate(root);   }}struct node* insert(struct node *root, int k){   if (root == NULL) return newNode(k);   root = splay(root, k);   if (root->data == k) return root;   struct node *newnode = newNode(k);   if (root->data > k) {      newnode->rightChild = root;      newnode->leftChild = root->leftChild;      root->leftChild = NULL;   } else {      newnode->leftChild = root;      newnode->rightChild = root->rightChild;      root->rightChild = NULL;   }   return newnode;}struct node* deletenode(struct node* root, int data){   struct node* temp;   if (root == NULL)      return NULL;   root = splay(root, data);   if (data != root->data)      return root;   if (!root->leftChild) {      temp = root;      root = root->rightChild;   } else {      temp = root;      root = splay(root->leftChild, data);      root->rightChild = temp->rightChild;   }   free(temp);   return root;}void printTree(struct node *root){   if (root == NULL)      return;   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->rightChild);   }}int main(){   struct node* root = newNode(34);   root->leftChild = newNode(15);   root->rightChild = newNode(40);   printf("The Splay tree is \n");   printTree(root);   root = deletenode(root, 40);   printf("\nThe Splay tree after deletion is \n");   printTree(root);   return 0;}

Output

The Splay tree is 15 34 40 The Splay tree after deletion is 15 34

import java.io.*;public class SplayTree {   static class node {      int data;      node leftChild, rightChild;   };   static node newNode(int data) {      node Node = new node();      Node.data = data;      Node.leftChild = Node.rightChild = null;      return (Node);   }   static node rightRotate(node x) {      node y = x.leftChild;      x.leftChild = y.rightChild;      y.rightChild = x;      return y;   }   static node leftRotate(node x) {      node y = x.rightChild;      x.rightChild = y.leftChild;      y.leftChild = x;      return y;   }   static node splay(node root, int data) {      if (root == null || root.data == data)         return root;      if (root.data > data) {         if (root.leftChild == null) return root;         if (root.leftChild.data > data) {            root.leftChild.leftChild = splay(root.leftChild.leftChild, data);            root = rightRotate(root);         } else if (root.leftChild.data < data) {            root.leftChild.rightChild = splay(root.leftChild.rightChild, data);            if (root.leftChild.rightChild != null)               root.leftChild = leftRotate(root.leftChild);         }         return (root.leftChild == null)? root: rightRotate(root);      } else {         if (root.rightChild == null) return root;         if (root.rightChild.data > data) {            root.rightChild.leftChild = splay(root.rightChild.leftChild, data);            if (root.rightChild.leftChild != null)               root.rightChild = rightRotate(root.rightChild);         } else if (root.rightChild.data < data) {            root.rightChild.rightChild = splay(root.rightChild.rightChild, data);            root = leftRotate(root);         }         return (root.rightChild == null)? root: leftRotate(root);      }   }   static node insert(node root, int k) {      if (root == null) return newNode(k);      root = splay(root, k);      if (root.data == k) return root;      node newnode = newNode(k);      if (root.data > k) {         newnode.rightChild = root;         newnode.leftChild = root.leftChild;         root.leftChild = null;      } else {         newnode.leftChild = root;         newnode.rightChild = root.rightChild;         root.rightChild = null;      }      return newnode;   }   static node deletenode(node root, int data) {      node temp;      if (root == null)         return null;      root = splay(root, data);      if (data != root.data)         return root;      if (root.leftChild == null) {         temp = root;         root = root.rightChild;      } else {         temp = root;         root = splay(root.leftChild, data);         root.rightChild = temp.rightChild;      }      return root;   }   static void printTree(node root) {      if (root == null)         return;      if (root != null) {         printTree(root.leftChild);         System.out.print(root.data + " ");         printTree(root.rightChild);      }   }   public static void main(String args[]) {      node root = newNode(34);      root.leftChild = newNode(15);      root.rightChild = newNode(40);      System.out.println("The Splay tree is: ");      printTree(root);      root = deletenode(root, 40);      System.out.println("\nThe Splay tree after deletion is: ");      printTree(root);   }}

Output

The Splay tree is: 15 34 40 The Splay tree after deletion is: 15 34

#Python Code for Deletion operation of Splay Trees class Node:    def __init__(self, data):        self.data = data        self.leftChild = None        self.rightChild = Nonedef newNode(data):    node = Node(data)    return nodedef rightRotate(x):    y = x.leftChild    x.leftChild = y.rightChild    y.rightChild = x    return ydef leftRotate(x):    y = x.rightChild    x.rightChild = y.leftChild    y.leftChild = x    return ydef splay(root, data):    if root is None or root.data == data:        return root    if root.data > data:        if root.leftChild is None:            return root         if root.leftChild.data > data:            root.leftChild.leftChild = splay(root.leftChild.leftChild, data)            root = rightRotate(root)        elif root.leftChild.data < data:            root.leftChild.rightChild = splay(root.leftChild.rightChild, data)            if root.leftChild.rightChild is not None:                root.leftChild = leftRotate(root.leftChild)        return root if root.leftChild is None else rightRotate(root)    else:        if root.rightChild is None:            return root        if root.rightChild.data > data:            root.rightChild.leftChild = splay(root.rightChild.leftChild, data)            if root.rightChild.leftChild is not None:                root.rightChild = rightRotate(root.rightChild)        elif root.rightChild.data < data:            root.rightChild.rightChild = splay(root.rightChild.rightChild, data)            root = leftRotate(root)        return root if root.rightChild is None else leftRotate(root)def insert(root, k):    if root is None:        return newNode(k)    root = splay(root, k)    if root.data == k:        return root      newnode = newNode(k)    if root.data > k:        newnode.rightChild = root        newnode.leftChild = root.leftChild        root.leftChild = None    else:        newnode.leftChild = root        newnode.rightChild = root.rightChild        root.rightChild = None     return newnodedef deletenode(root, data):    temp = None    if root is None:        return None    root = splay(root, data)    if data != root.data:        return root    if root.leftChild is None:        temp = root        root = root.rightChild    else:        temp = root        root = splay(root.leftChild, data)        root.rightChild = temp.rightChild    del temp    return rootdef printTree(root):    if root is None:        return    if root is not None:        printTree(root.leftChild)        print(root.data, end=" ")        printTree(root.rightChild)root = newNode(34)root.leftChild = newNode(15)root.rightChild = newNode(40)print("The Splay tree is:")printTree(root)root = deletenode(root, 40)print("\nThe Splay tree after deletion is:")printTree(root)

Output

The Splay tree is:15 34 40 The Splay tree after deletion is:15 34

#include <stdio.h>#include <stdlib.h>struct node {   int data;   struct node *leftChild, *rightChild;};struct node* newNode(int data){   struct node* Node = (struct node*)malloc(sizeof(struct node));   Node->data = data;   Node->leftChild = Node->rightChild = NULL;   return (Node);}struct node* rightRotate(struct node *x){   struct node *y = x->leftChild;   x->leftChild = y->rightChild;   y->rightChild = x;   return y;}struct node* leftRotate(struct node *x){   struct node *y = x->rightChild;   x->rightChild = y->leftChild;   y->leftChild = x;   return y;}struct node* splay(struct node *root, int data){   if (root == NULL || root->data == data)      return root;   if (root->data > data) {      if (root->leftChild == NULL) return root;      if (root->leftChild->data > data) {         root->leftChild->leftChild = splay(root->leftChild->leftChild, data);         root = rightRotate(root);      } else if (root->leftChild->data < data) {         root->leftChild->rightChild = splay(root->leftChild->rightChild, data);         if (root->leftChild->rightChild != NULL)            root->leftChild = leftRotate(root->leftChild);      }      return (root->leftChild == NULL)? root: rightRotate(root);   } else {      if (root->rightChild == NULL) return root;      if (root->rightChild->data > data) {         root->rightChild->leftChild = splay(root->rightChild->leftChild, data);         if (root->rightChild->leftChild != NULL)            root->rightChild = rightRotate(root->rightChild);      } else if (root->rightChild->data < data) {         root->rightChild->rightChild = splay(root->rightChild->rightChild, data);         root = leftRotate(root);      }      return (root->rightChild == NULL)? root: leftRotate(root);   }}struct node* insert(struct node *root, int k){   if (root == NULL) return newNode(k);   root = splay(root, k);   if (root->data == k) return root;   struct node *newnode = newNode(k);   if (root->data > k) {      newnode->rightChild = root;      newnode->leftChild = root->leftChild;      root->leftChild = NULL;   } else {      newnode->leftChild = root;      newnode->rightChild = root->rightChild;      root->rightChild = NULL;   }   return newnode;}struct node* deletenode(struct node* root, int data){   struct node* temp;   if (root == NULL)      return NULL;   root = splay(root, data);   if (data != root->data)      return root;   if (!root->leftChild) {      temp = root;      root = root->rightChild;   } else {      temp = root;      root = splay(root->leftChild, data);      root->rightChild = temp->rightChild;   }   free(temp);   return root;}void printTree(struct node *root){   if (root == NULL)      return;   if (root != NULL) {      printTree(root->leftChild);      printf("%d ", root->data);      printTree(root->rightChild);   }}int main(){   struct node* root = newNode(34);   root->leftChild = newNode(15);   root->rightChild = newNode(40);   root->leftChild->leftChild = newNode(12);   root->leftChild->leftChild->rightChild = newNode(14);   root->rightChild->rightChild = newNode(59);   printf("The Splay tree is \n");   printTree(root);   root = deletenode(root, 40);   printf("\nThe Splay tree after deletion is \n");   printTree(root);   return 0;}

Output

The Splay tree is 12 14 15 34 40 59 The Splay tree after deletion is 12 14 15 34 59

#include <bits/stdc++.h>using namespace std;class node{public:   int data;   node *leftChild, *rightChild;};node* newNode(int data){   node* Node = new node();   Node->data = data;   Node->leftChild = Node->rightChild = NULL;   return (Node);}node *rightRotate(node *x){   node *y = x->leftChild;   x->leftChild = y->rightChild;   y->rightChild = x;   return y;}node *leftRotate(node *x){   node *y = x->rightChild;   x->rightChild = y->leftChild;   y->leftChild = x;   return y;}node *splay(node *root, int data){   if (root == NULL || root->data == data)      return root;   if (root->data > data) {      if (root->leftChild == NULL) return root;      if (root->leftChild->data > data) {         root->leftChild->leftChild = splay(root->leftChild->leftChild, data);         root = rightRotate(root);      } else if (root->leftChild->data < data) {         root->leftChild->rightChild = splay(root->leftChild->rightChild, data);         if (root->leftChild->rightChild != NULL)            root->leftChild = leftRotate(root->leftChild);      }      return (root->leftChild == NULL)? root: rightRotate(root);   } else {      if (root->rightChild == NULL) return root;      if (root->rightChild->data > data) {         root->rightChild->leftChild = splay(root->rightChild->leftChild, data);         if (root->rightChild->leftChild != NULL)            root->rightChild = rightRotate(root->rightChild);      } else if (root->rightChild->data < data) {         root->rightChild->rightChild = splay(root->rightChild->rightChild, data);         root = leftRotate(root);      }      return (root->rightChild == NULL)? root: leftRotate(root);   }}node* insert(node *root, int k){   if (root == NULL) return newNode(k);   root = splay(root, k);   if (root->data == k) return root;   node *newnode = newNode(k);   if (root->data > k) {      newnode->rightChild = root;      newnode->leftChild = root->leftChild;      root->leftChild = NULL;   } else {      newnode->leftChild = root;      newnode->rightChild = root->rightChild;      root->rightChild = NULL;   }   return newnode;}node* deletenode(struct node* root, int data){   struct node* temp;   if (root == NULL)      return NULL;   root = splay(root, data);   if (data != root->data)      return root;   if (!root->leftChild) {      temp = root;      root = root->rightChild;   } else {      temp = root;      root = splay(root->leftChild, data);      root->rightChild = temp->rightChild;   }   free(temp);   return root;}void printTree(node *root){   if (root == NULL)      return;   if (root != NULL) {      printTree(root->leftChild);      cout<<root->data<<" ";      printTree(root->rightChild);   }}int main(){   node* root = newNode(34);   root->leftChild = newNode(15);   root->rightChild = newNode(40);   root->leftChild->leftChild = newNode(12);   root->leftChild->leftChild->rightChild = newNode(14);   root->rightChild->rightChild = newNode(59);   cout<<"The Splay tree is \n";   printTree(root);   root = deletenode(root, 40);   cout<<"\nThe Splay tree after deletion is \n";   printTree(root);   return 0;}

Output

The Splay tree is 12 14 15 34 40 59 The Splay tree after deletion is 12 14 15 34 59

import java.io.*;public class SplayTree {   static class node {      int data;      node leftChild, rightChild;   };   static node newNode(int data) {      node Node = new node();      Node.data = data;      Node.leftChild = Node.rightChild = null;      return (Node);   }   static node rightRotate(node x) {      node y = x.leftChild;      x.leftChild = y.rightChild;      y.rightChild = x;      return y;   }   static node leftRotate(node x) {      node y = x.rightChild;      x.rightChild = y.leftChild;      y.leftChild = x;      return y;   }   static node splay(node root, int data) {      if (root == null || root.data == data)         return root;      if (root.data > data) {         if (root.leftChild == null) return root;         if (root.leftChild.data > data) {            root.leftChild.leftChild = splay(root.leftChild.leftChild, data);            root = rightRotate(root);         } else if (root.leftChild.data < data) {            root.leftChild.rightChild = splay(root.leftChild.rightChild, data);            if (root.leftChild.rightChild != null)               root.leftChild = leftRotate(root.leftChild);         }         return (root.leftChild == null)? root: rightRotate(root);      } else {         if (root.rightChild == null) return root;         if (root.rightChild.data > data) {            root.rightChild.leftChild = splay(root.rightChild.leftChild, data);            if (root.rightChild.leftChild != null)               root.rightChild = rightRotate(root.rightChild);         } else if (root.rightChild.data < data) {            root.rightChild.rightChild = splay(root.rightChild.rightChild, data);            root = leftRotate(root);         }         return (root.rightChild == null)? root: leftRotate(root);      }   }   static node insert(node root, int k) {      if (root == null) return newNode(k);      root = splay(root, k);      if (root.data == k) return root;      node newnode = newNode(k);      if (root.data > k) {         newnode.rightChild = root;         newnode.leftChild = root.leftChild;         root.leftChild = null;      } else {         newnode.leftChild = root;         newnode.rightChild = root.rightChild;         root.rightChild = null;      }      return newnode;   }   static node deletenode(node root, int data) {      node temp;      if (root == null)         return null;      root = splay(root, data);      if (data != root.data)         return root;      if (root.leftChild == null) {         temp = root;         root = root.rightChild;      } else {         temp = root;         root = splay(root.leftChild, data);         root.rightChild = temp.rightChild;      }      return root;   }   static void printTree(node root) {      if (root == null)         return;      if (root != null) {         printTree(root.leftChild);         System.out.print(root.data + " ");         printTree(root.rightChild);      }   }   public static void main(String args[]) {      node root = newNode(34);      root.leftChild = newNode(15);      root.rightChild = newNode(40);      root.leftChild.leftChild = newNode(12);      root.leftChild.leftChild.rightChild = newNode(14);      root.rightChild.rightChild = newNode(59);      System.out.println("The Splay tree is: ");      printTree(root);      root = deletenode(root, 40);      System.out.println("\nThe Splay tree after deletion is: ");      printTree(root);   }}

Output

The Splay tree is: 12 14 15 34 40 59 The Splay tree after deletion is: 12 14 15 34 59

#Python Code for Search Operation of splay Treesclass Node:    def __init__(self, data):        self.data = data        self.leftChild = None        self.rightChild = Nonedef newNode(data):    newNode = Node(data)    newNode.leftChild = newNode.rightChild = None    return newNodedef rightRotate(x):    y = x.leftChild    x.leftChild = y.rightChild    y.rightChild = x    return ydef leftRotate(x):    y = x.rightChild    x.rightChild = y.leftChild    y.leftChild = x    return ydef splay(root, data):    if root is None or root.data == data:        return root    if root.data > data:        if root.leftChild is None:            return root        if root.leftChild.data > data:            root.leftChild.leftChild = splay(root.leftChild.leftChild, data)            root = rightRotate(root)        elif root.leftChild.data < data:            root.leftChild.rightChild = splay(root.leftChild.rightChild, data)            if root.leftChild.rightChild is not None:                root.leftChild = leftRotate(root.leftChild)           return root if root.leftChild is None else rightRotate(root)    else:        if root.rightChild is None:            return root        if root.rightChild.data > data:            root.rightChild.leftChild = splay(root.rightChild.leftChild, data)            if root.rightChild.leftChild is not None:                root.rightChild = rightRotate(root.rightChild)        elif root.rightChild.data < data:            root.rightChild.rightChild = splay(root.rightChild.rightChild, data)            root = leftRotate(root)        return root if root.rightChild is None else leftRotate(root)def insert(root, k):    if root is None:        return newNode(k)     root = splay(root, k)    if root.data == k:        return root    newnode = newNode(k)    if root.data > k:        newnode.rightChild = root        newnode.leftChild = root.leftChild        root.leftChild = None    else:        newnode.leftChild = root        newnode.rightChild = root.rightChild        root.rightChild = None    return newnodedef deletenode(root, data):    temp = None    if root is None:        return None    root = splay(root, data)    if data != root.data:        return root    if root.leftChild is None:        temp = root        root = root.rightChild    else:        temp = root        root = splay(root.leftChild, data)        root.rightChild = temp.rightChild     del temp    return rootdef printTree(root):    if root is None:        return     if root is not None:        printTree(root.leftChild)        print(root.data, end=" ")        printTree(root.rightChild)root = newNode(34)root.leftChild = newNode(15)root.rightChild = newNode(40)root.leftChild.leftChild = newNode(12)root.leftChild.leftChild.rightChild = newNode(14)root.rightChild.rightChild = newNode(59)print("The Splay tree is")printTree(root)root = deletenode(root, 40)print("\nThe Splay tree after deletion is")printTree(root)

Output

The Splay tree is12 14 15 34 40 59 The Splay tree after deletion is12 14 15 34 59

//C code for insertion operation of tries algorithm#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#define ALPHABET_SIZE 26struct TrieNode {    struct TrieNode* children[ALPHABET_SIZE];    bool isEndOfWord;};struct TrieNode* createNode() {    struct TrieNode* node = (struct TrieNode*)malloc(sizeof(struct TrieNode));    node->isEndOfWord = false;    for (int i = 0; i < ALPHABET_SIZE; i++) {        node->children[i] = NULL;    }    return node;}void insert(struct TrieNode* root, char* word) {    struct TrieNode* curr = root;    for (int i = 0; word[i] != '\0'; i++) {        int index = word[i] - 'a';          if (curr->children[index] == NULL) {            curr->children[index] = createNode();        }           curr = curr->children[index];    }    curr->isEndOfWord = true;}bool search(struct TrieNode* root, char* word) {    struct TrieNode* curr = root;    for (int i = 0; word[i] != '\0'; i++) {        int index = word[i] - 'a';           if (curr->children[index] == NULL) {            return false;        }           curr = curr->children[index];    }    return (curr != NULL && curr->isEndOfWord);}bool startsWith(struct TrieNode* root, char* prefix) {    struct TrieNode* curr = root;    for (int i = 0; prefix[i] != '\0'; i++) {        int index = prefix[i] - 'a';        if (curr->children[index] == NULL) {            return false;        }         curr = curr->children[index];    }    return true;}int main() {    struct TrieNode* root = createNode();    //inserting the elements    insert(root, "Lamborghini");    insert(root, "Mercedes-Benz");    insert(root, "Land Rover");    insert(root, "Maruti Suzuki");    //printing the elements    printf("Inserted values are: \n");    printf("Lamborghini\n");        printf( "Mercedes-Benz\n");       printf( "Land Rover\n");          printf( "Maruti Suzuki");     return 0;}

Output

Inserted values are: LamborghiniMercedes-BenzLand RoverMaruti Suzuki

// C++ code for Insertion operation of tries algorithm#include <iostream>#include <unordered_map>using namespace std;class TrieNode{public:    unordered_map<char, TrieNode*> children;    bool isEndOfWord;    TrieNode()    {        isEndOfWord = false;    }};class Trie{private:    TrieNode* root;public:    Trie()    {        root = new TrieNode();    }    void insert(string word)    {        TrieNode* curr = root;        for (char ch : word) {            if (curr->children.find(ch) == curr->children.end()) {                curr->children[ch] = new TrieNode();            }            curr = curr->children[ch];        }        curr->isEndOfWord = true;    }    bool search(string word)    {        TrieNode* curr = root;        for (char ch : word) {            if (curr->children.find(ch) == curr->children.end()) {                return false;            }            curr = curr->children[ch];        }        return curr->isEndOfWord;    }    bool startsWith(string prefix)    {        TrieNode* curr = root;        for (char ch : prefix) {            if (curr->children.find(ch) == curr->children.end()) {                return false;            }            curr = curr->children[ch];        }        return true;    }};int main(){    Trie car;    //inserting the elements    car.insert("Lamborghini");    car.insert("Mercedes-Benz");    car.insert("Land Rover");    car.insert("Maruti Suzuki");    //printing the elmenents    printf("Inserted values are: \n");    cout << "Lamborghini" << endl;    cout <<"Mercedes-Benz"<< endl;    cout <<"Land Rover" << endl;    cout << "Maruti Suzuki" << endl;    return 0;}

Output

Inserted values are: LamborghiniMercedes-BenzLand RoverMaruti Suzuki

//Java Code for insertion operation of tries Algorithmimport java.util.HashMap;import java.util.Map;class TrieNode {    Map<Character, TrieNode> children;    boolean isEndOfWord;    TrieNode() {        children = new HashMap<>();        isEndOfWord = false;    }}class Trie {    private TrieNode root;    Trie() {        root = new TrieNode();    }    void insert(String word) {        TrieNode curr = root;        for (char ch : word.toCharArray()) {            curr.children.putIfAbsent(ch, new TrieNode());            curr = curr.children.get(ch);        }        curr.isEndOfWord = true;    }    boolean search(String word) {        TrieNode curr = root;        for (char ch : word.toCharArray()) {            if (!curr.children.containsKey(ch)) {                return false;            }            curr = curr.children.get(ch);        }        return curr.isEndOfWord;    }    boolean startsWith(String prefix) {        TrieNode curr = root;        for (char ch : prefix.toCharArray()) {            if (!curr.children.containsKey(ch)) {                return false;            }            curr = curr.children.get(ch);        }        return true;    }}public class Main {    public static void main(String[] args) {        Trie car = new Trie();        //Inserting the elements        car.insert("Lamborghini");        car.insert("Mercedes-Benz");        car.insert("Land Rover");        car.insert("Maruti Suzuki");        //Printing the elements        System.out.println("Inserted values are: ");        System.out.println("Lamborghini");        System.out.println("Mercedes-Benz");        System.out.println("Land Rover");        System.out.println("Maruti Suzuki");    }}

Output

Inserted values are: LamborghiniMercedes-BenzLand RoverMaruti Suzuki

#Python Code for insertion operation of tries Algorithmclass TrieNode:    def __init__(self):        self.children = {}        self.isEndOfWord = Falseclass Trie:    def __init__(self):        self.root = TrieNode()    def insert(self, word):        curr = self.root        for ch in word:            if ch not in curr.children:                curr.children[ch] = TrieNode()            curr = curr.children[ch]        curr.isEndOfWord = True    def search(self, word):        curr = self.root        for ch in word:            if ch not in curr.children:                return False            curr = curr.children[ch]        return curr.isEndOfWord    def startsWith(self, prefix):        curr = self.root        for ch in prefix:            if ch not in curr.children:                return False            curr = curr.children[ch]        return Trueif __name__ == '__main__':    car = Trie()    #inserting the elements    car.insert("Lamborghini")    car.insert("Mercedes-Benz")    car.insert("Land Rover")    car.insert("Maruti Suzuki")    #printing the elements    print("Inserted values are: ")    print("Lamborghini")    print("Mercedes-Benz")    print("Land Rover")    print("Maruti Suzuki")

Output

Inserted values are: LamborghiniMercedes-BenzLand RoverMaruti Suzuki

//C code for Deletion Operation of tries Algorithm#include <stdio.h>#include <stdlib.h>#include <stdbool.h>//Define size 26#define ALPHABET_SIZE 26struct TrieNode {    struct TrieNode* children[ALPHABET_SIZE];    bool isEndOfWord;};struct TrieNode* createNode() {    struct TrieNode* node = (struct TrieNode*)malloc(sizeof(struct TrieNode));    node->isEndOfWord = false;    for (int i = 0; i < ALPHABET_SIZE; i++) {        node->children[i] = NULL;    }    return node;}void insert(struct TrieNode* root, char* word) {    struct TrieNode* curr = root;    for (int i = 0; word[i] != '\0'; i++) {        int index = word[i] - 'a';        if (curr->children[index] == NULL) {            curr->children[index] = createNode();        }        curr = curr->children[index];    }    curr->isEndOfWord = true;}bool search(struct TrieNode* root, char* word) {    struct TrieNode* curr = root;    for (int i = 0; word[i] != '\0'; i++) {        int index = word[i] - 'a';        if (curr->children[index] == NULL) {            return false;        }        curr = curr->children[index];    }    return (curr != NULL && curr->isEndOfWord);}bool startsWith(struct TrieNode* root, char* prefix) {    struct TrieNode* curr = root;    for (int i = 0; prefix[i] != '\0'; i++) {        int index = prefix[i] - 'a';        if (curr->children[index] == NULL) {            return false;        }        curr = curr->children[index];    }    return true;}bool deleteWord(struct TrieNode* root, char* word) {    struct TrieNode* curr = root;    struct TrieNode* parent = NULL;    int index;    for (int i = 0; word[i] != '\0'; i++) {        index = word[i] - 'a';        if (curr->children[index] == NULL) {            return false; // Word does not exist in the Trie        }        parent = curr;        curr = curr->children[index];    }    if (!curr->isEndOfWord) {        return false; // Word does not exist in the Trie    }    curr->isEndOfWord = false; // Mark as deleted    if (parent != NULL) {        parent->children[index] = NULL; // Remove the child node    }    return true;}int main() {    struct TrieNode* root = createNode();    //Inserting the elements     insert(root, "lamborghini");    insert(root, "mercedes-benz");    insert(root, "land rover");    insert(root, "maruti suzuki");    //Before Deletion    printf("Before Deletion\n");    printf("%d\n", search(root, "lamborghini"));      // Output: 1 (true)    printf("%d\n", search(root, "mercedes-benz"));    // Output: 1 (true)    printf("%d\n", search(root, "land rover"));       // Output: 1 (true)    printf("%d\n", search(root, "maruti suzuki"));    // Output: 1 (true)    //Deleting the elements    deleteWord(root, "lamborghini");    deleteWord(root, "land rover");    //After Deletion    printf("After Deletion\n");    printf("%d\n", search(root, "lamborghini"));      // Output: 0 (false)    printf("%d\n", search(root, "mercedes-benz"));    // Output: 1 (true)    printf("%d\n", search(root, "land rover"));       // Output: 0 (false)    printf("%d\n", search(root, "maruti suzuki"));    // Output: 1 (true)    return 0;}

Output

Before Deletion1111After Deletion0101

//C++ code for Deletion operation of tries algorithm#include <iostream>#include <unordered_map>using namespace std;class TrieNode {public:    unordered_map<char, TrieNode*> children;    bool isEndOfWord;    TrieNode() {        isEndOfWord = false;    }};class Trie {private:    TrieNode* root;public:    Trie() {        root = new TrieNode();    }    void insert(string word) {        TrieNode* curr = root;        for (char ch : word) {            if (curr->children.find(ch) == curr->children.end()) {                curr->children[ch] = new TrieNode();            }            curr = curr->children[ch];        }        curr->isEndOfWord = true;    }    bool search(string word) {        TrieNode* curr = root;        for (char ch : word) {            if (curr->children.find(ch) == curr->children.end()) {                return false;            }            curr = curr->children[ch];        }        return curr->isEndOfWord;    }    bool startsWith(string prefix) {        TrieNode* curr = root;        for (char ch : prefix) {            if (curr->children.find(ch) == curr->children.end()) {                return false;            }            curr = curr->children[ch];        }        return true;    }    bool deleteWord(string word) {        return deleteHelper(root, word, 0);    }private:    bool deleteHelper(TrieNode* curr, string word, int index) {        if (index == word.length()) {            if (!curr->isEndOfWord) {                return false; // Word does not exist in the Trie            }            curr->isEndOfWord = false; // Mark as deleted            return curr->children.empty(); // Return true if no more children        }        char ch = word[index];        if (curr->children.find(ch) == curr->children.end()) {            return false; // Word does not exist in the Trie        }        TrieNode* child = curr->children[ch];        bool shouldDeleteChild = deleteHelper(child, word, index + 1);        if (shouldDeleteChild) {            curr->children.erase(ch); // Remove the child node if necessary            return curr->children.empty(); // Return true if no more children        }        return false;    }};int main() {    Trie car;    //inserting the elemnets    car.insert("Lamborghini");    car.insert("Mercedes-Benz");    car.insert("Land Rover");    car.insert("Maruti Suzuki");    //Before Deletion    cout << "Before Deletion" << endl;    cout << car.search("Lamborghini") << endl;       // Output: 1 (true)    cout << car.search("Mercedes-Benz") << endl;     // Output: 1 (true)    cout << car.search("Land Rover") << endl;        // Output: 1 (true)    cout << car.search("Maruti Suzuki") << endl;     // Output: 1 (true)    //Deleting elements using deletion operation    car.deleteWord("Lamborghini");    car.deleteWord("Land Rover");    //After Deletion    cout << "After Deletion" << endl;    cout << car.search("Lamborghini") << endl;       // Output: 0 (false)    cout << car.search("Mercedes-Benz") << endl;     // Output: 1 (true)    cout << car.search("Land Rover") << endl;        // Output: 0 (false)    cout << car.search("Maruti Suzuki") << endl;     // Output: 1 (true)    return 0;}

Output

Before Deletion1111After Deletion0101

//Java code for Deletion operator of tries algotrithmimport java.util.HashMap;import java.util.Map;class TrieNode {    Map<Character, TrieNode> children;    boolean isEndOfWord;    TrieNode() {        children = new HashMap<>();        isEndOfWord = false;    }}class Trie {    private TrieNode root;    Trie() {        root = new TrieNode();    }    void insert(String word) {        TrieNode curr = root;        for (char ch : word.toCharArray()) {            curr.children.putIfAbsent(ch, new TrieNode());            curr = curr.children.get(ch);        }        curr.isEndOfWord = true;    }    boolean search(String word) {        TrieNode curr = root;        for (char ch : word.toCharArray()) {            if (!curr.children.containsKey(ch)) {                return false;            }            curr = curr.children.get(ch);        }        return curr.isEndOfWord;    }    boolean startsWith(String prefix) {        TrieNode curr = root;        for (char ch : prefix.toCharArray()) {            if (!curr.children.containsKey(ch)) {                return false;            }            curr = curr.children.get(ch);        }        return true;    }    boolean delete(String word) {        return deleteHelper(root, word, 0);    }    private boolean deleteHelper(TrieNode curr, String word, int index) {        if (index == word.length()) {            if (!curr.isEndOfWord) {                return false; // Word does not exist in the Trie            }            curr.isEndOfWord = false; // Mark as deleted            return curr.children.isEmpty(); // Return true if no more children        }        char ch = word.charAt(index);        if (!curr.children.containsKey(ch)) {            return false; // Word does not exist in the Trie        }        TrieNode child = curr.children.get(ch);        boolean shouldDeleteChild = deleteHelper(child, word, index + 1);        if (shouldDeleteChild) {            curr.children.remove(ch); // Remove the child node if necessary            return curr.children.isEmpty(); // Return true if no more children        }        return false;    }}public class Main {    public static void main(String[] args) {        Trie car = new Trie();        //Inserting the elements        car.insert("Lamborghini");        car.insert("Mercedes-Benz");        car.insert("Land Rover");        car.insert("Maruti Suzuki");       //Before Deletion        System.out.println("Before Deletion");        //Printing the elements        System.out.println(car.search("Lamborghini"));       // Output: true        System.out.println(car.search("Mercedes-Benz")); // Output: true        System.out.println(car.search("Land Rover"));      // Output: true        System.out.println(car.search("Maruti Suzuki"));         // Output: true         //Deleting the elements using deletion operation        car.delete("Lamborghini");        car.delete("Land Rover");            // After Deletion        System.out.println("After Deletion");       // Prints the elements in the Boolean expression        System.out.println(car.search("Lamborghini"));      // Output: false        System.out.println(car.search("Mercedes-Benz"));   // Output: true        System.out.println(car.search("Land Rover"));      // Output: false        System.out.println(car.search("Maruti Suzuki"));  // Output: true    }}

Output

Before DeletiontruetruetruetrueAfter Deletionfalsetruefalsetrue

#python Code for Deletion operation of tries algorithmclass TrieNode:    def __init__(self):        self.children = {}        self.isEndOfWord = Falseclass Trie:    def __init__(self):        self.root = TrieNode()    def insert(self, word):        curr = self.root        for ch in word:            if ch not in curr.children:                curr.children[ch] = TrieNode()            curr = curr.children[ch]        curr.isEndOfWord = True    def search(self, word):        curr = self.root        for ch in word:            if ch not in curr.children:                return False            curr = curr.children[ch]        return curr.isEndOfWord    def startsWith(self, prefix):        curr = self.root        for ch in prefix:            if ch not in curr.children:                return False            curr = curr.children[ch]        return True    def delete(self, word):        return self.deleteHelper(self.root, word, 0)    def deleteHelper(self, curr, word, index):        if index == len(word):            if not curr.isEndOfWord:                return False  # Word does not exist in the Trie            curr.isEndOfWord = False  # Mark as deleted            return len(curr.children) == 0  # Return True if no more children        ch = word[index]        if ch not in curr.children:            return False  # Word does not exist in the Trie        child = curr.children[ch]        shouldDeleteChild = self.deleteHelper(child, word, index + 1)        if shouldDeleteChild:            del curr.children[ch]  # Remove the child node if necessary            return len(curr.children) == 0  # Return True if no more children        return Falsetrie = Trie()#inserting the elementstrie.insert("Lamborghini")trie.insert("Mercedes-Benz")trie.insert("Land Rover")trie.insert("Maruti Suzuki")#Before Deletionprint("Before Deletion:")print(trie.search("Lamborghini"))       # Output: Trueprint(trie.search("Mercedes-Benz"))     # Output: Trueprint(trie.search("Land Rover"))        # Output: Trueprint(trie.search("Maruti Suzuki"))     # Output: True#deleting the elements using Deletion operationtrie.delete("Lamborghini")trie.delete("Land Rover")#After Deletionprint("After Deletion:")#print elementsprint(trie.search("Lamborghini"))       # Output: Falseprint(trie.search("Mercedes-Benz"))     # Output: Trueprint(trie.search("Land Rover"))        # Output: Falseprint(trie.search("Maruti Suzuki"))     # Output: True

Output

Before Deletion:TrueTrueTrueTrueAfter Deletion:FalseTrueFalseTrue

//C program for search operation of tries algorithm#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#define ALPHABET_SIZE 26struct TrieNode {    struct TrieNode* children[ALPHABET_SIZE];    bool isEndOfWord;};struct TrieNode* createNode() {    struct TrieNode* node = (struct TrieNode*)malloc(sizeof(struct TrieNode));    node->isEndOfWord = false;        for (int i = 0; i < ALPHABET_SIZE; i++) {        node->children[i] = NULL;    }    return node;}void insert(struct TrieNode* root, char* word) {    struct TrieNode* curr = root;    for (int i = 0; word[i] != '\0'; i++) {        int index = word[i] - 'a';            if (curr->children[index] == NULL) {            curr->children[index] = createNode();        }          curr = curr->children[index];    }     curr->isEndOfWord = true;}bool search(struct TrieNode* root, char* word) {    struct TrieNode* curr = root;       for (int i = 0; word[i] != '\0'; i++) {        int index = word[i] - 'a';                if (curr->children[index] == NULL) {            return false;        }           curr = curr->children[index];    }    return (curr != NULL && curr->isEndOfWord);}bool startsWith(struct TrieNode* root, char* prefix) {    struct TrieNode* curr = root;    for (int i = 0; prefix[i] != '\0'; i++) {        int index = prefix[i] - 'a';          if (curr->children[index] == NULL) {            return false;        }         curr = curr->children[index];    }    return true;}int main() {    struct TrieNode* root = createNode();    //inserting the elements    insert(root, "Lamborghini");    insert(root, "Mercedes-Benz");    insert(root, "Land Rover");    insert(root, "Maruti Suzuki");       //Searching elements    printf("Searching Cars\n");    //Printing searched elements    printf("%d\n", search(root, "Lamborghini"));     // Output: 1 (true)    printf("%d\n", search(root, "Mercedes-Benz"));   // Output: 1 (true)    printf("%d\n", search(root, "Honda"));           // Output: 0 (false)    printf("%d\n", search(root, "Land Rover"));      // Output: 1 (true)    printf("%d\n", search(root, "BMW"));             // Output: 0 (false)       //Searching the elements the name starts with?    printf("Cars name starts with\n");    //Printing the elements    printf("%d\n", startsWith(root, "Lambo"));       // Output: 1 (true)    printf("%d\n", startsWith(root, "Hon"));         // Output: 0 (false)    printf("%d\n", startsWith(root, "Hy"));          // Output: 0 (false)    printf("%d\n", startsWith(root, "Mar"));         // Output: 1 (true)    printf("%d\n", startsWith(root, "Land"));        // Output: 1 (true)       return 0;}

Output

Searching Cars11010Cars name starts with10011

//C++ code for Search operation of tries algorithm#include <iostream>#include <unordered_map>using namespace std;class TrieNode {public:    unordered_map<char, TrieNode*> children;    bool isEndOfWord;        TrieNode() {        isEndOfWord = false;    }};class Trie {private:    TrieNode* root;public:    Trie() {        root = new TrieNode();    }    void insert(string word) {        TrieNode* curr = root;        for (char ch : word) {            if (curr->children.find(ch) == curr->children.end()) {                curr->children[ch] = new TrieNode();            }            curr = curr->children[ch];        }        curr->isEndOfWord = true;    }    bool search(string word) {        TrieNode* curr = root;        for (char ch : word) {            if (curr->children.find(ch) == curr->children.end()) {                return false;            }            curr = curr->children[ch];        }        return curr->isEndOfWord;    }    bool startsWith(string prefix) {        TrieNode* curr = root;        for (char ch : prefix) {            if (curr->children.find(ch) == curr->children.end()) {                return false;            }            curr = curr->children[ch];        }        return true;    }};int main() {    Trie car;    //inserting the elements    car.insert("Lamborghini");    car.insert("Mercedes-Benz");    car.insert("Land Rover");    car.insert("Maruti Suzuki");   //searching elements    cout<< "Searching Cars"<< endl;     // Printing searched elements in Boolean expression    cout << car.search("Lamborghini") << endl;     // Output: 1 (true)    cout << car.search("Mercedes-Benz") << endl;    // Output: 1 (true)    cout << car.search("Honda") << endl;     // Output: 0 (false)    cout << car.search("Land Rover") << endl;    // Output: 1 (true)    cout << car.search("BMW") << endl;   // Output: 0 (false)      //searching names starts with?    cout<<"cars name starts with" << endl;    //Printing the elements    cout << car.startsWith("Lambo") << endl;   // Output: 1 (true)    cout << car.startsWith("Hon") << endl;    // Output: 0 (false)    cout << car.startsWith("Hy") << endl;    // Output: 0 (false)    cout << car.startsWith("Mar") << endl;    // Output: 1 (true)    cout << car.startsWith("Land") << endl;   // Output: 1 (true)    return 0;}

Output

Searching Cars11010cars name starts with10011

//Java program for tries Algorithmimport java.util.HashMap;import java.util.Map;class TrieNode {    Map<Character, TrieNode> children;    boolean isEndOfWord;    TrieNode() {        children = new HashMap<>();        isEndOfWord = false;    }}class Trie {    private TrieNode root;    Trie() {        root = new TrieNode();    }    void insert(String word) {        TrieNode curr = root;        for (char ch : word.toCharArray()) {            curr.children.putIfAbsent(ch, new TrieNode());            curr = curr.children.get(ch);        }        curr.isEndOfWord = true;    }    boolean search(String word) {        TrieNode curr = root;        for (char ch : word.toCharArray()) {            if (!curr.children.containsKey(ch)) {                return false;            }            curr = curr.children.get(ch);        }        return curr.isEndOfWord;    }    boolean startsWith(String prefix) {        TrieNode curr = root;        for (char ch : prefix.toCharArray()) {            if (!curr.children.containsKey(ch)) {                return false;            }            curr = curr.children.get(ch);        }        return true;    }}public class Main {    public static void main(String[] args) {        Trie car = new Trie();        //Inserting the elements        car.insert("Lamborghini");        car.insert("Mercedes-Benz");        car.insert("Land Rover");        car.insert("Maruti Suzuki");        //searching the elements        System.out.println("Searching Cars");        //Printing the searched elements        System.out.println(car.search("Lamborghini"));     // Output: true        System.out.println(car.search("Mercedes-Benz"));   // Output: true        System.out.println(car.search("Honda"));           // Output: false        System.out.println(car.search("Land Rover"));      // Output: true        System.out.println(car.search("BMW"));             // Output: false          //searching the elements name start with?        System.out.println("Cars name starts with");        //Printing the elements        System.out.println(car.startsWith("Lambo"));       // Output: true        System.out.println(car.startsWith("Hon"));         // Output: false        System.out.println(car.startsWith("Hy"));          // Output: false        System.out.println(car.startsWith("Mar"));         // Output: true        System.out.println(car.startsWith("Land"));        // Output: true    }}

Output

Searching CarstruetruefalsetruefalseCars name starts withtruefalsefalsetruetrue

#Python code for Search operation of tries algorithmclass TrieNode:    def __init__(self):        self.children = {}        self.isEndOfWord = Falseclass Trie:    def __init__(self):        self.root = TrieNode()    def insert(self, word):        curr = self.root        for ch in word:            if ch not in curr.children:                curr.children[ch] = TrieNode()            curr = curr.children[ch]        curr.isEndOfWord = True    def search(self, word):        curr = self.root        for ch in word:            if ch not in curr.children:                return False            curr = curr.children[ch]        return curr.isEndOfWord    def startsWith(self, prefix):        curr = self.root        for ch in prefix:            if ch not in curr.children:                return False            curr = curr.children[ch]        return Trueif __name__ == '__main__':    car = Trie()   #Inserting the elements    car.insert("Lamborghini")    car.insert("Mercedes-Benz")    car.insert("Land Rover")    car.insert("Maruti Suzuki")    #Searching elements    print("Searching Cars")    #Printing the searched elements    print(car.search("Lamborghini"))     # Output: True    print(car.search("Mercedes-Benz"))   # Output: True    print(car.search("Honda"))           # Output: False    print(car.search("Land Rover"))      # Output: True    print(car.search("BMW"))             # Output: False    #printing elements name starts with?    print("Cars name starts with")    print(car.startsWith("Lambo"))       # Output: True    print(car.startsWith("Hon"))         # Output: False    print(car.startsWith("Hy"))          # Output: False    print(car.startsWith("Mar"))         # Output: True    print(car.startsWith("Land"))        # Output: True

Output

Before Deletion:TrueTrueTrueTrueAfter Deletion:FalseTrueFalseTrue

//C code for Max Heap construction  Algorithm#include <stdio.h>#include <stdlib.h>// Structure to represent a heaptypedef struct {    int* array;     // Array to store heap elements    int capacity;   // Maximum capacity of the heap    int size;       // Current size of the heap} Heap;// Function to create a new heapHeap* createHeap(int capacity){    Heap* heap = (Heap*)malloc(sizeof(Heap));    heap->array = (int*)malloc(capacity * sizeof(int));    heap->capacity = capacity;    heap->size = 0;    return heap;}// Function to swap two elements in the heapvoid swap(int* a, int* b){    int temp = *a;    *a = *b;    *b = temp;}// Function to heapify a subtree rooted at index ivoid heapify(Heap* heap, int i){    int largest = i;    int left = 2 * i + 1;    int right = 2 * i + 2;    // Check if the left child is larger than the root    if (left < heap->size && heap->array[left] > heap->array[largest])        largest = left;    // Check if the right child is larger than the largest so far    if (right < heap->size && heap->array[right] > heap->array[largest])        largest = right;    // If the largest is not the root, swap the root with the largest    if (largest != i) {        swap(&heap->array[i], &heap->array[largest]);        heapify(heap, largest);    }}// Function to insert a new element into the heapvoid insert(Heap* heap, int value){    if (heap->size == heap->capacity) {        printf("Heap is full. Cannot insert more elements.\n");        return;    }    // Insert the new element at the end    int i = heap->size++;    heap->array[i] = value;    // Fix the heap property if it is violated    while (i != 0 && heap->array[(i - 1) / 2] < heap->array[i]) {        swap(&heap->array[i], &heap->array[(i - 1) / 2]);        i = (i - 1) / 2;    }}// Function to extract the maximum element from the heapint extractMax(Heap* heap){    if (heap->size == 0) {        printf("Heap is empty. Cannot extract maximum element.\n");        return -1;    }    // Store the root element    int max = heap->array[0];    // Replace the root with the last element    heap->array[0] = heap->array[heap->size - 1];    heap->size--;    // Heapify the root    heapify(heap, 0);    return max;}// Function to print the elements of the heapvoid printHeap(Heap* heap){    printf("Heap elements: ");    for (int i = 0; i < heap->size; i++) {        printf("%d ", heap-<array[i]);    }    printf("\n");}// Example usage of the heapint main(){    Heap* heap = createHeap(10);    insert(heap, 35);    insert(heap, 33);    insert(heap, 42);    insert(heap, 10);    insert(heap, 14);    insert(heap, 19);    insert(heap, 27);    insert(heap, 44);    insert(heap, 26);    insert(heap, 31);    printHeap(heap);    int max = extractMax(heap);    printf("Maximum element: %d\n", max);    return 0;}

Output

Heap elements: 44 42 35 33 31 19 27 10 26 14 Maximum element: 44

//C++ code for Max Heap construction  Algorithm#include <iostream>// Structure to represent a heapstruct Heap {    int* array;     // Array to store heap elements    int capacity;   // Maximum capacity of the heap    int size;       // Current size of the heap};// Function to create a new heapHeap* createHeap(int capacity){    Heap* heap = new Heap;    heap->array = new int[capacity];    heap->capacity = capacity;    heap->size = 0;    return heap;}// Function to swap two elements in the heapvoid swap(int& a, int& b){    int temp = a;    a = b;    b = temp;}// Function to heapify a subtree rooted at index ivoid heapify(Heap* heap, int i){    int largest = i;    int left = 2 * i + 1;    int right = 2 * i + 2;    // Check if the left child is larger than the root    if (left <heap->size && heap->array[left] > heap->array[largest])        largest = left;    // Check if the right child is larger than the largest so far    if (right <heap->size && heap->array[right] > heap->array[largest])        largest = right;    // If the largest is not the root, swap the root with the largest    if (largest != i) {        swap(heap->array[i], heap->array[largest]);        heapify(heap, largest);    }}// Function to insert a new element into the heapvoid insert(Heap* heap, int value){    if (heap->size == heap->capacity) {        std::cout << "Heap is full. Cannot insert more elements." << std::endl;        return;    }    // Insert the new element at the end    int i = heap->size++;    heap->array[i] = value;    // Fix the heap property if it is violated    while (i != 0 && heap->array[(i - 1) / 2] < heap->array[i]) {        swap(heap->array[i], heap->array[(i - 1) / 2]);        i = (i - 1) / 2;    }}// Function to extract the maximum element from the heapint extractMax(Heap* heap){    if (heap->size == 0) {        std::cout << "Heap is empty. Cannot extract maximum element." << std::endl;        return -1;    }    // Store the root element    int max = heap->array[0];    // Replace the root with the last element    heap->array[0] = heap->array[heap->size - 1];    heap->size--;    // Heapify the root    heapify(heap, 0);    return max;}// Function to print the elements of the heapvoid printHeap(Heap* heap){    std::cout << "Heap elements: ";    for (int i = 0; i < heap->size; i++) {        std::cout << heap->array[i] << " ";    }    std::cout << std::endl;}// Example usage of the heapint main(){    Heap* heap = createHeap(10);    insert(heap, 35);    insert(heap, 33);    insert(heap, 42);    insert(heap, 10);    insert(heap, 14);    insert(heap, 19);    insert(heap, 27);    insert(heap, 44);    insert(heap, 26);    insert(heap, 31);    printHeap(heap);    int max = extractMax(heap);    std::cout << "Maximum element: " << max << std::endl;    return 0;}

Output

Heap elements: 44 42 35 33 31 19 27 10 26 14 Maximum element: 44

// Java code for for Max Heap construction  Algorithm//Structure to represent a heappublic class MaxHeap {    private int[] heap; // To store heap elements    private int capacity; // Maximum capacity of the heap    private int size; // Current size of the heap    // To create a new heap    public MaxHeap(int capacity) {        this.capacity = capacity;        this.size = 0;        this.heap = new int[capacity];    }    private int parent(int i) {        return (i - 1) / 2;    }    private int leftChild(int i) {        return 2 * i + 1;    }    private int rightChild(int i) {        return 2 * i + 2;    }    private void swap(int i, int j) {        int temp = heap[i];        heap[i] = heap[j];        heap[j] = temp;    }   // Heapify a subtree rooted at index i    private void heapifyDown(int i) {        int largest = i;        int left = leftChild(i);        int right = rightChild(i);             // Check if the left child is larger than the root        if (left < size && heap[left] > heap[largest])            largest = left;                 // Check if the right child is larger than the largest so far        if (right < size && heap[right] > heap[largest])            largest = right;        // If the largest is not the root, swap the root with the largest        if (largest != i) {            swap(i, largest);            heapifyDown(largest);        }    }    private void heapifyUp(int i) {        while (i > 0 && heap[i] > heap[parent(i)]) {            int parent = parent(i);            swap(i, parent);            i = parent;        }    }    // Insert the new element at the end    public void insert(int value) {        if (size == capacity) {            System.out.println("Heap is full. Cannot insert more elements.");            return;        }        heap[size] = value;        size++;        heapifyUp(size - 1);    }    // Function to extract the maximum element from the heap    public int extractMax() {        if (size == 0) {            System.out.println("Heap is empty. Cannot extract maximum element.");            return -1;        }        // store th root element        int max = heap[0];        //Replace the root with the last elements        heap[0] = heap[size - 1];        size--;        heapifyDown(0);        return max;    }     //print the elements of the heap    public void printHeap() {        System.out.print("Heap elements: ");        for (int i = 0; i < size; i++) {            System.out.print(heap[i] + " ");        }        System.out.println();    }    public static void main(String[] args) {        MaxHeap heap = new MaxHeap(10);        heap.insert(35);        heap.insert(33);        heap.insert(42);        heap.insert(10);        heap.insert(14);        heap.insert(19);        heap.insert(27);        heap.insert(44);        heap.insert(26);        heap.insert(31);        heap.printHeap();        int max = heap.extractMax();        System.out.println("Maximum element: " + max);    }}

Output

Heap elements: 44 42 35 33 31 19 27 10 26 14 Maximum element: 44

# Python code for for Max Heap construction  Algorithmclass MaxHeap:    def __init__(self):        self.heap = []    def parent(self, i):        return (i - 1) // 2    def left_child(self, i):        return 2 * i + 1    def right_child(self, i):        return 2 * i + 2    #Function to swap two elements in the heap    def swap(self, i, j):        self.heap[i], self.heap[j] = self.heap[j], self.heap[i]    # Function to heapify a subtree rooted at index i    def heapify_down(self, i):        left = self.left_child(i)        right = self.right_child(i)        largest = i        #Check if the left child is larger than the root        if left < len(self.heap) and self.heap[left] >self.heap[largest]:            largest = left        # Check if the right child is larger than the largest so far        if right < len(self.heap) and self.heap[right] > self.heap[largest]:            largest = right        # If the largest is not the root, swap the root with the largest        if largest != i:            self.swap(i, largest)            self.heapify_down(largest)    def heapify_up(self, i):        while i > 0 and self.heap[i] > self.heap[self.parent(i)]:            parent = self.parent(i)            self.swap(i, parent)            i = parent    # Insert the new element at the end    def insert(self, value):        self.heap.append(value)        # Fix the heap property if it is violated        self.heapify_up(len(self.heap) - 1)    # Function to extract the maximum element from the heap    def extract_max(self):        if len(self.heap) == 0:            print("Heap is empty. Cannot extract maximum element.")            return None        max_value = self.heap[0]        self.heap[0] = self.heap[-1]        self.heap.pop()        self.heapify_down(0)        return max_value    # Function to print the elements of the heap    def print_heap(self):        print("Heap elements:", end=" ")        for value in self.heap:            print(value, end=" ")        print()# Example usage of the heapheap = MaxHeap()heap.insert(35)heap.insert(33)heap.insert(42)heap.insert(10)heap.insert(14)heap.insert(19)heap.insert(27)heap.insert(44)heap.insert(26)heap.insert(31)heap.print_heap()max_value = heap.extract_max()print("Maximum element:", max_value)

Output

Heap elements: 44 42 35 33 31 19 27 10 26 14 Maximum element: 44s

//C code for Max Heap Deletion Algorithm#include <stdio.h>#include <stdlib.h>// Structure to represent a heaptypedef struct {    int* array;     // Array to store heap elements    int capacity;   // Maximum capacity of the heap    int size;       // Current size of the heap} Heap;// create a new heapHeap* createHeap(int capacity){    Heap* heap = (Heap*)malloc(sizeof(Heap));    heap->array = (int*)malloc(capacity * sizeof(int));    heap->capacity = capacity;    heap->size = 0;    return heap;}// swap two elements in the heapvoid swap(int* a, int* b){    int temp = *a;    *a = *b;    *b = temp;}// Heapify a subtree rooted at index ivoid heapify(Heap* heap, int i){    int largest = i;    int left = 2 * i + 1;    int right = 2 * i + 2;    // Check if the left child is larger than the root    if (left < heap->size && heap->array[left] > heap->array[largest])        largest = left;    // Check if the right child is larger than the largest so far    if (right < heap->size && heap->array[right] > heap->array[largest])        largest = right;    // If the largest is not the root, swap the root with the largest    if (largest != i) {        swap(&heap->array[i], &heap->array[largest]);        heapify(heap, largest);    }}// Function to insert a new element into the heapvoid insert(Heap* heap, int value){    if (heap->size == heap->capacity) {        printf("Heap is full. Cannot insert more elements.\n");        return;    }    // Insert the new element at the end    int i = heap->size++;    heap->array[i] = value;    // Fix the heap property if it is violated    while (i != 0 && heap->array[(i - 1) / 2] < heap->array[i]) {        swap(&heap->array[i], &heap->array[(i - 1) / 2]);        i = (i - 1) / 2;    }}// delete the maximum element from the heapint deleteMax(Heap* heap){    if (heap->size == 0) {        printf("Heap is empty. Cannot extract maximum element.\n");        return -1;    }    // Store the root element    int max = heap->array[0];    // Replace the root with the last element    heap->array[0] = heap->array[heap->size - 1];    heap->size--;    // Heapify the root    heapify(heap, 0);    return max;}// print the elements of the heapvoid printHeap(Heap* heap){    printf("Heap elements: ");    for (int i = 0; i < heap->size; i++) {        printf("%d ", heap->array[i]);    }    printf("\n");}// Deallocate memory occupied by the heapvoid destroyHeap(Heap* heap){    free(heap->array);    free(heap);}// Example usage of the heapint main(){    Heap* heap = createHeap(10);    insert(heap, 35);    insert(heap, 33);    insert(heap, 42);    insert(heap, 10);    insert(heap, 14);    insert(heap, 19);    insert(heap, 27);    insert(heap, 44);    insert(heap, 26);    insert(heap, 31);    printHeap(heap);    // Deleting the maximum element in the heap    int max = deleteMax(heap);    printf("Maximum element: %d\n", max);    printHeap(heap);    destroyHeap(heap);    return 0;}

Output

Heap elements: 44 42 35 33 31 19 27 10 26 14 Maximum element: 44Heap elements: 42 33 35 26 31 19 27 10 14

//C++ code for Max Heap Deletion Algorithm#include <iostream>// Structure to represent a heapstruct Heap {    int* array;     // Array to store heap elements    int capacity;   // Maximum capacity of the heap    int size;       // Current size of the heap};// Create a new heapHeap* createHeap(int capacity){    Heap* heap = new Heap;    heap->array = new int[capacity];    heap->capacity = capacity;    heap->size = 0;    return heap;}// Swap two elements in the heapvoid swap(int& a, int& b){    int temp = a;    a = b;    b = temp;}// Heapify a subtree rooted at index ivoid heapify(Heap* heap, int i){    int largest = i;    int left = 2 * i + 1;    int right = 2 * i + 2;    // Check if the left child is larger than the root    if (left < heap->size && heap->array[left] > heap->array[largest])        largest = left;    // Check if the right child is larger than the largest so far    if (right < heap->size && heap->array[right] > heap->array[largest])        largest = right;    // If the largest is not the root, swap the root with the largest    if (largest != i) {        swap(heap->array[i], heap->array[largest]);        heapify(heap, largest);    }}// Function to insert a new element into the heapvoid insert(Heap* heap, int value){    if (heap->size == heap->capacity) {        std::cout << "Heap is full. Cannot insert more elements." << std::endl;        return;    }    // Insert the new element at the end    int i = heap->size++;    heap->array[i] = value;    // Fix the heap property if it is violated    while (i != 0 && heap->array[(i - 1) / 2] < heap->array[i]) {        swap(heap->array[i], heap->array[(i - 1) / 2]);        i = (i - 1) / 2;    }}// Function to delete the maximum element from the heapint deleteMax(Heap* heap){    if (heap->size == 0) {        std::cout << "Heap is empty. Cannot extract maximum element." << std::endl;        return -1;    }    // Store the root element    int max = heap->array[0];    // Replace the root with the last element    heap->array[0] = heap->array[heap->size - 1];    heap->size--;    // Heapify the root    heapify(heap, 0);    return max;}// Function to print the elements of the heapvoid printHeap(Heap* heap){    std::cout << "Heap elements: ";    for (int i = 0; i < heap->size; i++) {        std::cout << heap->array[i] << " ";    }    std::cout << std::endl;}// Function to deallocate memory occupied by the heapvoid destroyHeap(Heap* heap){    delete[] heap->array;    delete heap;}// Example usage of the heapint main(){    Heap* heap = createHeap(10);    insert(heap, 35);    insert(heap, 33);    insert(heap, 42);    insert(heap, 10);    insert(heap, 14);    insert(heap, 19);    insert(heap, 27);    insert(heap, 44);    insert(heap, 26);    insert(heap, 31);    printHeap(heap);    int max = deleteMax(heap);    std::cout << "Maximum element: " << max << std::endl;    printHeap(heap);    destroyHeap(heap);    return 0;}

Output

Heap elements: 44 42 35 33 31 19 27 10 26 14 Maximum element: 44Heap elements: 42 33 35 26 31 19 27 10 14

// Java code for for Max Heap Deletion  Algorithm// Structure to represent a heapclass Heap {    private int[] array;  // Array to store heap elements    private int capacity;  // Maximum capacity of the heap    private int size;      // Current size of the heap    // To create a new heap    public Heap(int capacity) {        this.array = new int[capacity];        this.capacity = capacity;        this.size = 0;    }    // Swap two elements in the heap    private void swap(int a, int b) {        int temp = array[a];        array[a] = array[b];        array[b] = temp;    }    // Heapify a subtree rooted at index i    private void heapify(int i) {        int largest = i;        int left = 2 * i + 1;        int right = 2 * i + 2;             // Check if the left child is larger than the root        if (left < size && array[left] > array[largest])            largest = left;                 // Check if the right child is larger than the largest so far        if (right < size && array[right] > array[largest])            largest = right;        // If the largest is not the root, swap the root with the largest        if (largest != i) {            swap(i, largest);            heapify(largest);        }    }    // Insert a new element into the heap    public void insert(int value) {        if (size == capacity) {            System.out.println("Heap is full. Cannot insert more elements.");            return;        }        // Insert the new element at the end        int i = size++;        array[i] = value;        // Fix the heap property if it is violated        while (i != 0 && array[(i - 1) / 2] < array[i]) {            swap(i, (i - 1) / 2);            i = (i - 1) / 2;        }    }    // Delete the maximum element from the heap    public int deleteMax() {        if (size == 0) {            System.out.println("Heap is empty. Cannot extract maximum element.");            return -1;        }        // Store the root element        int max = array[0];        // Replace the root with the last element        array[0] = array[size - 1];        size--;        // Heapify the root        heapify(0);        return max;    }    // Print the elements of the heap    public void printHeap() {        System.out.print("Heap elements: ");        for (int i = 0; i < size; i++) {            System.out.print(array[i] + " ");        }        System.out.println();    }    // Deallocate memory occupied by the heap    public void destroyHeap() {        array = null;        size = 0;    }}//Inserting the elementspublic class Main {    public static void main(String[] args) {        Heap heap = new Heap(10);        heap.insert(35);        heap.insert(33);        heap.insert(42);        heap.insert(10);        heap.insert(14);        heap.insert(19);        heap.insert(27);        heap.insert(44);        heap.insert(26);        heap.insert(31);        heap.printHeap();        int max = heap.deleteMax();        System.out.println("Maximum element: " + max);          //Printing the heap elements after deletion of max element        heap.printHeap();        heap.destroyHeap();    }}

Output

Heap elements: 44 42 35 33 31 19 27 10 26 14 Maximum element: 44Heap elements: 42 33 35 26 31 19 27 10 14

#Python code for Max Heap Deletion Algorithmclass Heap:    def __init__(self, capacity):        self.array = [0] * capacity  #array to store heap elements        self.capacity = capacity  #maximum capacity of the heap        self.size = 0  #Current size of the heap    # swap two elements in the heap    def swap(self, a, b):        self.array[a], self.array[b] = self.array[b], self.array[a]    # Heapify a subtree rooted at index i    def heapify(self, i):        largest = i        left = 2 * i + 1        right = 2 * i + 2        # Check if the left child is larger than the root        if left < self.size and self.array[left] > self.array[largest]:            largest = left        # Check if the right child is larger than the largest so far        if right < self.size and self.array[right] > self.array[largest]:            largest = right        # If the largest is not the root, swap the root with the largest        if largest != i:            self.swap(i, largest)            self.heapify(largest)    # insert a new element into the heap    def insert(self, value):        if self.size == self.capacity:            print("Heap is full. Cannot insert more elements.")            return        # Insert the new element at the end        i = self.size        self.size += 1        self.array[i] = value        # Fix the heap property if it is violated        while i != 0 and self.array[(i - 1) // 2] < self.array[i]:            self.swap(i, (i - 1) // 2)            i = (i - 1) // 2    # delete the maximum element from the heap    def deleteMax(self):        if self.size == 0:            print("Heap is empty. Cannot extract maximum element.")            return -1        # store the root element        max_value = self.array[0]        # Replace the root with the last element        self.array[0] = self.array[self.size - 1]        self.size -= 1        # Heapify the root        self.heapify(0)        return max_value    # print the elements of the heap    def printHeap(self):        print("Heap elements:", end=" ")        for i in range(self.size):            print(self.array[i], end=" ")        print()    # deallocate memory occupied by the heap    def destroyHeap(self):        self.array = []        self.size = 0# Example usage of the heapheap = Heap(10)heap.insert(35)heap.insert(33)heap.insert(42)heap.insert(10)heap.insert(14)heap.insert(19)heap.insert(27)heap.insert(44)heap.insert(26)heap.insert(31)heap.printHeap()max_value = heap.deleteMax()print("Maximum element:", max_value)heap.printHeap()heap.destroyHeap()

Output

Heap elements: 44 42 35 33 31 19 27 10 26 14 Maximum element: 44Heap elements: 42 33 35 26 31 19 27 10 14

// C program for Recursion Data Structure#include <stdio.h>int factorial(int n) {    // Base case: factorial of 0 is 1    if (n == 0)        return 1;    // Recursive case: multiply n with factorial of (n-1)    return n * factorial(n - 1);}int main() {    // case 1    int number = 6;    printf("Number is: %d\n" , 6);    //case 2    if (number < 0) {        printf("Error: Factorial is undefined for negative numbers.\n");        return 1;    }     int result = factorial(number);    //print the output    printf("Factorial of %d is: %d\n", number, result);    return 0;}

Output

Number is: 6Factorial of 6 is: 720

// CPP program for Recursion Data Structure#include <iostream>int factorial(int n) {    // Base case: factorial of 0 is 1    if (n == 0)        return 1;      // Recursive case: multiply n with factorial of (n-1)    return n * factorial(n - 1);}int main() {    // case 1    int number = 6;    std::cout<<"Number is: "<<number<<"\n";    //case 2    if (number < 0) {        std::cout << "Error: Factorial is undefined for negative numbers.\n";        return 1;    }    int result = factorial(number);    //print the output    std::cout << "Factorial of " << number << " is: " << result << std::endl;      return 0;}

Output

Number is:  6Factorial of 6 is: 720

// Java program for Recursion Data Structureimport java.util.Scanner;public class Main {    public static int factorial(int n) {        // Base case: factorial of 0 is 1        if (n == 0)            return 1;        // Recursive case: multiply n with factorial of (n-1)        return n * factorial(n - 1);    }    public static void main(String[] args) {        //Case 1        int number = 6;System.out.println("Number is: " + number);        //Case 2        if (number < 0) {            System.out.println("Error: Factorial is undefined for negative numbers.");            System.exit(1);        }        int result = factorial(number);        //print the output        System.out.println("Factorial of " + number + " is: " + result);    }}

Output

Number is: 6Factorial of 6 is: 720

# Python program for Recursion Data Structuredef factorial(n):    #Base Case: factorial of 0 is 1    if n == 0:        return 1    # Recursive case: multiply n with factorial of (n-1)    return n * factorial(n - 1)#Case 1:number = 6;print("Number is: ", number);#Case 2:if number < 0:    print("Error: Factorial is undefined for negative numbers.")else:    result = factorial(number)    # print the output    print("Factorial of", number, "is: ", result)

Output

Number is:  6Factorial of 6 is: 720

#include <stdio.h>#include <stdbool.h>#define MAX 10int list[MAX] = {1,8,4,6,0,3,5,2,7,9};void display(){   int i;   printf("[");   // navigate through all items    for(i = 0; i < MAX; i++) {      printf("%d ",list[i]);   }   printf("]\n");}void bubbleSort() {   int temp;   int i,j;   bool swapped = false;          // loop through all numbers    for(i = 0; i < MAX-1; i++) {       swapped = false;      // loop through numbers falling ahead       for(j = 0; j < MAX-1-i; j++) {         printf("Items compared: [ %d, %d ] ", list[j],list[j+1]);         // check if next number is lesser than current no         //   swap the numbers.          //  (Bubble up the highest number)          if(list[j] > list[j+1]) {            temp = list[j];            list[j] = list[j+1];            list[j+1] = temp;            swapped = true;            printf(" => swapped [%d, %d]\n",list[j],list[j+1]);         } else {            printf(" => not swapped\n");         }      }      // if no number was swapped that means       //   array is sorted now, break the loop.       if(!swapped) {         break;      }      printf("Iteration %d#: ",(i+1));       display();                        }    }int main() {   printf("Input Array: ");   display();   printf("\n");   bubbleSort();   printf("\nOutput Array: ");   display();}

Output

Input Array: [1 8 4 6 0 3 5 2 7 9 ]Items compared: [ 1, 8 ]  => not swappedItems compared: [ 8, 4 ]  => swapped [4, 8]Items compared: [ 8, 6 ]  => swapped [6, 8]Items compared: [ 8, 0 ]  => swapped [0, 8]Items compared: [ 8, 3 ]  => swapped [3, 8]Items compared: [ 8, 5 ]  => swapped [5, 8]Items compared: [ 8, 2 ]  => swapped [2, 8]Items compared: [ 8, 7 ]  => swapped [7, 8]Items compared: [ 8, 9 ]  => not swappedIteration 1#: [1 4 6 0 3 5 2 7 8 9 ]Items compared: [ 1, 4 ]  => not swappedItems compared: [ 4, 6 ]  => not swappedItems compared: [ 6, 0 ]  => swapped [0, 6]Items compared: [ 6, 3 ]  => swapped [3, 6]Items compared: [ 6, 5 ]  => swapped [5, 6]Items compared: [ 6, 2 ]  => swapped [2, 6]Items compared: [ 6, 7 ]  => not swappedItems compared: [ 7, 8 ]  => not swappedIteration 2#: [1 4 0 3 5 2 6 7 8 9 ]Items compared: [ 1, 4 ]  => not swappedItems compared: [ 4, 0 ]  => swapped [0, 4]Items compared: [ 4, 3 ]  => swapped [3, 4]Items compared: [ 4, 5 ]  => not swappedItems compared: [ 5, 2 ]  => swapped [2, 5]Items compared: [ 5, 6 ]  => not swappedItems compared: [ 6, 7 ]  => not swappedIteration 3#: [1 0 3 4 2 5 6 7 8 9 ]Items compared: [ 1, 0 ]  => swapped [0, 1]Items compared: [ 1, 3 ]  => not swappedItems compared: [ 3, 4 ]  => not swappedItems compared: [ 4, 2 ]  => swapped [2, 4]Items compared: [ 4, 5 ]  => not swappedItems compared: [ 5, 6 ]  => not swappedIteration 4#: [0 1 3 2 4 5 6 7 8 9 ]Items compared: [ 0, 1 ]  => not swappedItems compared: [ 1, 3 ]  => not swappedItems compared: [ 3, 2 ]  => swapped [2, 3]Items compared: [ 3, 4 ]  => not swappedItems compared: [ 4, 5 ]  => not swappedIteration 5#: [0 1 2 3 4 5 6 7 8 9 ]Items compared: [ 0, 1 ]  => not swappedItems compared: [ 1, 2 ]  => not swappedItems compared: [ 2, 3 ]  => not swappedItems compared: [ 3, 4 ]  => not swappedOutput Array: [0 1 2 3 4 5 6 7 8 9 ]

// C++ Code for Tower of Hanoi#include <iostream>#include <array>#include <algorithm>const int MAX = 10;std::array<int, MAX> list = {1, 8, 4, 6, 0, 3, 5, 2, 7, 9};void display() {   std::cout << "[";   // navigate through all items    for (int i = 0; i < MAX; i++) {      std::cout << list[i] << " ";   }   std::cout << "]\n";}void bubbleSort() {   int temp;   bool swapped = false;          // loop through all numbers    for (int i = 0; i < MAX - 1; i++) {       swapped = false;      // loop through numbers falling ahead       for (int j = 0; j < MAX - 1 - i; j++) {         std::cout << "Items compared: [" << list[j] << ", " << list[j+1] << "] ";         // check if next number is lesser than current no         // swap the numbers.          // (Bubble up the highest number)          if (list[j] > list[j+1]) {            std::swap(list[j], list[j+1]);            swapped = true;            std::cout << "=> swapped [" << list[j] << ", " << list[j+1] << "]\n";         } else {            std::cout << "=> not swapped\n";         }      }      // if no number was swapped that means       // array is sorted now, break the loop.       if (!swapped) {         break;      }        std::cout << "Iteration " << (i+1) << "#: ";       display();                        }    }int main() {   std::cout << "Input Array: ";   display();   std::cout << "\n";   bubbleSort();   std::cout << "\nOutput Array: ";   display();   return 0;}

Output

Input Array: [1 8 4 6 0 3 5 2 7 9 ]Items compared: [1, 8] => not swappedItems compared: [8, 4] => swapped [4, 8]Items compared: [8, 6] => swapped [6, 8]Items compared: [8, 0] => swapped [0, 8]Items compared: [8, 3] => swapped [3, 8]Items compared: [8, 5] => swapped [5, 8]Items compared: [8, 2] => swapped [2, 8]Items compared: [8, 7] => swapped [7, 8]Items compared: [8, 9] => not swappedIteration 1#: [1 4 6 0 3 5 2 7 8 9 ]Items compared: [1, 4] => not swappedItems compared: [4, 6] => not swappedItems compared: [6, 0] => swapped [0, 6]Items compared: [6, 3] => swapped [3, 6]Items compared: [6, 5] => swapped [5, 6]Items compared: [6, 2] => swapped [2, 6]Items compared: [6, 7] => not swappedItems compared: [7, 8] => not swappedIteration 2#: [1 4 0 3 5 2 6 7 8 9 ]Items compared: [1, 4] => not swappedItems compared: [4, 0] => swapped [0, 4]Items compared: [4, 3] => swapped [3, 4]Items compared: [4, 5] => not swappedItems compared: [5, 2] => swapped [2, 5]Items compared: [5, 6] => not swappedItems compared: [6, 7] => not swappedIteration 3#: [1 0 3 4 2 5 6 7 8 9 ]Items compared: [1, 0] => swapped [0, 1]Items compared: [1, 3] => not swappedItems compared: [3, 4] => not swappedItems compared: [4, 2] => swapped [2, 4]Items compared: [4, 5] => not swappedItems compared: [5, 6] => not swappedIteration 4#: [0 1 3 2 4 5 6 7 8 9 ]Items compared: [0, 1] => not swappedItems compared: [1, 3] => not swappedItems compared: [3, 2] => swapped [2, 3]Items compared: [3, 4] => not swappedItems compared: [4, 5] => not swappedIteration 5#: [0 1 2 3 4 5 6 7 8 9 ]Items compared: [0, 1] => not swappedItems compared: [1, 2] => not swappedItems compared: [2, 3] => not swappedItems compared: [3, 4] => not swappedOutput Array: [0 1 2 3 4 5 6 7 8 9 ]

//Java Code for Tower of Hanoiimport java.util.Arrays;public class BubbleSort {    public static final int MAX = 10;    public static int[] list = {1, 8, 4, 6, 0, 3, 5, 2, 7, 9};    public static void display() {        System.out.print("[");        // navigate through all items        for (int i = 0; i < MAX; i++) {            System.out.print(list[i] + " ");        }        System.out.println("]");    }    public static void bubbleSort() {        boolean swapped;        // loop through all numbers        for (int i = 0; i < MAX - 1; i++) {            swapped = false;            // loop through numbers falling ahead            for (int j = 0; j < MAX - 1 - i; j++) {                System.out.print("Items compared: [" + list[j] + ", " + list[j + 1] + "] ");                // check if next number is lesser than current no                // swap the numbers.                // (Bubble up the highest number)                if (list[j] > list[j + 1]) {                    int temp = list[j];                    list[j] = list[j + 1];                    list[j + 1] = temp;                    swapped = true;                    System.out.println("=> swapped [" + list[j] + ", " + list[j + 1] + "]");                } else {                    System.out.println("=> not swapped");                }            }            // if no number was swapped that means            // array is sorted now, break the loop.            if (!swapped) {                break;            }            System.out.print("Iteration " + (i + 1) + "#: ");            display();        }    }    public static void main(String[] args) {        System.out.print("Input Array: ");        display();        System.out.println();        bubbleSort();        System.out.print("\nOutput Array: ");        display();    }}

Output

Input Array: [1 8 4 6 0 3 5 2 7 9 ]Items compared: [1, 8] => not swappedItems compared: [8, 4] => swapped [4, 8]Items compared: [8, 6] => swapped [6, 8]Items compared: [8, 0] => swapped [0, 8]Items compared: [8, 3] => swapped [3, 8]Items compared: [8, 5] => swapped [5, 8]Items compared: [8, 2] => swapped [2, 8]Items compared: [8, 7] => swapped [7, 8]Items compared: [8, 9] => not swappedIteration 1#: [1 4 6 0 3 5 2 7 8 9 ]Items compared: [1, 4] => not swappedItems compared: [4, 6] => not swappedItems compared: [6, 0] => swapped [0, 6]Items compared: [6, 3] => swapped [3, 6]Items compared: [6, 5] => swapped [5, 6]Items compared: [6, 2] => swapped [2, 6]Items compared: [6, 7] => not swappedItems compared: [7, 8] => not swappedIteration 2#: [1 4 0 3 5 2 6 7 8 9 ]Items compared: [1, 4] => not swappedItems compared: [4, 0] => swapped [0, 4]Items compared: [4, 3] => swapped [3, 4]Items compared: [4, 5] => not swappedItems compared: [5, 2] => swapped [2, 5]Items compared: [5, 6] => not swappedItems compared: [6, 7] => not swappedIteration 3#: [1 0 3 4 2 5 6 7 8 9 ]Items compared: [1, 0] => swapped [0, 1]Items compared: [1, 3] => not swappedItems compared: [3, 4] => not swappedItems compared: [4, 2] => swapped [2, 4]Items compared: [4, 5] => not swappedItems compared: [5, 6] => not swappedIteration 4#: [0 1 3 2 4 5 6 7 8 9 ]Items compared: [0, 1] => not swappedItems compared: [1, 3] => not swappedItems compared: [3, 2] => swapped [2, 3]Items compared: [3, 4] => not swappedItems compared: [4, 5] => not swappedIteration 5#: [0 1 2 3 4 5 6 7 8 9 ]Items compared: [0, 1] => not swappedItems compared: [1, 2] => not swappedItems compared: [2, 3] => not swappedItems compared: [3, 4] => not swappedOutput Array: [0 1 2 3 4 5 6 7 8 9 ]

#Python Code for Tower of HanoiMAX = 10list = [1, 8, 4, 6, 0, 3, 5, 2, 7, 9]def display():    print("[", end="")    # navigate through all items    for i in range(MAX):        print(list[i], end=" ")    print("]")def bubbleSort():    swapped = False    # loop through all numbers    for i in range(MAX - 1):        swapped = False        # loop through numbers falling ahead        for j in range(MAX - 1 - i):            print("Items compared: [",                  list[j],                  ", ",                  list[j + 1],                  "] ",                  end="")            # check if next number is lesser than the current number            # swap the numbers.            # (Bubble up the highest number)            if list[j] > list[j + 1]:                temp = list[j]                list[j] = list[j + 1]                list[j + 1] = temp                swapped = True                print("=> swapped [", list[j], ", ", list[j + 1], "]")            else:                print("=> not swapped")        # if no number was swapped, the array is sorted now, break the loop        if not swapped:            break        print("Iteration", (i + 1), "#: ", end="")        display()print("Input Array: ", end="")display()print()bubbleSort()print("\nOutput Array: ", end="")display()

Output

Input Array: [1 8 4 6 0 3 5 2 7 9 ]Items compared: [ 1 ,  8 ] => not swappedItems compared: [ 8 ,  4 ] => swapped [ 4 ,  8 ]Items compared: [ 8 ,  6 ] => swapped [ 6 ,  8 ]Items compared: [ 8 ,  0 ] => swapped [ 0 ,  8 ]Items compared: [ 8 ,  3 ] => swapped [ 3 ,  8 ]Items compared: [ 8 ,  5 ] => swapped [ 5 ,  8 ]Items compared: [ 8 ,  2 ] => swapped [ 2 ,  8 ]Items compared: [ 8 ,  7 ] => swapped [ 7 ,  8 ]Items compared: [ 8 ,  9 ] => not swappedIteration 1 #: [1 4 6 0 3 5 2 7 8 9 ]Items compared: [ 1 ,  4 ] => not swappedItems compared: [ 4 ,  6 ] => not swappedItems compared: [ 6 ,  0 ] => swapped [ 0 ,  6 ]Items compared: [ 6 ,  3 ] => swapped [ 3 ,  6 ]Items compared: [ 6 ,  5 ] => swapped [ 5 ,  6 ]Items compared: [ 6 ,  2 ] => swapped [ 2 ,  6 ]Items compared: [ 6 ,  7 ] => not swappedItems compared: [ 7 ,  8 ] => not swappedIteration 2 #: [1 4 0 3 5 2 6 7 8 9 ]Items compared: [ 1 ,  4 ] => not swappedItems compared: [ 4 ,  0 ] => swapped [ 0 ,  4 ]Items compared: [ 4 ,  3 ] => swapped [ 3 ,  4 ]Items compared: [ 4 ,  5 ] => not swappedItems compared: [ 5 ,  2 ] => swapped [ 2 ,  5 ]Items compared: [ 5 ,  6 ] => not swappedItems compared: [ 6 ,  7 ] => not swappedIteration 3 #: [1 0 3 4 2 5 6 7 8 9 ]Items compared: [ 1 ,  0 ] => swapped [ 0 ,  1 ]Items compared: [ 1 ,  3 ] => not swappedItems compared: [ 3 ,  4 ] => not swappedItems compared: [ 4 ,  2 ] => swapped [ 2 ,  4 ]Items compared: [ 4 ,  5 ] => not swappedItems compared: [ 5 ,  6 ] => not swappedIteration 4 #: [0 1 3 2 4 5 6 7 8 9 ]Items compared: [ 0 ,  1 ] => not swappedItems compared: [ 1 ,  3 ] => not swappedItems compared: [ 3 ,  2 ] => swapped [ 2 ,  3 ]Items compared: [ 3 ,  4 ] => not swappedItems compared: [ 4 ,  5 ] => not swappedIteration 5 #: [0 1 2 3 4 5 6 7 8 9 ]Items compared: [ 0 ,  1 ] => not swappedItems compared: [ 1 ,  2 ] => not swappedItems compared: [ 2 ,  3 ] => not swappedItems compared: [ 3 ,  4 ] => not swappedOutput Array: [0 1 2 3 4 5 6 7 8 9 ]

#include <stdio.h>int factorial(int n) {   //base case   if(n == 0) {      return 1;   } else {      return n * factorial(n-1);   }}int fibbonacci(int n) {   if(n == 0){      return 0;   } else if(n == 1) {      return 1;   } else {      return (fibbonacci(n-1) + fibbonacci(n-2));   }}int main() {   int n = 5;   int i;   printf("Factorial of %d: %d\n" , n , factorial(n));   printf("Fibbonacci of %d: " , n);   for(i = 0;i<n;i++) {      printf("%d ",fibbonacci(i));               }}

Output

Factorial of 5: 120Fibbonacci of 5: 0 1 1 2 3

// C++ Code for Fibonacci series#include <iostream>int factorial(int n) {   //base case   if(n == 0) {      return 1;   } else {      return n * factorial(n-1);   }}int fibbonacci(int n) {   if(n == 0){      return 0;   } else if(n == 1) {      return 1;   } else {      return (fibbonacci(n-1) + fibbonacci(n-2));   }}int main() {   int n = 5;   int i;   std::cout << "Factorial of " << n << ": " << factorial(n) << std::endl;   std::cout << "Fibbonacci of " << n << ": ";   for(i = 0;i<n;i++) {      std::cout << fibbonacci(i) << " ";               }}

Output

Factorial of 5: 120Fibbonacci of 5: 0 1 1 2 3

// Java Code for Fibonacci seriespublic class Fibonacci {    public static int factorial(int n) {        // base case        if (n == 0) {            return 1;        } else {            return n * factorial(n - 1);        }    }    public static int fibonacci(int n) {        if (n == 0) {            return 0;        } else if (n == 1) {            return 1;        } else {            return fibonacci(n - 1) + fibonacci(n - 2);        }    }    public static void main(String[] args) {        int n = 5;        int i;        System.out.println("Factorial of " + n + ": " + factorial(n));        System.out.print("Fibonacci of " + n + ": ");        for (i = 0; i < n; i++) {            System.out.print(fibonacci(i) + " ");        }    }

Output

Factorial of 5: 120Fibonacci of 5: 0 1 1 2 3

#Python code for fibonacci Seriesdef factorial(n):   # base case   if n == 0:      return 1   else:      return n * factorial(n-1)def fibonacci(n):   if n == 0:      return 0   elif n == 1:      return 1   else:      return fibonacci(n-1) + fibonacci(n-2)if __name__ == "__main__":   n = 5   print("Factorial of", n, ":", factorial(n))   print("Fibonacci of", n, ": ")   for i in range(n):      print(fibonacci(i))

Output

Factorial of 5 : 120Fibonacci of 5 : 01123