Wyszukiwanie w drzewie binarnym

Dzień dobry, próbuję zrobić znajdowanie węzła w drzewie BST i podczas zwracania otrzymuje adres zamiast danej wartości. Ktoś wie co powinienem zmienić?

#include <iostream>
#include <bits/stdc++.h>
using namespace std;

struct node{
    int data;
    node*left;
    node*right;
};
void printtree(node * root){//funkcja rekurencyjna  preorder (data,left,right)
    if (root == nullptr) return;// warunek sprawdza czy drzewo jest puste

    cout<< root->data<<endl;// wyswietla date
    printtree(root->left);
    printtree(root->right);
}
void inorder(node * root){//funkcja rekurencyjna  preorder (left,data,right)
    if (root == nullptr) return;// warunek sprawdza czy drzewo jest puste

    printtree(root->left);
    cout<< root->data<<endl;// wyswietla date
    printtree(root->right);
}
void postorder(node * root){//funkcja rekurencyjna  postorder(left,right,data)
    if (root == nullptr) return;// warunek sprawdza czy drzewo jest puste

    printtree(root->left);
    printtree(root->right);
    cout<< root->data<<endl;// wyswietla date
}
node*createnode(int data){
    node*newNode =  new node();
    newNode->data =data;
    newNode->left = newNode->right= nullptr;
    return newNode;
}
node * search (node * root, int k )
{
    while( root && root->data != k )
        root = ( k < root->data ) ? root->left: root->right;

    return root;
}
void deletetree(struct node* node)
{
    if (node == NULL) return;

    /* first delete both subtrees */
    deletetree(node->left);
    deletetree(node->right);

    /* then delete the node */
    printf("\n Usuwanie %d", node->data);
    free(node);
}

int Max(struct node*root) {

//przejście do ostatniego elementu po prawej
    while (root->right != NULL) {
        root = root->right;
    }
    return root->data;
}
int Min(struct node*root) {

//przejście do ostatniego elementu po lewej
    while (root->left != NULL) {
        root = root->left;
    }
    return root->data;
}

int main() {

    //lvl1
    node* root= createnode(9);
    //lvl2
    root->left= createnode(5);
    root->right= createnode(13);
    //lvl3
    root->left->left= createnode(4);
    root->left->right= createnode(7);
    root->right->left= createnode(10);
    root->right->right= createnode(15);
    //lvl4
    root->left->right->right= createnode(8);
    root->left->right->left= createnode(6);
    root->right->right->right= createnode(18);
    root->left->left->left= createnode(2);
    root->right->right->left= createnode(14);
    root->right->left->right= createnode(12);

    cout<<("preorder")<<endl;
    printtree(root);
    cout<<("\npostorder")<<endl;
    postorder(root);
    cout<<("\ninorder")<<endl;
    inorder(root);

    cout<<("\n Maximum to: ")<<Max(root)<<endl;
    cout<<("\n Minimum to: ")<<Min(root)<<endl;

    cout<<("\nszukana wartosc to:")<<search(root,2)<<endl;
        

    deletetree(root);
    root = NULL;

    printf("\n Drzewo zostalo usuniete ");

    printtree(root);
    cin.get();
    return 0;
}

aragorn280 napisał(a):

Ktoś wie co powinienem zmienić ?

Wszystko.

Dlaczego to C ze strumieniami? Dlaczego nie masz - zmiłuj się - choćby konstruktora i destruktora ?
Dlaczego masz new i free()

aragorn280 napisał(a):

Ktoś wie co powinienem zmienić ?

Wywalić całość i napisać w C++, taki wstępny fragment:

#include <iostream>
using namespace std;

class tree
{
    private:
    struct node
    {
        int data;
        node *left,*right;
        static void clean(node *n) { if(n) delete n; }
        template<typename... nodes> static void clean(node *n,nodes... lst) { clean(n),clean(lst...); }
        node(int data):data(data),left(nullptr),right(nullptr) {}
        ~node() { clean(left,right); }
        static node *&search(node *&n,int data)
        {
        	if(!n) return n;
        	if(data<n->data) return search(n->left,data);
            if(data>n->data) return search(n->right,data);
            return n;
		}
        void inorder(ostream &s)
        {
            if(left) left->inorder(s);
            s<<data<<' ';
            if(right) right->inorder(s);
        }
    };
    node *root;
    public:
    void clean() { node::clean(root); root=nullptr; }
    tree():root(nullptr) {}
    ~tree() { node::clean(root); }
    void inorder(ostream &s=cout) { if(root) root->inorder(s); }
    bool contain(int data) { return node::search(root,data); }
    template<typename... values> void add(int data,values... lst) { add(data),add(lst...); }
    bool add(int data)
	{
		node *&found=node::search(root,data);
		if(found) return false;
		found=new node(data);
		return true;
	}
};

int main()
{
    tree T;
    T.add(4,2,6,1,3,5,7);
    T.inorder();
    return 0;
}