BST problema output

Salve a tutti. Mi stavo esercitando con gli alberi binari di ricerca, e ho provato a fare un esercizio nel quale dovevo stampare tutte le chiavi che avevano un padre con un fratello. Il metodo sembra funzionare perfettamente, il problema è che quando non deve stampare la chiave, ansicchè non fare nulla, stampa il carattere " ". In questo modo tutto il file di output inizia con almeno uno spazio vuoto. Sapete quale possa essere l'errore? come posso risolvere? in basso vi allego il codice

#include <iostream>
#include <fstream>

using namespace std;

ifstream in("input.txt");
ofstream out("output.txt");

template <class H>
class Nodo{
private:
    H elemento;
    Nodo<H>* padre;
    Nodo<H>* dx;
    Nodo<H>* sx;
public:
    Nodo(H _elemento):elemento(_elemento){
        this->padre=NULL;
        this->dx=NULL;
        this->sx=NULL;
    }
    H getElemento(){return elemento;}
    Nodo<H>* getPadre(){return padre;}
    Nodo<H>* getDx(){return dx;}
    Nodo<H>* getSx(){return sx;}

    void setElemento(H x){this->elemento=x;}
    void setPadre(Nodo<H>* padre){this->padre=padre;}
    void setDx(Nodo<H>* dx){this->dx=dx;}
    void setSx(Nodo<H>* sx){this->sx=sx;}
};

template <class H>
class Tree{
private:
    Nodo<H>* radice;
public:
    Tree(){this->radice=NULL;}
    void ins(H x){
        Nodo<H>* nuovo=new Nodo<H>(x);
        if(radice==NULL)
            radice=nuovo;
        else{
            Nodo<H>* iter=radice;
            Nodo<H>* tmp=NULL;
            while(iter!=NULL){
                tmp=iter;
                if(x>iter->getElemento())
                    iter=iter->getDx();
                else
                    iter=iter->getSx();
            }
            nuovo->setPadre(tmp);
            if(x>tmp->getElemento())
                tmp->setDx(nuovo);
            else
                tmp->setSx(nuovo);
        }
    }


    Nodo<H>* cerca(H val){
        Nodo<H>* x=radice;
        while(x!=NULL && x->getElemento()!=val){
            if(x->getElemento()>val)
                x=x->getSx();
            else
                x=x->getDx();
        }
        return x;
    }
    Nodo<H>* minimo(Nodo<H>* minimo){
        Nodo<H>* x=minimo;
        while(x->getSx()!=NULL) x=x->getSx();
        return x;
    }
    void Trapianta(Nodo<H>* x, Nodo<H>* y){
        if(x->getPadre()==NULL) radice=y;
        else if(x==x->getPadre()->getSx())
            x->getPadre()->setSx(y);
        else
            x->getPadre()->setDx(y);
        if(y)
            y->setPadre(x->getPadre());
    }
    void Cancella(H val){
        Nodo<H>* x=cerca(val);
        if(x){
            if(x->getSx()==NULL)
                Trapianta(x, x->getDx());
            else if(x->getDx()==NULL)
                Trapianta(x, x->getSx());
            else{
                Nodo<H>* y=minimo(x->getDx());
                if(y->getPadre()!=x){
                    Trapianta(y, y->getDx());
                    y->setDx(x->getDx());
                    y->getDx()->setPadre(y);
                }
                Trapianta(x, y);
                y->setSx(x->getSx());
                y->getSx()->setPadre(y);
            }
            delete x;
        }
    }
    
        void visitaPostorder(Nodo<H>* x){
        if(x){
            visitaPostorder(x->getSx());
            visitaPostorder(x->getDx());
            func(x); 
			out<< " ";
        }
    }
    
	void func (Nodo<H>* x){
    	Nodo<H>* iter = x;
    	if(!iter->getPadre())
			return;	
		else
    		iter=iter->getPadre();	
    	if(!iter->getPadre())
    		return;
    	else
    	iter=iter->getPadre();
    		
    	if(iter->getDx() != NULL && iter->getSx() != NULL)
   
    		 out<<x->getElemento();
	}
    
    void print(){
        visitaPostorder(radice);
    }
};

template <class H>
void metodo(int n){
    Tree<H>* tree=new Tree<H>;
    H val; char a;
    for(int i=0; i<n; i++){
        in>>a;
        if(a=='i'){
            while(a!=':')
                in>>a;
            in>>val;
            tree->ins(val);
        }
        else if(a=='c'){
            while(a!=':')
                in>>a;
            in>>val;
            tree->Cancella(val);
        }
    }
    	 tree->print(); 
		 out<<endl;
}

int main()
{
    string type; int n; 
    for(int i=0; i<100; i++){
        in>>type; in>>n; 
        if(type=="int") metodo<int>(n);
        if(type=="double") metodo<double>(n);
    }
    return 0;
}

come si può evincere dal codice, prendo in input un file di 100 righe per costruire l'albero, e il file di output deve avere per ogni riga tutte le chiavi che hanno il padre con un fratello.

Spero di non essermi dilungato troppo, auguro a tutti una buona serata