C++11 打印和删除二叉树中的数据，c++；

晚上好,， 我正在努力打印我的二叉树

#ifndef TREE_H_INCLUDED
#define TREE_H_INCLUDED

#include "qt.h"
#include <iostream>
using namespace std;

template<typename T>
class Tree{
    Node<T> *root;
    void insertIntoTree(T &d, Node<T> *&r);
    void printTree(Node<T> *r);
    void deleteTree(Node<T> *&r);
    Node<T>* findInTree(T &d, Node<T> *r, Node<T> *&parent);
    void deleteLeaf(Node<T> *p, Node<T> *q);
    void deleteInBranch(Node<T> *p, Node<T> *g);
public:
    Tree() : root(nullptr){}
    ~Tree(){
        clean();
    }
    bool find(T d){
        Node<T> *dummy=nullptr;
        return findInTree(d, root, dummy);
    };
    void clean(){
        deleteTree(root);}
    void insert(T d){
         insertIntoTree(d, root);}
    void print(){
        printTree(root);
    }
    bool deleteNode(T d);
};

template<typename T>
void Tree<T>::insertIntoTree(T &d, Node<T> *&r){
    if(!r){
        r = new Node<T>(d);
        return;
    }
    if(r->getData()<d){
        insertIntoTree(d, r->right);
    }
    else{
        insertIntoTree(d, r->left);
    }
}

template<typename T>
void Tree<T>::printTree(Node<T> *r){
    if(r){
        printTree(r->left);
        r->print();
        printTree(r->right);
    }
}

template<typename T>
void Tree<T>::deleteTree(Node<T> *&r){
    if(r){
        deleteTree(r->left);
        deleteTree(r->right);
        delete r;
        r = nullptr;
    }
}

template<typename T>
Node<T>* Tree<T>::findInTree(T &d, Node<T> *r, Node<T> *&parent){
    if(!r){
        return nullptr;
    }
    if(r->getData()==d){
        return r;
    }
    parent = r;
    if(r->getData()<d){
        return findInTree(d, r->right, parent);
     }
    else{
        return findInTree(d, r->right, parent);
    }
}

template<typename T>
void Tree<T>::deleteLeaf(Node<T> *p, Node<T> *q){
    if(p == root){
        root = nullptr;
    }
    else{
        if(p->right == q)
            q->right = nullptr;
        else
            q->left = nullptr;
    }
    delete p;
}

template<typename T>
void Tree<T>::deleteInBranch(Node<T> *p, Node<T> *q){
    Node<T> *s = (p->left ? p->left : p->right);
    if(p == root){
        root = s;
    }else{
        if(q->left == p){
            q->left = s;
        }
        else{
            q->right = s;
        }
    }
    delete p;
}

template<typename T>
bool Tree<T>::deleteNode(T d){
   Node<T> *p, *q = nullptr;
   p = findInTree(d, root, q);
   if(!p){
       return false;
   }
   if(!p->left && !p->right){
        deleteLeaf(p, q);
   } else if(!p->left || !p->right){
       deleteInBranch(p, q);
   } else{
       Node<T> *r = p->left; 
       q = p;
       while(r->right){
           q = r;
           r = r->right;
       }
       p->setData(r->getData());
       if(r->left){
           deleteInBranch(r, q);
       } else{
           deleteLeaf(r, q);
       }
   }
   return true;
}

#endif // TREE_H_INCLUDED

\ifndef TREE\u包括在内
#定义包含的树
#包括“qt.h”
#包括
使用名称空间std；
模板
类树{
节点*根；
无效插入树（T&d、节点*&r）；
无效打印树（节点*r）；
无效删除树（节点*&r）；
节点*findInTree（T&d、节点*r、节点*&父节点）；
void deleteLeaf（节点*p，节点*q）；
void deleteInBranch（节点*p，节点*g）；
公众：
Tree（）：根（nullptr）{}
~Tree（）{
清洁（）；
}
布尔查找（TD）{
节点*dummy=nullptr；
返回findInTree（d，根，伪）；
};
void clean（）{
deleteTree（根）；}
空白插入（T d）{
插入树（d，根）；}
作废打印（）{
打印树（根）；
}
bool-deleteNode（td）；
};
模板
空树：：插入树（T&d、节点*&r）{
if（！r）{
r=新节点（d）；
返回；
}
如果（r->getData（）右侧）；
}
否则{
插入树（d，r->左）；
}
}
模板
无效树：：打印树（节点*r）{
if（r）{
打印树（右->左）；
r->print（）；
打印树（右->右）；
}
}
模板
无效树：：删除树（节点*&r）{
if（r）{
删除树（r->左）；
删除树（r->右侧）；
删除r；
r=nullptr；
}
}
模板
节点*树：：findInTree（T&d、节点*r、节点*&父节点）{
if（！r）{
返回空ptr；
}
如果（r->getData（）==d）{
返回r；
}
父代=r；
如果（r->getData（）右侧，父级）；
}
否则{
返回findInTree（d，r->右侧，父级）；
}
}
模板
void树：：deleteLeaf（节点*p，节点*q）{
if（p==根）{
root=nullptr；
}
否则{
如果（p->right==q）
q->right=nullptr；
其他的
q->left=nullptr；
}
删除p；
}
模板
void树：：deleteInBranch（节点*p，节点*q）{
节点*s=（p->左？p->左：p->右）；
if（p==根）{
根=s；
}否则{
如果（q->左==p）{
q->左=s；
}
否则{
q->右=s；
}
}
删除p；
}
模板
布尔树：：删除节点（td）{
节点*p，*q=nullptr；
p=findInTree（d，根，q）；
如果（！p）{
返回false；
}
如果（！p->左&&！p->右）{
落叶（p，q）；
}如果（！p->左| |！p->右），则为else{
deleteInBranch（p，q）；
}否则{
节点*r=p->左；
q=p；
while（右->右）{
q=r；
r=r->右；
}
p->setData（r->getData（））；
如果（右->左）{
deleteInBranch（r，q）；
}否则{
删除叶（r，q）；
}
}
返回true；
}
#endif//TREE_H_包括在内

qt.h

#如果包括
#定义包含的QT_H_
#包括
模板
类节点{
T数据；
节点*左；
节点*右；
公众：
节点（td）：数据（d），左（nullptr），右（nullptr）{
作废打印（）{
如果程序崩溃，您应该使用调试器来确定崩溃位置。为此，请打开“调用堆栈”然后向下导航，直到找到其中一个函数。根据调试器的不同，通常只需双击函数，它就会显示代码中的崩溃位置。仍然不知道如何操作，但至少我发现了错误，谢谢您的回答：）
#ifndef QT_H_INCLUDED
#define QT_H_INCLUDED

#include<iostream>

template<typename T>
class Node{
    T data;
    Node<T> *left;
    Node<T> *right;
public:
    Node(T d) : data(d), left(nullptr), right(nullptr){}
    void print(){
        std::cout << data << std::endl;}
    T getData()const {
        return data;
        }
    void setData(const T &value){
        data = value;
        }
    template<typename X> friend class Tree;
};

#endif // QT_H_INCLUDED

#include <iostream>
#include "qt.h"
#include "tree.h"

using namespace std;

int main()
{
    Tree<int> t;
    t.insert(42);
    t.insert(26);
    t.insert(10);
    t.insert(5);
    t.insert(53);
    t.insert(9);
    t.insert(38);
    if(t.find(42)){
        cout << "nalezeno" << endl;
    }
    else
        cout << "nenalezeno" << endl;
    if(t.deleteNode(42)){
        cout << "smazano" << endl;
    }
    t.print();
     return 0;
}