;;; testcases for complete?

;;; #t
(define t1 '())

;;; #t
(define t2 '(7 () ()))

;;; #t
(define t3 '(7 (3 () ()) (9 () ())))

;;; #f
(define t4 '(7 (3 (1 () ()) ()) (9 () ())))

;;; #f
(define t5 '(7 (3 (1 () ()) ()) (9 () (10 () ()))))

;;; #f
(define t6 '(7 (3 (1 () ()) (5 () ())) (9 (8 () ()) ())))

;;; #t
(define t7 '(7 (3 (1 () ()) (5 () ())) (9 (8 () ()) (10 () ()))))



;;; Testcases for occurs-free?

;;; All test cases ask whether x occurs free in the expression
;;; #f
(define c1 '(cond [y y]))

;;; #t
(define c2 '(cond [x x]))

;;; #t
(define c3 '(cond [y y][else x]))

;;; #t
(define c4 '(cond [(lambda (x) x) x][else y]))

;;; #f
(define c5 '(cond [(lambda (x) x) y][else y]))

;;; #f
(define c6 '(cond [y y][else (lambda (x) x)]))

;;; #t
(define c7 '(cond [y y][else (lambda (y) x)]))



(define a '(a s w d e))

(define get
  (lambda (i a)
    (if (> i 0)
	(get (- i 1) (cdr a))
	(car a))))

(define set
  (lambda (i a e)
    (if (> i 0)
	(cons (car a) (set (- i 1) (cdr a) e))
	(cons e (cdr a)))))

(define get2d
  (lambda (i j a)
    (get j (get i a))))

(define b '(a s (3 4 5) d g))




(define occurs-free?
  (lambda (var exp)
    (cond [(symbol? exp) (eqv? var exp)]
	  [(eqv? (car exp) 'lambda)
	   (and (not (eqv? (caadr exp) var))
		(occurs-free? var (caddr exp)))]
	  [(eqv? (car exp) 'cond)
	   (cond-checker var (cdr exp))]
	  [else (or (occurs-free? var (car exp))
		    (occurs-free? var (cadr exp)))])))

(define cond-checker
  (lambda (var cases)
    (if (null? cases)
	#f
	(or (if (null? (caar cases))
		#f
		(occurs-free? var (caar cases)))
	    (if (null? (cadar cases))
		#f
		(occurs-free? var (cadar cases)))
	    (cond-checker var (cdr cases))))))



(define complete?
  (lambda (bintree)
    (if (eq? (complete-helper? bintree) -1)
	#f
	#t)))

(define complete-helper?
  (lambda (bintree)    
    (if (null? bintree)
	0
	(let ([hleft (complete-helper? (cadr bintree))]
	      [hright (complete-helper? (caddr bintree))])
	  (if (and (= hleft hright)
		   (not (= hleft -1))
		   (not (= hright -1)))
	      (+ 1 hleft)
	      -1)))))