# Hackerrank Binary Search Tree : Insertion problem solution

In this tutorial, we are going to solve or make a solution to the Binary Search Tree: Insertion problem. so here we have given a pointer to the head or root node and the values to be inserted into the tree. and we need to insert the values into the appropriate position in the binary search tree and then return the root of the updated binary tree.

## Problem solution in Python programming.

```class Node:
def __init__(self, info):
self.info = info
self.left = None
self.right = None
self.level = None

def __str__(self):
return str(self.info)

def preOrder(root):
if root == None:
return
print (root.info, end=" ")
preOrder(root.left)
preOrder(root.right)

class BinarySearchTree:
def __init__(self):
self.root = None

#Node is defined as
#self.left (the left child of the node)
#self.right (the right child of the node)
#self.info (the value of the node)

def insert(self, val):
if self.root is None:
self.root=Node(val)
else:
current = self.root
while True:
if val < current.info:
if current.left is None:
current.left=Node(val)
break
else:
current=current.left
else:
if current.right is None:
current.right=Node(val)
break
else:
current=current.right

tree = BinarySearchTree()
t = int(input())

arr = list(map(int, input().split()))

for i in range(t):
tree.insert(arr[i])

preOrder(tree.root)```

## Problem solution in Java Programming.

```import java.util.*;
import java.io.*;

class Node {
Node left;
Node right;
int data;

Node(int data) {
this.data = data;
left = null;
right = null;
}
}

class Solution {

public static void preOrder( Node root ) {

if( root == null)
return;

System.out.print(root.data + " ");
preOrder(root.left);
preOrder(root.right);

}

/* Node is defined as :
class Node
int data;
Node left;
Node right;

*/

public static Node insert(Node root,int value)
{
if(root == null) {
root = new Node(value);
} else if(value < root.data){
root.left = insert(root.left,value);
} else if(value > root.data) {
root.right = insert(root.right,value);
}

return root;

}

public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int t = scan.nextInt();
Node root = null;
while(t-- > 0) {
int data = scan.nextInt();
root = insert(root, data);
}
scan.close();
preOrder(root);
}
}```

### Problem solution in C++ programming.

```#include <bits/stdc++.h>

using namespace std;

class Node {
public:
int data;
Node *left;
Node *right;
Node(int d) {
data = d;
left = NULL;
right = NULL;
}
};

class Solution {
public:

void preOrder(Node *root) {

if( root == NULL )
return;

std::cout << root->data << " ";

preOrder(root->left);
preOrder(root->right);
}

/*
Node is defined as

class Node {
public:
int data;
Node *left;
Node *right;
Node(int d) {
data = d;
left = NULL;
right = NULL;
}
};

*/

Node * insert(Node * root, int value) {

if(root==NULL) {
Node* newNode;
newNode = (Node*)malloc(sizeof(Node));
newNode->left = NULL;
newNode->right = NULL;
newNode->data = value;
return newNode;
}

if(value <= root->data)
root->left = insert(root->left, value);
else
root->right = insert(root->right, value);

return root;
}

};

int main() {

Solution myTree;
Node* root = NULL;

int t;
int data;

std::cin >> t;

while(t-- > 0) {
std::cin >> data;
root = myTree.insert(root, data);
}

myTree.preOrder(root);

return 0;
}```

### Problem solution in C programming.

```#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

struct node {

int data;
struct node *left;
struct node *right;

};

void preOrder( struct node *root) {

if( root == NULL )
return;
printf("%d ",root->data);
preOrder(root->left);
preOrder(root->right);

}

/* you only have to complete the function given below.
node is defined as

struct node {

int data;
struct node *left;
struct node *right;

};

*/

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

if(root == NULL){
root = malloc(sizeof(struct node));
root->data = data;
root->left = NULL;
root->right = NULL;

}else if(data < root->data){
root->left = insert(root->left, data);
}else{
root->right = insert(root->right, data);
}
return root;

}

int main() {

struct node* root = NULL;

int t;
int data;

scanf("%d", &t);

while(t-- > 0) {
scanf("%d", &data);
root = insert(root, data);
}

preOrder(root);
return 0;
}
```