#lang racket

(define (node v l r)
  (list 'node v l r))

(define (node? t)
  (and
   (list? t)
   (= (length t) 4)
   (eq? 'node (car t))))

(define (node-val t)
  (second t))

(define (node-left t)
  (third t))
(define (node-right t)
  (fourth t))
(define (leaf v)
  (list 'leaf v))

(define (leaf? t)
  (and
   (list? t)
   (= (length t) 2)
   (eq? (car t) 'leaf)))

(define (leaf-val t)
  (second t))

(define (tree? t)
  (or
   (leaf? t)
   (and
    (node? t)
    (tree? (node-right t))
    (tree? (node-left t)))))

(define (tree-min t)
  (cond [(leaf? t) (leaf-val t)]
        [else (let ((mini-left (tree-min (node-left t)))
                    (mini-right (tree-min (node-right t)))
                    (mini-node (node-val t)))
                (cond [(and (<= mini-right mini-node)
                            (<= mini-right mini-left)) mini-right]
                      [(and (<= mini-left mini-node)
                            (<= mini-left mini-right)) mini-left]
                      [else mini-node]))]))

(define drzefko (node 4
                      (node 3 (node 6 (node 1 (leaf 14) (leaf 3)) (node 100 (leaf 5) (leaf 13))) (leaf 1))
                      (leaf 4)))