drzewo bts niekodkonczone usuwanie

#include <iostream>

using namespace std;

// drzewa dla reprezentacji tablicowej
/*const int N = 12;
int drzewo[N] = {12,7,19,3,9,15,-1,-1,-1,-1,-1,14};
int rootT = 0;
void preOrder(int p){
    if(p>=12 || drzewo[p]!=-1) return;
    cout << drzewo[p] << " ";
    preOrder(p*2+1);
    preOrder(p*2+2);
}*/

//dla reprezentacji dowiązaniowej
//definicja węzła drzewa
struct wezel{
    int value;
    wezel* left = NULL;
    wezel* right = NULL;
    wezel* up = NULL;
};

wezel * root = NULL;

void inOrder(wezel* p){
    if(p==NULL) return;
    inOrder(p->left);
    cout << p->value << " ";
    inOrder(p->right);
}

void dodaj(int w){
    cout << "dodaj(" << w << "): ";
    wezel* y = new wezel;
    y->value = w;
    if(root==NULL) root = y;
    else{
        wezel* x = root;
        wezel* p = x;
        while(x!=NULL){
            p = x;
            if(w<x->value) x=x->left;
            else x=x->right;
        }
        if(w<p->value) p->left=y;
        else p->right=y;
        y->up = p;
    }
    inOrder(root);
    cout << endl;
}

wezel * szukaj(wezel* x, int w){
    if(x==NULL || x->value) return x;
    if(w<x->value) return szukaj(x->left, w);
    else return szukaj(x->right, w);
}

wezel * minBST(wezel* x){
    if(x==NULL) return x;
    while(x->left!=NULL) x=x->left;
    return x;
}

wezel * maxBST(wezel* x){
    if(x==NULL) return x;
    while(x->right!=NULL) x=x->right;
    return x;
}

wezel * nastepnik(wezel* x){
    if(x==NULL) return x;
    if(x->right!=NULL) return minBST(x->right);
    wezel* r = x->up;
    while(r!=NULL && x==r->right){
        x = r;
        r = x->up;
    }
    return x;
}

wezel * poprzednik(wezel* x){
    if(x==NULL) return x;
    if(x->left!=NULL) return maxBST(x->left);
    wezel* r = x->up;
    while(r!=NULL && x==r->left){
        x = r;
        r = x->up;
    }
    return x;
}

void usun(int w){
    cout << "usun(" << w << "): ";
    wezel* x = szukaj(root, w);
    if(x==NULL) return;
    if(x->left==NULL && x->right==NULL){ //przypadek1:
        delete x;
        return;
    }
    if(x->left==NULL || x->right==NULL){ //przypadek2:
        wezel* syn;
        if(x->left==NULL){
            syn = x->right;
            x->right = NULL;
        }else{
            syn = x->left;
            x->left = NULL;
        }
        x->value = syn->value;
        delete syn;
        return;
    }
    //przypadek3:
    wezel* z = nastepnik(x);
    if(z==NULL) z = poprzednik(x);
    x->value = z->value;
    delete z;
    inOrder(root);
    cout << endl;
}

int main(int argc, char* argv){
    //po każdej operacji dodania węzła należy wyświetlić drzewo
    dodaj(10);dodaj(5);dodaj(3);dodaj(9);dodaj(8);dodaj(14);dodaj(12);dodaj(1); dodaj(11);
    szukaj(root, 10); szukaj(root, 1); szukaj(root, 12); szukaj(root, 3); szukaj(root, 14); szukaj(root, 9);
    usun(11); usun(9);usun(5); usun(10);
    cout << "inOrder(root): ";
    inOrder(root);
    cout << endl;
    return 0;
}