(define (rl) (load "bst.ss"))

(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 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 remove
  (lambda (e t)
    (cond [(null? t) '()]
	  [(< e (car t)) (list (car t) (remove e (cadr t)) (caddr t))]
	  [(> e (car t)) (list (car t) (cadr t) (remove e (caddr t)))]
	  [else "doyuormagic"])))
	  




;;; Assume a list that does not contain any other lists.

;;; opposite of car
;;; no reverse
(define last
  (lambda (l)
    (if (null? (cdr l))
	(car l)
	(last (cdr l)))))

(define all-but-last
  (lambda (l)
    (if (null? (cdr l))
	'()
	(cons (car l) (all-but-last (cdr l))))))

(define replace
  (lambda (old new l)
    (cond [(null? l) '()]
	  [(eq? old (car l)) (cons new (replace old new (cdr l)))]
	  [else (cons (car l) (replace old new (cdr l)))])))

(define remove-first
  (lambda (e l)
    (cond [(null? l) '()]
	  [(eq? e (car l)) (cdr l)]
	  [else (cons (car l) (remove-first e (cdr l)))])))

;;; no reversing of the list
(define remove-last
  (lambda (e ls)
    (remove-last-helper e ls '(()))))

;OK
;(define remove-last-helper  
;  (lambda (e ls removed? first middle)
;    (cond [(null? ls) (append first middle)]
;	  [(eq? e (car ls)) (if removed?
;				(remove-last-helper e (cdr ls) #t (append first (list e) middle) '())
;				(remove-last-helper e (cdr ls) #t (append first middle) '()))]
;	  [else (remove-last-helper e (cdr ls) removed? first (append middle (list (car ls))))])))

;Good
;(define remove-last-helper  
;  (lambda (e ls store)
;    (cond [(null? ls) (car store)]
;	  [(eq? e (car ls)) (remove-last-helper e (cdr ls) (cons (cdr store) (append (cdr store) (list (car ls)))))]
;	  [else (remove-last-helper e (cdr ls) (cons (append (car store) (list (car ls)))


;better
(define remove-last
  (lambda (e ls)
    (if (null? ls)
	'()
	(cdr (remove-last-helper e ls)))))

(define remove-last-helper
  (lambda (e ls)
    (if (null? ls)
	'(#f)
	(let ([temp (remove-last-helper e (cdr ls))])
	  (if (eq? (car ls) e)
	      (if (car temp)
		  (cons #t (cons (car ls) (cdr temp)))
		  (cons #t (cdr temp)))
	      (cons (car temp) (cons (car ls) (cdr temp))))))))