#lang racket

;; spoko funkcje


(define (reverse-rek xs)
  (if (pair? xs)
      (append (reverse-rek (cdr xs)) (cons (car xs) null))
      xs))

(define (fold-right op nval xs) ;; spoko funkcja
  (if (null? xs)
      nval
      (op (car xs)
          (fold-right op nval (cdr xs)))))


(define (insert xs n)
  (if (> n (car xs))
      (cons (car xs) (insert (cdr xs) n))
      (cons n xs)))


(define (append-s . xs)
  (fold-right append null xs))

(define (permi xs)
  (if (null? xs)
      null
      (append-s (map (lambda (zs) (insert (car zs) zs)) (permi (cdr xs))))))



(define (mirror tree) ;3
  (if (leaf? tree)
      tree
      (make-node (node-val tree )
                 (mirror (node-right tree))
                 (mirror (node-left tree)))))

(define (flatten tree) ;4
  (if (leaf? tree)
      null
      (append (flatten (node-left tree))
            (cons (node-val tree)
                  (flatten (node-right tree))))))

(define (treesort xs) ;5
  (define (treesorcik xs tree)
    (if (null? xs)
        tree
       (treesorcik (cdr xs) (bst-insert (car xs) tree))))
  (flatten (treesorcik xs 'leaf)))

(define (append xs ys)
  (if (null? xs)
      ys
      (cons (car xs) (append (cdr xs) ys))))

(define (map f xs)
  (if (null? xs)
      null
      (cons (f (car xs))
            (map f (cdr xs)))))

(define (flatten2 t)
  (define (flat t acc)
    (if (leaf? t)
        acc
        (flat (node-left t) (cons (node-value t) (flat (node-right t) acc)))))
  (flat t null))