/**
     * Grąžinamas aibės poaibis iki elemento.
     *
     * @param element - Aibės elementas.
     * @return Grąžinamas aibės poaibis iki elemento.
     */
    @Override
    public SetADT<E> headSet(E element) {
        if (element == null) {
            throw new IllegalArgumentException("Element is null in headSet(E element)");
        }

        BstSetKTU<E> headSet = new BstSetKTU<>();

        if (contains(element)) {
            headSetRecursive(headSet, root, element);
        }

        return headSet;
    }

    /**
     * Grąžinamas aibės poaibis nuo elemento element1 iki element2.
     *
     * @param element1 - pradinis aibės poaibio elementas.
     * @param element2 - galinis aibės poaibio elementas.
     * @return Grąžinamas aibės poaibis nuo elemento element1 iki element2.
     */
    @Override
    public SetADT<E> subSet(E element1, E element2) {
        if (element1 == null || element2 == null) {
            throw new IllegalArgumentException("Element is null in headSet(E element)");
        }

        BstSetKTU<E> subSet = new BstSetKTU<>();

        if (contains(element1) && contains(element2)) {
            BstNode<E> n = getNode(element2);
            subSetRecursive(subSet, n, element1);
        }

        return subSet;
    }

    /**
     * Grąžinamas aibės poaibis nuo elemento.
     *
     * @param element - Aibės elementas.
     * @return Grąžinamas aibės poaibis nuo elemento.
     */
    @Override
    public SetADT<E> tailSet(E element) {
        if (element == null) {
            throw new IllegalArgumentException("Element is null in headSet(E element)");
        }

        BstSetKTU<E> tailSet = new BstSetKTU<>();

        if (contains(element)) {
            tailSet = (BstSetKTU<E>) subSetRecursive(tailSet, root, element);
        }

        return tailSet;
    }

    private SetADT<E> headSetRecursive(SetADT<E> headSet, BstNode<E> n, E element) {
        if (n != null) {
            int cmp = (c == null) ? n.element.compareTo(element) : c.compare(n.element, element);

            if (cmp <= 0) {
                headSet.add(n.element);
            }

            headSet = headSetRecursive(headSet, n.left, element);
            headSet = headSetRecursive(headSet, n.right, element);
        }
        return headSet;
    }

    private SetADT<E> subSetRecursive(SetADT<E> subSet, BstNode<E> n, E element) {
        if (n != null) {
            int cmp = (c == null) ? n.element.compareTo(element) : c.compare(n.element, element);

            if (cmp >= 0) {
                subSet.add(n.element);
            }

            subSet = subSetRecursive(subSet, n.left, element);
            subSet = subSetRecursive(subSet, n.right, element);
        }
        return subSet;
    }

    private BstNode<E> getNode(E element) {
        if (element == null) {
            throw new IllegalArgumentException("Element is null in get(E element)");
        }

        BstNode<E> node = root;
        while (node != null) {
            int cmp = c.compare(element, node.element);

            if (cmp < 0) {
                node = node.left;
            } else if (cmp > 0) {
                node = node.right;
            } else {
                return node;
            }
        }

        return null;
    }