#lang racket

(define-struct node (value left right))

(define (search node value) (cond
                              [(= (node-value node) value) #t]
                              [(empty? node) #f]
                              [(> (node-value node) value) (search (node-left node) value)]
                              [else (search (node-right node) value)]
                              ))

(define (insert node value) (cond
                              [(empty? node) (make-node value empty empty)]
                              [(> (node-value node) value) (make-node (node-value node) (insert (node-left node) value) (node-right node))]
                              [else (make-node (node-value node) (node-left node) (insert (node-right node) value))]
                              ))

(define (bst-from-list lst) (cond
                              [(empty? lst) empty]
                              [else (insert (bst-from-list (rest lst)) (first lst))]
                              ))

(define (rotate-left node) (if (empty? node) empty (let
                               (
                               [x node]
                               [l (node-left node)]
                               [r (node-right node)])
                             (let (
                               [a (if (empty? l) empty (node-left l))]
                               [b (if (empty? l) empty (node-right l))]
                               [c (if (empty? r) empty (node-left r))]
                               [d (if (empty? r) empty (node-right r))]
                             ) (
                               (make-node (node-value l)
                                          a
                                          (make-node (node-value x)
                                                     b
                                                     r)
                                          )
                             )))))

(define (height node) (cond
                        [(empty? node) 0]
                        [else (+ 1 (max (height (node-left node)) (height (node-right node))))]
                        ))

(define (avlcheck node) (cond
                        [(empty? node) 0]
                        [(= (height (node-left node)) -1) -1]
                        [(= (height (node-right node)) -1) -1]
                        [(< 1 (abs (- (height (node-left node)) (height (node-right node))))) -1]
                        [else (+ 1 (max (height (node-left node)) (height (node-right node))))]
                        ))