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) 

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

def create(self, val):  
    if self.root == None:
        self.root = Node(val)
    else:
        current = self.root

        while True:
            if val < current.info:
                if current.left:
                    current = current.left
                else:
                    current.left = Node(val)
                    break
            elif val > current.info:
                if current.right:
                    current = current.right
                else:
                    current.right = Node(val)
                    break
            else:
                break

""" 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 preOrder(root): if(root==None): return 0 print(root.info, end=" ") preOrder(root.left) preOrder(root.right)

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

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

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

preOrder(tree.root)

JavaScript solution using recursion

function preOrder(root) {
    let res = '';
    function abc(root){
      if(root){
        res = res + root.data + '  ';
        abc(root.left);
        abc(root.right)  
       }
    }
    abc(root);
    console.log(res)
}

Haskell

It would have been nice if the problem statement gave an actual sample of the expected input data and how to parse it... Bad form, folks.

module Main where

data Tree = Empty | Node Int Tree Tree

instance Show Tree where
    show Empty = ""
    show (Node x l r) =
        show x ++ " " ++ show l ++ show r

insert :: Tree -> Int -> Tree
insert Empty x = Node x Empty Empty
insert (Node k left right) x
    | x < k = Node k (insert left x) right
    | otherwise = Node k left (insert right x)

parseTree :: [Int] -> Tree
parseTree = foldl insert Empty

main :: IO ()
main = do
    _ <- getLine
    seq <- map read . words <$> getLine :: IO [Int]
    print $ parseTree seq

class Node: def init(self,val): self.value=val self.left=None self.right=None

class Tree: def init(self): self.root=None

def insert(self,root,val):
    if root is None:
        return Node(val)
    elif root.value>val:
        root.left=self.insert(root.left,val)
    else:
        root.right=self.insert(root.right,val)

    return root

def preOrder(self,root):
    if root is None:
        return 
    print(root.value,end=' ')
    self.preOrder(root.left)
    self.preOrder(root.right)

n=int(input()) nums=list(map(int,input().split())) tree=Tree() tree.root=Node(nums[0]) for num in nums[1:]: tree.insert(tree.root,num) tree.preOrder(tree.root)

There is a gotcha here, that the C# template doesn't parse the input like the languages. And the description doesn't describe how to parse the input.