C++ 二进制树模板崩溃

有人能告诉我为什么我的上一个函数

height（）

会导致系统崩溃吗？我测试了每个函数，它们都可以工作，但是当我编写这个函数并从main调用它时，它会导致程序崩溃。它构建时没有任何错误

#ifndef BINARYTREE_H
#define BINARYTREE_H
#include <iostream>
using namespace std;

// This class is a template class that creates a binary
// tree that can hold values of any data type. It has 
// functions to insert a node, delete a node, display the
// tree In Order, Pre Order and Post Order, search for a 
// value, count the number of total nodes, left nodes, 
// and a function to determine the height of the tree.

template <class T>
class BinaryTree
{
private:
    struct TreeNode
    {
        T value;            // The value in the node
        TreeNode *left;     // Pointer to left child node
        TreeNode *right;    // Pointer to right child node
    };

    TreeNode *root;         // Pointer to the root node

    // Private member functions
    void insert(TreeNode *&, TreeNode *&);
    void destroySubTree(TreeNode *);
    void deleteNode(T, TreeNode *&);
    void makeDeletion(TreeNode *&);
    void displayInOrder(TreeNode *) const;
    void displayPreOrder(TreeNode *) const;
    void displayPostOrder(TreeNode *) const;
    int counter(TreeNode *);
    int leafCounter(TreeNode *);
    int height(TreeNode *);

public:
    // Constructor
    BinaryTree()
    { root = NULL; }

    // Destructor
    ~BinaryTree()
    { destroySubTree(root); }

    // Binary tree operations
    void insertNode(T);
    bool searchNode(T);
    void remove(T);

    void displayPreOrder() const
    { displayPreOrder(root); }

    void displayInOrder() const
    { displayInOrder(root); }

    void displayPostOrder() const
    { displayPostOrder(root); }

    // Node counter
    int counter()
    { 
        int n = counter(root);
        return n;
    }

    // Leaf counter
    int leafCounter()
    {
        int leaf = leafCounter(root);
        return leaf;
    }

    // Height of the tree
    int height()
    {
        int h = height(root);
        return h;
    }
};

//*********************************************************
// insert function accepts a TreeNode pointer and a       *
// pointer to a node. The function inserts the node into  *
// the tree pointer to by the TreeNode pointer. This      *
// function is call recursively.                          *
//*********************************************************
template <class T>
void BinaryTree<T>::insert(TreeNode *&nodePtr, TreeNode *&newNode)
{
    if (nodePtr == NULL)
        nodePtr = newNode;              // Insert the node
    else if (newNode->value < nodePtr->value)
        insert(nodePtr->left, newNode); // Search the left branch
    else
        insert(nodePtr->right, newNode);// Search the right branch
}

//*********************************************************
// insertNode creates anew node to hold num as its value  *
// and passes it to the insert function.                  *
//*********************************************************
template <class T>
 void BinaryTree<T>::insertNode(T item)
 {
     TreeNode *newNode;     // Pointer to a new node

     // Create anew node and store num in it
     newNode = new TreeNode;
     newNode->value = item;
     newNode->left = newNode->right = NULL;

     // Insert the node
     insert(root, newNode);
 }

//**********************************************************
// destroySubTree is called by the destructor. It deletes  *
// all nodes in the tree.                                  *
//**********************************************************
template <class T>
void BinaryTree<T>::destroySubTree(TreeNode *nodePtr)
{
     if (nodePtr)
     {
         if (nodePtr->left)
             destroySubTree(nodePtr->left);
         if (nodePtr->right)
             destroySubTree(nodePtr->right);
         delete nodePtr;
     }
}

//**********************************************************
// searchNode determines if a value is present in the tree.*
// If so, the function returns true. Otherwise it returns  *
// false.
//**********************************************************
template <class T>
bool BinaryTree<T>::searchNode(T item)
{
    TreeNode *nodePtr = root;

    while (nodePtr)
    {
        if (nodePtr->value == item)
            return true;
        else if (item < nodePtr->value)
            nodePtr = nodePtr->left;
        else
            nodePtr = nodePtr->right;
    }
    return false;
}

//*********************************************************
// remove calls deleteNode to delete the node whode value *
// member is the same as num                              *
//*********************************************************
template <class T>
void BinaryTree<T>::remove(T item)
{
    deleteNode(item, root);
}

//*********************************************************
// deleteNode deletes the node whose value member is the  *
// same as num                                            *
//*********************************************************
template <class T>
void BinaryTree<T>::deleteNode(T item, TreeNode *&nodePtr)
{
    if (item < nodePtr->value)
        deleteNode(item, nodePtr->left);
    else if (item > nodePtr->value)
        deleteNode(item, nodePtr->right);
    else
        makeDeletion(nodePtr);
}

//*********************************************************
// makeDeletion takes a reference to apointer to the node *
// that is to be deleted. The node is removed and the     *
// branches of the tree below the node are reattached     *
//*********************************************************
template <class T>
void BinaryTree<T>::makeDeletion(TreeNode *&nodePtr)
{
    // Define a temporary pointer to use in reattaching
    // the left subtree
    TreeNode *tempNodePtr;

    if (nodePtr == NULL)
        cout << "Cannot delete empty node.\n";
    else if (nodePtr->right == NULL)
    {
        tempNodePtr = nodePtr;
        nodePtr = nodePtr->left;    // Reattach the left child
        delete tempNodePtr;
    }
    else if (nodePtr->left == NULL)
    {
        tempNodePtr = nodePtr;
        nodePtr = nodePtr->right;   // Reattach the right child
        delete tempNodePtr;
    } 

}
//*********************************************************
// The displayInOrder function displays the values in the *
// subtree pointed to by nodePtr, via inorder traversal   *
//*********************************************************
template <class T>
void BinaryTree<T>::displayInOrder(TreeNode *nodePtr) const
{
    if (nodePtr)
    {
        displayInOrder(nodePtr->left);
        cout << nodePtr->value << endl;
        displayInOrder(nodePtr->right);
    }
}
//*********************************************************
// The displayPreOrder function displays the values in the*
// subtree pointed to by nodePtr, via Preorder traversal  *
//*********************************************************
template <class T>
void BinaryTree<T>::displayPreOrder(TreeNode *nodePtr) const
{
    if (nodePtr)
    {
        cout << nodePtr->value << endl;
        displayInOrder(nodePtr->left);
        displayInOrder(nodePtr->right);
    }
}
//*********************************************************
// displayPostOrder function displays the values in the   *
// subtree pointed to by nodePtr, via Postorder traversal *
//*********************************************************
template <class T>
void BinaryTree<T>::displayPostOrder(TreeNode *nodePtr) const
{
    if (nodePtr)
    {
        displayInOrder(nodePtr->left);
        displayInOrder(nodePtr->right);
        cout << nodePtr->value << endl;
    }
}

//*********************************************************
// counter counts the number of nodes the tree has        *
//*********************************************************
template <class T>
int BinaryTree<T>::counter(TreeNode *nodePtr)
{
    if (nodePtr == NULL)
        return 0;
    else
        return counter(nodePtr->left) +1+ counter(nodePtr->right);
}

//*********************************************************
// leafCounter counts the number of leaf nodes in the tree*
//*********************************************************
template <class T>
int BinaryTree<T>::leafCounter(TreeNode *nodePtr)
{
    if (nodePtr == NULL)
        return 0;
    else if (nodePtr->left == NULL && nodePtr->right == NULL)
        return 1;
    else 
        return leafCounter(nodePtr->left) + leafCounter(nodePtr->right);
}

//*********************************************************
// height returns the height of the tree                  *
//*********************************************************
template <class T>
int BinaryTree<T>::height(TreeNode *nodePtr)
{

    if(nodePtr = NULL)
        return -1;
    if (height(nodePtr->left) <= height(nodePtr->right))
        return (height(nodePtr->right) +1);
    else
        return (height(nodePtr->left) +1);

}
#endif

\ifndef二进制树
#定义二叉树
#包括
使用名称空间std；
//此类是创建二进制文件的模板类
//可以保存任何数据类型的值的树。它有
//用于插入节点、删除节点、显示
//排序树，预排序和后排序，搜索
//值，计算总节点数，左节点数，
//和一个函数来确定树的高度。
样板
类二叉树
{
私人：
树状结构
{
T value；//节点中的值
TreeNode*left；//指向左子节点的指针
TreeNode*right；//指向右子节点的指针
};
TreeNode*root；//指向根节点的指针
//私人成员职能
无效插入（TreeNode*&，TreeNode*&）；
子树（TreeNode*）；
void deleteNode（T，TreeNode*&）；
void makeDeletion（TreeNode*&）；
无效显示顺序（TreeNode*）常数；
无效显示预订单（TreeNode*）常量；
无效显示PostOrder（TreeNode*）常量；
整数计数器（TreeNode*）；
内部叶片计数器（TreeNode*）；
内部高度（TreeNode*）；
公众：
//建造师
二叉树（）
{root=NULL；}
//析构函数
~BinaryTree（）
{子树（根）；}
//二叉树运算
void-insertNode（T）；
布尔搜索节点（T）；
脱空（T）；
void displayPreOrder（）常量
{displayPreOrder（根）；}
void displayInOrder（）常量
{displayInOrder（根）；}
void displayPostOrder（）常量
{displayPostOrder（根）；}
//节点计数器
int计数器（）
{ 
int n=计数器（根）；
返回n；
}
//叶计数器
int leaftcounter（）
{
int leaf=叶计数器（根）；
回叶；
}
//树高
整数高度（）
{
int h=高度（根）；
返回h；
}
};
//*********************************************************
//insert函数接受树节点指针和*
//指向节点的指针。该函数将节点插入到*
//树节点指针指向的树指针。这个*
//函数是递归调用的*
//*********************************************************
样板
void BinaryTree:：insert（TreeNode*&nodePtr，TreeNode*&newNode）
{
if（nodePtr==NULL）
nodePtr=newNode；//插入节点
else if（newNode->valuevalue）
插入（nodePtr->left，newNode）；//搜索左分支
其他的
插入（nodePtr->right，newNode）；//搜索右分支
}
//*********************************************************
//insertNode创建一个新节点，将num作为其值*
//并将其传递给insert函数*
//*********************************************************
样板
void BinaryTree:：insertNode（T项）
{
TreeNode*newNode；//指向新节点的指针
//创建新节点并在其中存储num
新节点=新树节点；
新建节点->值=项目；
newNode->left=newNode->right=NULL；
//插入节点
插入（根，新节点）；
}
//**********************************************************
//析构函数调用destroySubTree。它删除*
//树中的所有节点*
//**********************************************************
样板
void BinaryTree:：destroySubTree（TreeNode*nodePtr）
{
if（nodePtr）
{
如果（nodePtr->left）
销毁子树（nodePtr->left）；
如果（nodePtr->right）
销毁子树（nodePtr->right）；
删除nodePtr；
}
}
//**********************************************************
//searchNode确定树中是否存在值*
//如果是，则函数返回true。否则它将返回*
//错。
//**********************************************************
样板
bool二进制树：：searchNode（T项）
{
TreeNode*nodePtr=根；
while（nodePtr）
{
如果（nodePtr->value==项目）
返回true；
else if（项目value）
nodePtr=nodePtr->left；
其他的
nodePtr=nodePtr->right；
}
返回false；
}
//*********************************************************
//remove调用deleteNode以删除节点whode值*
//成员与num相同*
//*********************************************************
样板
void BinaryTree:：删除（T项）
{
删除节点（项，根）；
}
//*********************************************************
//deleteNode删除其值成员为*
//与num相同*
//*********************************************************
样板
void BinaryTree:：deleteNode（T项、TreeNode*&nodePtr）
{
如果（项目value）
删除节点（项目，节点接受->左侧）；
否则如果（项目>节点接受->值）
删除节点（项目，节点接受->右侧）；
其他的
makeDeletion（nodePtr）；
}
//*********************************************************
//makeDeletion将apointer引用到节点*
//这将被删除。节点将被删除，并且*
//节点下方的树分支将重新附着*
//*********************************************************
样板
void BinaryTree:：makeDeletion（TreeNode*&nodePtr）
{
//定义用于重新附着的临时指针
//左子树
TreeNode*tempNodePtr；
if（nodePtr==NULL）
cout right==NULL）
{
tempNodePtr=nodePtr；
nodePtr=nodePtr->left；//重新连接左侧子级
删除tempNodePtr；
}
else if（nodePtr->left==NULL）
{
T
// This program demonstrates that the functions of
// BinaryTree works correctly.
#include "BinaryTree.h"
#include <iostream>
using namespace std;

int main()
{
    // Create a BinaryTree object
    BinaryTree<int> tree;

    // Insert some nodes
    cout << "Inserting nodes...\n";
    tree.insertNode(5);
    tree.insertNode(10);
    tree.insertNode(3);
    tree.insertNode(1);
    tree.insertNode(13);

    // Display the nodes InOrder
    cout << "\nDisplaying the nodes InOrder...\n";
    tree.displayInOrder();

    // Display the nodes PreOrder
    cout << "\nDisplaying the nodes PreOrder...\n";
    tree.displayPreOrder();

    // Display the nodes PostOrder
    cout << "\nDisplaying the nodes PostOrder...\n";
    tree.displayPostOrder();

    // Delete a node
    cout << "\nDeleting node 3...\n";
    tree.remove(3);

    // Display the nodes after deletion
    cout << "\nHere are the nodes InOrder after deletion:\n";
    tree.displayInOrder();

    // Search the nodes for the value 10
    cout << "\nSearching the nodes for the value 10...\n";
    if (tree.searchNode(10))
        cout << "Value was found.\n";
    else 
        cout << "Value was not found.\n";

    // Search for the deleted node 3
    cout << "\nSearching for the deleted node 3...\n";
    if (tree.searchNode(3))
        cout << "Value was found.\n";
    else 
        cout << "Value was not found.\n";

    // Count how many nodes are in the tree
    cout << "\nThere are " << tree.counter() << " nodes"
         << " in the tree.\n";

    // Count how many leafs are in the tree
    cout << "\nThere are " << tree.leafCounter()
         << " leaves in the tree.\n";

    // Get the height of the tree
    cout << "\nThe height of the tree is " << tree.height();
    cout << endl;

    return 0;
}

if(nodePtr = NULL)

if(nodePtr == NULL)