;; open Assert

type tree = 
	| Empty 
	| Node of tree * int * tree

let t : tree = 
	Node (Node (Empty, 1, Empty), 
		    3,
	      Node (Empty, 2, Node (Empty, 4, Empty))) 
											
let rec size ( t : tree ) : int = 
		begin match t with
			| Empty -> 0
			| Node ( l , v , r ) -> 1 + size l + size r 
		end			
		
let test () : bool = size t = 4
;; run_test "size t" test

let rec height ( t : tree) : int = 
	begin match t with 
		| Empty -> 0
		| Node ( l , v , r ) -> 1 + max (height l) (height r)
	end 		

let test () : bool = height t = 3
;; run_test "height t" test

let rec inorder (t : tree) : int list = 
	begin match t with
		| Empty -> []
	  | Node (l , v , r ) -> inorder l @ [v] @ inorder r 
	end 
			
let test () : bool = inorder t = [1;3;2;4]
;; run_test "inorder t" test

let rec preorder (t : tree) : int list = 
	begin match t with
		| Empty -> []
		| Node (l, v, r) -> [ v ] @ preorder l @ preorder r
	end		
let test () : bool = preorder t = [3;1;2;4]
;; run_test "preorder t" test

let rec postorder (t : tree) : int list = 
	begin match t with 
		| Empty -> []
		| Node (l,v,r) -> postorder l @  postorder r @ [v]
	end 
			
let test () : bool = postorder t = [1;4;2;3]
;; run_test "postorder t" test

let rec contains (n :int) (t : tree) : bool = 
	begin match t with
		| Empty -> false
		| Node (l,v,r) -> v = n || contains n l || contains n r 
  end
	
let test () : bool = contains 5 t = false
;; run_test "contains t" test