C++ c++；错误LNK2019:二进制搜索树

考虑到我的根声明有问题，我的插入函数、默认构造函数和析构函数中出现了三个错误

如果I#include.cpp文件： 我的插入函数和正确构造树存在问题。我在观察我的局部变量，根的行为很奇怪——在添加第一个值后，根指向没有数据的东西。（我对C++非常陌生，所以请您耐心等待，这是我第一次创建模板类和二叉搜索树）

它每次到达行时都会抛出一个异常，而（p->data！=item）

这是我的插入函数：

    template <class Item>
void Tree<Item>::insert(Item item)
{
    Node<Item> *new_node = new Node<Item>();
    new_node->data = item;

    if (root == nullptr)
    {
        root = new_node;
    }
    else
    {
        Node<Item> *q = nullptr;
        Node<Item> *p = root;
        while (p != nullptr && q->data != item)
        {
            q = p;
            if (item < p->data)
            {
                q = p->lchild;
            }
            else if (item > p->data)
            {
                q = p->rchild;
            }
        }
        if (q->data == item)
        {
            cout << "Duplicate Data" << endl;
        }
        else
        {
            if (item > q->data)
            {
                q->rchild = new_node;
            }
            else
            {
                q->lchild = new_node;
            }
        }
    }
}

模板
无效树：：插入（项）
{
Node*new_Node=新节点（）；
新建_节点->数据=项目；
if（root==nullptr）
{
根=新的_节点；
}
其他的
{
Node*q=nullptr；
节点*p=根；
而（p！=nullptr&&q->data！=item）
{
q=p；
如果（项目数据）
{
q=p->lchild；
}
否则如果（项目>p->数据）
{
q=p->rchild；
}
}
如果（q->数据==项目）
{
cout（数据）
{
q->rchild=新节点；
}
其他的
{
q->lchild=新节点；
}
}
}
}

标题：

#pragma once
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

template <class Item>
struct Node
{
    //Default constructor for Node
    //Purpose: Initialize all values
    //Parameters: None
    //Returns: None
    Node();

    //Parameterized constructor for Node
    //Purpose: Initialize all values
    //Parameters: a data Item, and Node pointers for left and right children
    //Returns: None
    Node(Item, Node<Item>*, Node<Item>*);

    //variables
    Item data;
    Node<Item> *lchild;
    Node<Item> *rchild;
};

template <class Item>
class Tree
{

public:
    //Default constructor for Tree
    //Purpose: Initialize all values
    //Parameters: None
    //Returns: None
    Tree();

    //Copy constructor
    //Purpose: create new Tree
    //Parameters: A Tree object
    //Returns: Tree
    Tree(const Tree&);

    //copy
    //Purpose: To copy values
    //Parameters: Node pointer
    //Returns: None
    void copy(Node<Item>*);

    //chop
    //Purpose: Delete tree
    //Parameters: Node pointer
    //Returns: None
    void chop(Node<Item>*);

    //Destructor
    //Purpose: Clean up data, delete tree
    //Parameters: None
    //Returns: None
    ~Tree();

    //operator=
    //Purpose: Overload assignment operator
    //Parameters: a const ref to a Tree object
    //Returns: Tree
    const Tree<Item>&operator=(const Tree&);

    //insert
    //Purpose: To add a value to tree
    //Parameters: A const reference to an Item
    //Returns: None
    void insert(Item);

    //inOrderTraverse
    //Purpose: To traverse the tree in order
    //Parameters: A Node pointer
    //Returns: None
    //void inOrderTraverse(Item);


private:
    Node<Item> *root;
};

#pragma一次
#包括
#包括
#包括
使用名称空间std；
模板
结构体类型
{
//节点的默认构造函数
//目的：初始化所有值
//参数：无
//退货：无
Node（）；
//节点的参数化构造函数
//目的：初始化所有值
//参数：一个数据项，以及左、右子节点的节点指针
//退货：无
节点（项目，节点*，节点*）；
//变数
项目数据；
节点*lchild；
节点*rchild；
};
模板
类树
{
公众：
//树的默认构造函数
//目的：初始化所有值
//参数：无
//退货：无
树（）；
//复制构造函数
//目的：创建新树
//参数：树对象
//返回：树
树（consttree&）；
//抄袭
//目的：复制值
//参数：节点指针
//退货：无
无效副本（节点*）；
//砍
//目的：删除树
//参数：节点指针
//退货：无
无效印章（节点*）；
//析构函数
//用途：清理数据、删除树
//参数：无
//退货：无
~Tree（）；
//接线员=
//用途：过载分配操作员
//参数：树对象的常量引用
//返回：树
常量树&运算符=（常量树&）；
//插入
//目的：为树添加值
//参数：对项目的常量引用
//退货：无
无效插入（项目）；
//无序旅行
//目的：按顺序遍历树
//参数：节点指针
//退货：无
//订单行程中的作废（项目）；
私人：
节点*根；
};

下面是我的树类：

   #include "Tree.h"

template <class Item>
Node<Item>::Node()
{
    data = 0;
    lchild = nullptr;
    rchild = nullptr;
}

template <class Item>
Node<Item>::Node(Item _data, Node<Item> *_lchild, Node<Item> *_rchild)
{
    data = _data;
    lchild = _lchild;
    rchild = _rchild;
}

template <class Item>
Tree<Item>::Tree()
{
    root = nullptr;
}

template <class Item>
void Tree<Item>::copy(Node<Item> *c)
{
    if (c)
    {
        insert(c->data);
        copy(c->lchild);
        copy(c->rchild);
    }
}

template <class Item>
void Tree<Item>::chop(Node<Item> *c)
{
    if (c)
    {
        chop(c->lchild);
        chop(c->rchild);
        delete c;
    }
}

template <class Item>
Tree<Item>::Tree(const Tree& t)
{
    root = nullptr;
    copy(t.root);
}

template <class Item>
Tree<Item>::~Tree()
{
    chop(root);
}

template <class Item>
const Tree<Item>&Tree<Item>::operator=(const Tree& t)
{
    if (this != &t)
    {
        chop(root);
        root = nullptr;
        copy(t.root);
    }
    return *this;
}

template <class Item>
void Tree<Item>::insert(Item item)
{
    Node<Item> *new_node = new Node<Item>();
    new_node->data = item;

    if (root == nullptr)
    {
        root = new_node;
    }
    else
    {
        Node<Item> *p = root;
        Node<Item> *q = nullptr;
        while (p->data != item)
        {
            q = p;
            if (item < p->data)
            {
                p = p->lchild;
            }
            else if (item > p->data)
            {
                p = p->rchild;
            }
        }
        if (p-> data == item)
        {
            cout << "Duplicate Data" << endl;
        }
        else 
        {
            if (item < q->data)
            {
                q->lchild = new_node;
            }
            else
            {
                q->rchild = new_node;
            }
        }

    }
}

#包括“Tree.h”
模板
Node:：Node（）
{
数据=0；
lchild=nullptr；
rchild=nullptr；
}
模板
节点：：节点（项_数据、节点*\u lchild、节点*\u rchild）
{
数据=_数据；
lchild=_lchild；
rchild=_rchild；
}
模板
Tree:：Tree（）
{
root=nullptr；
}
模板
无效树：：复制（节点*c）
{
如果（c）
{
插入（c->数据）；
副本（c->lchild）；
副本（c->rchild）；
}
}
模板
空树：：chop（节点*c）
{
如果（c）
{
印章（c->lchild）；
印章（c->rchild）；
删除c；
}
}
模板
树：：树（consttree&t）
{
root=nullptr；
拷贝（t.root）；
}
模板
树：：~Tree（）
{
斩（根）；
}
模板
常量树和树：：运算符=（常量树和t）
{
如果（此！=&t）
{
斩（根）；
root=nullptr；
拷贝（t.root）；
}
归还*这个；
}
模板
无效树：：插入（项）
{
Node*new_Node=新节点（）；
新建_节点->数据=项目；
if（root==nullptr）
{
根=新的_节点；
}
其他的
{
节点*p=根；
Node*q=nullptr；
而（p->data！=项目）
{
q=p；
如果（项目数据）
{
p=p->lchild；
}
否则如果（项目>p->数据）
{
p=p->rchild；
}
}
如果（p->data==项目）
{
cout lchild=新节点；
}
其他的
{
q->rchild=新节点；
}
}
}
}

主要内容：

#包括“Tree.h”
int main（）
{
//数据的变量
字符串文件；
ifstream-infle（文件）；
树myTree；
int d=0；
//要求用户输入文件名
在while循环条件下不能，不是吗

while (p != nullptr && p->data != item)

q只是一个空指针，[q->data！=item]将始终为真。
您的算法有几个问题，我将指出其中的几个

if (root == nullptr)
{
    root = new_node;
}

处理root不为null的条件。请记下您的代码

Node<Item> *p = root;

这里的一个错误已经在另一个答案中指出，但是
p
不能为空，因为在这一点上，p与root相同，并且p永远不会改变，所以您不断地指向root

q = p // I would do q = root;

应该在循环的外部。循环的内部应该是这样的：

while(q != nullptr) {
  if(newNode->data < q->data) {
    q = q->leftChild;
  } else if(newNode->data > q->data) {
    q = q->rightChild;
  } else {
    cout << "ERROR: item already exists";
    return 1;
  }
}

while（q！=nullptr）{
如果（新建节点->数据数据）{
q=q->leftChild；
}else if（newNode->data>q->data）{
q=q->rightChild；
}否则{
我能不能试一下你的代码，它把列表打印得很好（仍然没有“重复”消息），但是当我观察我的局部变量时，没有任何东西保存在“p”中，因为没有任何内容保存在根中。树没有被准确地构造。你知道为什么吗？你在哪里声明
节点根
它是否说
节点根=nullptr
是的，我正在编辑我的原始帖子以添加我的构造函数，这样你就可以发布你的帖子了吗
q = p // I would do q = root;

while(q != nullptr) {
  if(newNode->data < q->data) {
    q = q->leftChild;
  } else if(newNode->data > q->data) {
    q = q->rightChild;
  } else {
    cout << "ERROR: item already exists";
    return 1;
  }
}