"Рекурсивная функция" (Обход бинарного дерева)

void print_tree(Node *p, int level){
    if(p){
        print_tree(p->left, level + 1);     // вывод левого поддерева
        for(int i = 0; i < level; i++) cout << "   ";
        cout << p->d << endl;               // вывод корня поддерева
        print_tree(p->right, level + 1);    // вывод левого поддерева
    }
}

struct Node{
    int d;
    Node *left;
    Node *right;
};

#include <iostream>
#include <windows.h>
#include <conio.h>
 
using namespace std;
 
struct Node{
    int d;
    Node *left;
    Node *right;
};
Node *first(int d);
Node *search_insert(Node *root, int d);
void print_tree(Node *root, int l);
//----------------------------------
int main(){
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
 
    int b[] = {10, 25, 20, 6, 21, 8, 1, 30};
    Node *root = first(b[0]);
    for(int i = 1; i < 8; i++) search_insert(root, b[i]);
    cout << "+" << root->d << "\n\n"; 
    print_tree(root, 0);
    _getch();
    return 0;
}
//----------------------------------
Node *first(int d){
    Node *pv = new Node; 
    pv->d = d;
    pv->left = 0;
    pv->right = 0;
    return pv;
}
//-----------------------------------
Node *search_insert(Node *root, int d){
    Node *pv = root, *prev;
    bool found = false;
    while(pv && !found){
        prev = pv;
        if( d == pv->d) found = true;
        else if(d < pv->d) pv = pv->left;
        else pv = pv->right;
    }
    if(found) return pv;
 
    Node *pnew = new Node;
    pnew->d = d;
    pnew->left = 0;
    pnew->right = 0;
    if(d < prev->d)
        prev->left = pnew;
    else
        prev->right = pnew;
 
    return pnew;
}
//----------------------------------------
void print_tree(Node *p, int level){
    if(p){
        print_tree(p->left, level + 1);     // вывод левого поддерева
        for(int i = 0; i < level; i++) cout << "   ";
        cout << p->d << endl;               // вывод корня поддерева
        print_tree(p->right, level + 1);    // вывод левого поддерева
    }
}

void print_tree(Node *p, int level)
{
        if(p){
                for(int i = 0; i < level; i++) cout << "--";
                cout << "Level: " << level << "; Element = "p->d << endl; // вывод корня поддерева
 
                print_tree(p->left, level + 1);         // вывод левого поддерева
                print_tree(p->right, level + 1);        // вывод левого поддерева
        }
}

#include <iostream>
#include <cstdlib>
 
class Node {
public:
    Node() : _left(NULL), _right(NULL), _val(0) {}
    Node(int v) : _left(NULL), _right(NULL), _val(v) {}
    Node(int v, Node *n) {
        if ( v < n->val() ){
            while ( n->val() > v && n->left() != NULL )
                n = n->left();       
        }
        else if ( v > n->val() ){
            while ( n->val() < v && n->right() != NULL)
                n = n->right();
        }
        if ( v == n->val() ){
            std::cerr << "Doubling value (" << v << ")!" << std::endl;
            exit(1);
        }
        else if ( v < n->val() ){
            _right = n;
            _left = n->left();
            n->left(this);
            if ( _left )
                _left->right(this);
        }
        else {
            _left = n;
            _right = n->right();
            n->right(this);
            if ( _right )
                _right->left(this);
        }
        _val = v;
    }
    int val() const { return _val; }
    void val(int v) { _val = v; }
    Node *left() const { return _left; }
    void left(Node *n) { _left = n; }
    Node *right() const { return _right; }
    void right(Node *n) { _right = n; }
    Node *first() const {
        const Node *f = this;
        while ( f->left() != NULL )
            f = f->left();
        return (Node*)f;
    }
    Node *last() const {
        const Node *l = this;
        while ( l->right() != NULL )
            l = l->right();
        return (Node*)l;
    }
private:
    Node *_left;
    Node *_right;
    int _val;
};
 
void printTree(Node *n){
    n = n->first();
    while ( n ){
        std::cout << n->val() << ' ';
        n = n->right();
    }
}
 
void killTree(Node *n){
    Node *t;
    n = n->first();
    while ( n ){
        t = n->right();
        delete n;
        n = t;
    }
}
 
int main(){
    const int values = 10;
    int arr[values] = { 2, 1, 3, 6, 4, 9, 7, 5, 0, 8 }, i;
    Node *n = new Node(arr[0]);
    for ( i = 1; i < values; ++i ){
        n = new Node(arr[i], n);
    }
 
    printTree(n);
    killTree(n);
    std::cout << std::endl;
    return 0;
}

Stack * top = NULL;
push(&top,r);
while(top){
r = pop(&top);
cout<<r->d;
if(r->right)push(&top,r->right);
if(r->left)push(&top,r->legt);
}