(define rl
  (lambda () (load "2-new.ss")))


(define largest
  (lambda (l)
    (largest-top-level-list (flatten l '()))))


(define largest-top-level-list
  (lambda (l)
    (cond [(null? l) #f]
	  [else (largest-helper (car l) (cdr l))])))

(define largest-helper
  (lambda (e l)
    (cond [(null? l) e]
	  [(> (car l) e) (largest-helper (car l) (cdr l))]
	  [else (largest-helper e (cdr l))])))
	   

(define largest
  (lambda (ls)
    (cond [(null? ls) #f]
	  [(pair? (car ls)) (my-max (largest (car ls))
				    (largest (cdr ls)))]
	  [else (my-max (car ls)
			(largest (cdr ls)))])))

(define my-max
  (lambda (x y)
    (cond [(not x) y]
	  [(not y) x]
	  [(> x y) x]
	  [else y])))



;(define flatten
;  (lambda (l)
;    (cond [(null? l) '()]
;	  [(list? (car l)) (append (flatten (car l)) (flatten (cdr l)))]
;	  [else (cons (car l) (flatten (cdr l)))])))


(define flatten
  (lambda (l accu)
    (cond [(null? l) accu]
	  [(atom? (car l)) (cons (car l) (flatten (cdr l) accu))]
	  [else (flatten (car l) (flatten (cdr l) accu))])))



;(define flatten
;  (lambda (l accu)
;    (cond [(null? l) accu]
;         [(null? (car l)) (flatten (cdr l) accu)]
;	  [(atom? (car l)) (cons (car l) (flatten (cdr l) accu))]
;	  [else (flatten (car l) (flatten (cdr l) accu))])))




(define (intersection l1 l2)
  (cond [(null? l1) '()]
	[(null? l2) '()]
	[(member (car l1) l2) (cons (car l1) (intersection (cdr l1) l2))]
	[else (intersection (cdr l1) l2)]))


(define (interval-union list1 list2)
  (if (> (car list1) (car list2))
      (interval-union list2 list1)
      (if (>= (cadr list1) (car list2))
	  (if (> (cadr list1) (cadr list2))
	      (list list1)
	      (list (cons (car list1) (cdr list2))))
	  (list list1 list2))))


(define empty-tree
  (lambda ()
    '()))

(define comparator
  (lambda (x y)
    (if (< x y)
	-1
	(if (> x y)
	    1
	    0))))

(define insert-inc
  (lambda (e t)
    (insert e t comparator)))

(define insert-dec
  (lambda (e t)
    (insert e t (lambda (x y)
		  (- (comparator x y))))))


(define remove-inc
  (lambda (e t)
    (remove2 e t comparator)))

(define remove-dec
  (lambda (e t)
    (remove2 e t (lambda (x y)
		  (- (comparator x y))))))

(define insert
  (lambda (e t comp)
    (cond [(null? t) (list e '() '())]
	  [(= (comp e (car t)) -1) (list (car t) (insert e (cadr t) comp) (caddr t))]
	  [(= (comp e (car t)) +1) (list (car t) (cadr t) (insert e (caddr t) comp))]
	  [else t])))


(define iterator
  (lambda (t)
    (let ([data (flatten t)])
      (lambda ()
	(if (null? data)
	    #f
	    (let ([item (car data)])
	      (set! data (cdr data))
	      item))))))

(define flatten
  (lambda (t)
    (if (null? t)
	'()
	(append (flatten (cadr t)) (list (car t)) (flatten (caddr t))))))




;(define find
;  (lambda (e t)
;    (cond [(null? t) #f]
;	  [(< e (car t)) (find e (cadr t))]
;	  [(> e (car t)) (find e (caddr t))]
;	  [else #t])))

(define remove2
  (lambda (e t comp)
    (cond [(null? t) '()]
	  [(= (comp e (car t)) -1) (list (car t) (remove2 e (cadr t) comp) (caddr t))]
	  [(= (comp e (car t)) 1) (list (car t) (cadr t) (remove2 e (caddr t) comp))]
	  [else (remove-helper e t comp)])))

(define remove-helper
  (lambda (e t comp)
    (if (and (null? (cadr t)) (null? (caddr t)))
	'()
	(if (null? (cadr t))
	    (caddr t)
	    (if (null? (caddr t))
		(cadr t)
		(remove-find-helper e t comp))))))

;;; this is tricky if dec tree
(define remove-find-helper
  (lambda (e t comp)
    (let ([max (find-max (cadr t))])
      (list max (remove2 max (cadr t) comp) (caddr t)))))

(define find-max
  (lambda (t)
    (if (not (null? (caddr t)))
	(find-max (caddr t))
	(car t))))

(define left-most
  (lambda (ls)
    (cond [(atom? ls) ls]
	  [else (left-most (car ls))])))

;;; do not reverse the list
(define right-most
  (lambda (ls)
    (cond [(atom? ls) ls]
	  [(null? (cdr ls)) (right-most (car ls))]
	  [else (right-most (cdr ls))])))

(define count-parens-all
  (lambda (ls)
    (cond [(null? ls) 2]
	  [(pair? (car ls)) (+ (count-parens-all (car ls))
			       (count-parens-all (cdr ls)))]
	  [(null? (car ls)) (+ 2 (count-parens-all (cdr ls)))]
	  [else (count-parens-all (cdr ls))])))
	   




;;; visit each element just once
(define remove-left-most
  (lambda (e ls)
    (cdr (remove-left-most-helper e ls))))

(define remove-left-most-helper
  (lambda (e ls)    
    (cond [(null? ls) '(#f)]
	  [(equal? e (car ls)) (cons #t (cdr ls))]
	  [(pair? (car ls)) (let ([left-side (remove-left-most-helper e (car ls))])
			      (if (car left-side)
				  (cons #t (cons (cdr left-side) (cdr ls)))
				  (let ([right-side (remove-left-most-helper e (cdr ls))])
				    (cons (car right-side) (cons (cdr left-side) (cdr right-side))))))]
	  [else (let ([right-side (remove-left-most-helper e (cdr ls))])
		  (cons (car right-side) (cons (car ls) (cdr right-side))))]))) 



(define remove-right-most
  (lambda (e ls)
    (cdr (remove-right-most-helper e ls))))

(define remove-right-most-helper
  (lambda (e ls)
    (cond [(null? ls) '(#f)]
	  [(pair? (car ls)) (let ([right-side (remove-right-most-helper e (cdr ls))])
			      (if (car right-side)
				  (cons #t (cons (car ls) (cdr right-side)))
				  (if (equal? e (car ls))
				      (cons #t (cdr right-side))
				      (let ([left-side (remove-right-most-helper e (car ls))])
					(cons (car left-side) (cons (cdr left-side) (cdr ls)))))))]
	  [else (let ([right-side (remove-right-most-helper e (cdr ls))])
		  (if (and (eq? e (car ls))
			   (not (car right-side)))
		      (cons #t (cdr right-side))
		      (cons (car right-side) (cons (car ls) (cdr right-side)))))])))


;;; reverse-all p.107 (requires accu)
(define reverse
  (lambda (ls)
    (reverse-helper ls '())))

(define reverse-helper
  (lambda (ls accu)    
    (cond [(null? ls) accu]
	  [(pair? (car ls)) (reverse-helper (cdr ls) (cons (reverse-helper (car ls) '()) accu))]
	  [else (reverse-helper (cdr ls) (cons (car ls) accu))])))

;;; flatten p.111
;(define flatten
;  (lambda (ls)
;    (cond [(null? ls) '()]
;	  [(pair? (car ls)) (append (flatten (car ls))
;				    (flatten (cdr ls)))]
;	  [else (cons (car ls) (flatten (cdr ls)))])))