tree

#include <iostream>
#include <ctime>
#include <memory>
#include <vector>

using namespace std;

struct BSTnode {                     //liść

    int wartosc;                    //wartość
    unique_ptr<BSTnode> lewo;       //odnośnik w lewo
    unique_ptr<BSTnode> prawo;      //odnośnik w prawo

    BSTnode(int a) {

        this->wartosc = a;
        this->lewo = nullptr;
        this->prawo = nullptr;

    }
};

// wypisywanie drzewa na ekran
ostream& operator << (ostream& stream, BSTnode* bst) {
    if (bst) {
        stream << bst->lewo.get() << bst->wartosc << bst->prawo.get();
    }
    else return stream << " ";
}

// in-order
void inorder(BSTnode *bst) {
    cout << "in-orer: " << bst->lewo.get() << bst->wartosc << bst->prawo.get() << endl;
}

// pre-order
void preorder(BSTnode *bst) {
    cout << "pre-order: " << bst->wartosc << bst->lewo.get() << bst->prawo.get() << endl;
}

//past-order
void postorder(BSTnode *bst) {
    cout << "post-order: " << bst->lewo.get() << bst->prawo.get() << bst->wartosc << endl;
}

// dodawanie elementu do drzewa
void addtotree(unique_ptr<BSTnode>& root, int a) {

    if (root) {
        if (root->wartosc > a && root->wartosc != a) addtotree(root->lewo, a);
        if (root->wartosc < a && root->wartosc != a) addtotree(root->prawo, a);
    }
    else root = make_unique<BSTnode>(a);
}

// szukanie minimalnej wartosci w drzewie
int min(BSTnode* b) {

    if (b) {
        if (b->lewo) {
            return min(b->lewo.get());
        }
        else return b->wartosc;
    }
}

// szuaknie elementu w drzewie
bool szukajka(BSTnode* b, const int& c) {

    if (b)
    {
        if (b->wartosc == c) return 1;
        else if (b->wartosc < c) szukajka(b->prawo.get(), c);
        else if (b->wartosc > c) szukajka(b->lewo.get(), c);
    }
    else return 0;
}

// zapisywanie drzewa do wektora
void saveToVector(unique_ptr<BSTnode>& tree, vector<int>& vector)
{
    if (tree)
    {
        vector.push_back(tree->wartosc);
        saveToVector(tree->lewo, vector);
        saveToVector(tree->prawo, vector);
    }
}

// usuwanie wybranego elementu z drzewa
void remove(unique_ptr<BSTnode>& tree, const int& value)
{
    vector<int> tmp;
    saveToVector(tree, tmp);
    tree = nullptr;
    for (int i = 0; i < tmp.size(); i++)
    {
        if (tmp[i] != value) addtotree(tree, tmp[i]);
    }
}

int main() {

    srand(time(NULL));

    // tworzenie drzewa o korzeniu 5
    unique_ptr<BSTnode> b = make_unique<BSTnode>(5);

    //dodawanie losowych 10 elementow
    for (int i = 0; i < 10; i++) {
        addtotree(b, rand() % 10 + 1);
    }

    // wyświetlanie drzewa w roznych opcjach przejsc
    inorder(b.get());
    preorder(b.get());
    postorder(b.get());

    //szukanie minimalnej wartosci podanej przez urzytkownika
    cout << "wartosc minimalna: " << min(b.get()) << endl;
    int x;
    cout << "wprowadz liczbe szukana: ";
    cin >> x;
    cin.clear();
    cin.ignore(1000, '\n');
    // sprawdzenie czy element podany przez uzytkownika istnieje
    cout << "czy element " << x << " istnieje? " << szukajka(b.get(), x) << endl;


    //usuwanie z drzewa elementu podanego przez uzytkownika
    int y;
    cout << "podaj cyfre ktora chesz ususnac z drzewa: ";
    cin >> y;
    cin.clear();
    cin.ignore(1000, '\n');
    remove(b, y);
    cout << endl << b.get();

    cin.get();
    return 0;
}