KamilCompleteBinaryTree

#ifndef DRZEWO
#define DRZEWO

#include<iostream>
#include<string>
#include<cstdlib>
#include<sstream>
#include<fstream>

class element;

class tree {
private:
    element* root;
    unsigned int size;
public:
    tree() : root(nullptr), size(0) {};

    int push(int val);
    int get_size() { return size; }
    void set_size(int VAL) { size = VAL; }
    void go_through();
};

class element {
private:
    int local_size;
    int val;
    element* parent;
    element* left;
    element* right;

public:
    element* get_left() { return left; }
    element* get_right() { return right; }
    element* get_parent() { return parent; }
    int get_val() { return val; }
    int get_local_size() { return local_size; }

    void set_val(int VAL) { val = VAL; }
    void set_left(element* tmp) { left = tmp; }
    void set_right(element* tmp) { right = tmp; }
    void set_parent(element* tmp) { parent = tmp; }
    void show_val() { std::cout << val; }
    void set_local_size(int VAL) { local_size = VAL; }

    element() : val(-1), left(nullptr), right(nullptr), parent(nullptr), local_size(1){};
    element(int VAL, element* LEFT, element* RIGHT,element* PARENT) : val(val), right(RIGHT), left(LEFT), parent(PARENT) {};
};

int pusher(int val, unsigned int size, element* root) {
    element* tmp = new element;
    element* par = root;
    tmp->set_val(val);
    /*if (get_size() == 0) {
        root = tmp;                 dodanie pierwszego w funkcji klasy;
    }*/

    //jesli lewy pusty
    if (root->get_left() == nullptr) {
        root->set_left(tmp);
        root->get_left()->set_parent(root);
        //zwiekszenie wartosci wielkosci drzewa pod elementem ze samym soba
        //root->set_local_size(root->get_local_size() + 1);
        //return 0;
    }
    else
    //jesli prawy pusty
    if (root->get_right() == nullptr) {
        root->set_right(tmp);
        root->get_right()->set_parent(root);
        //zwiekszenie wartosci wielkosci drzewa pod elementem ze samym soba
//      root->set_local_size(root->get_local_size() + 1);
    //  return 0;
    }
    else {
        //idziemy w lewo
        if (root->get_local_size() % 2 == 1) {
            par = par->get_left();
            pusher(val, root->get_local_size(), par);
            //zwiekszenie wartosci wielkosci drzewa pod elementemze samym soba
    //      root->set_local_size(root->get_local_size() + 1);
//          return 0;
        }
        //idziemy w prawo
        if (root->get_local_size() % 2 == 0) {
            par = par->get_right();
            pusher(val, root->get_local_size(), par);
            //zwiekszenie wartosci wielkosci drzewa pod elementem ze samym soba
        //  root->set_local_size(root->get_local_size() + 1);
//          return 0;
        }
    }
    root->set_local_size(root->get_local_size() + 1);

    return -1;
}


int tree::push(int val) {
    element* tmp = new element;
    if (get_size() == 0) {
        root = tmp;
        root->set_val(val);
        set_size(get_size() + 1);
        return 0;
    }
    pusher(val, get_size(), root);
    set_size(get_size() + 1);
    return 0;
}


tree* read_to_class(std::string nazwa_pliku, int ilosc) {
    tree* ret_list = new tree;
    element* tmp = new element;

    std::string str;
    int intek;

    std::ifstream plik;
    plik.open(nazwa_pliku, std::ios::in);
    if (plik.good()) {
        while (!plik.eof()) {
            //for(int i = 0; i<ilosc;++i ){

            std::getline(plik, str, ' ');
            intek = atoi(str.c_str());
            tmp->set_val(intek);
            ret_list->push(intek);
        }
    }
    return ret_list;
}

/*void tree::go_through() {
    element tmp = *root;
    this->root->show_val();
    while (tmp == root) {
        while (tmp.get_left() != nullptr) {
            tmp.show_val();
            tmp = tmp.get_left();
        }
        tmp = tmp.get_parent();

    }
}*/



void show_all(element* root) {
    element* left = root->get_left();
    element* right = root->get_right();
    if (left != nullptr) {
        std::cout << left->get_val() << " "; //<< std::endl;
    }
    if (right != nullptr) {
        std::cout << right->get_val() << " "; //<< std::endl;
    }
    if (left->get_left() != nullptr || left->get_right() != nullptr) {
        show_all(left);
    }
    if (right->get_left() != nullptr || right->get_right() != nullptr) {
        show_all(right);
    }
}

void preorder(element* root) {

    element* left = root->get_left();
    element* right = root->get_right();
    std::cout << root->get_val() << " ";

    if (left != nullptr) {
        std::cout << left->get_val() << " "; //<< std::endl;
        if (left->get_left() != nullptr) {

            preorder(left->get_left());
        }
        if(left->get_right() != nullptr){
            //std::cout << std::endl;
            preorder(left->get_right());
        }
    }

    if (right != nullptr) {
        std::cout << right->get_val() << " "; //<< std::endl;
        if (right->get_left() != nullptr) {
            preorder(right->get_left());
        }
        if (right->get_right() != nullptr) {
            //std::cout << std::endl;
            preorder(right->get_right());
        }
    }



}

void tree::go_through() {
    // std::cout << this->root->get_val() << " ";
    //show_all(this->root);
    preorder(this->root);
}

#endif // !DRZEWO