C++模板二叉排序树

什么是二叉查找树：

根节点的值大于其左子树中任意一个节点的值，小于其右节点中任意一节点的值，这一规则适用于二叉查找树中的每一个节点。以下是实现过程，不知是否有bug，刚写完就给上传到了知乎。
以下是代码，看了很多人的总是感觉不是我想要的感觉于是自己写一个。
如有错误请指正

#pragma once
#include"预编译.h"

using namespace std;

template<typename T>
struct TreeNode {
	T val;

	TreeNode* left;

	TreeNode* right;

	TreeNode() :val(default(T)), left(NULL), right(NULL) {

	}

	TreeNode(T val) :val(val),left(NULL), right(NULL) {

	}
};

template<typename T>
class  BinaryTree {

private:
	TreeNode<T>* root;

	queue<TreeNode<T>*> queen_BinaryTree;

public:

	BinaryTree()//默认的构造函数
	{

	}

	BinaryTree(T val)//带参数的构造函数
	{
		root = new TreeNode<T>(val);
	}

	BinaryTree(const BinaryTree<T>& A)
	{
		root = A;
	}

	bool IsEmpty()
	{
		if (root == NULL)
		{
			return true;
		}

		return false;
	}

	bool IsExist(T val)
	{
		return FindTree(root, val);
	}

	bool FindTree(TreeNode<T>* root, T val)
	{
		if (root == NULL)
		{
			return false;
		}

		if (root->val == val)
		{
			return true;
		}

		if (root->val > val)
		{
			return FindTree(root->left, val);
		}
		else
		{
			return FindTree(root->right, val);
		}
	}

	void AddTreeNode(T val)
	{
		AddFindTree(root, val);

		return;
	}

	TreeNode<T>* AddFindTree(TreeNode<T>* root, T val)
	{
		if (root == NULL)
		{
			TreeNode<T>* temp = new TreeNode<T>(val);

			std::cout << val << "  "<< temp->val <<"   ";

			return temp;
		}

		if (root->val > val)
		{
			root->left = AddFindTree(root->left, val);
		}

		else
		{
			root->right = AddFindTree(root->right, val);
		}

		return root;
	}

	void DeleteTreeNode(T val)
	{
		root = deleteTreeNode(root,val);
	}

	TreeNode<T>* deleteTreeNode(TreeNode<T>* root, T val)
	{
		if (root == NULL)
		{
			return NULL;
		}

		std::cout << root->val << " ** "<<val<<"     ";

		if (root->val == val)
		{
			return deleteNode(root);
		}

		if (root->val > val)
		{
			root->left = deleteTreeNode(root->left, val);
		}
		else
		{
			root->right = deleteTreeNode(root->right, val);
		}

		return root;
	}

	TreeNode<T>* deleteNode(TreeNode<T>* root)
	{

		TreeNode<T>* tmp1, * tmp2;

		if (root->left == NULL && root->right == NULL)
		{
			tmp1 = root;

			root = root->left;

			delete(tmp1);
		}

		else if (root->left == NULL && root->right != NULL)
		{
			tmp1 = root;

			root = root->right;

			delete(tmp1);
		}
		else if (root->right == NULL && root->left != NULL)
		{
			tmp1 = root;

			root = root->left;

			delete(tmp1);
		}
		else
		{
			tmp1 = root;

			tmp2 = root->left;

			while (tmp2->right)
			{
				tmp1 = tmp2;

				tmp2 = tmp2->right;
			}

			root->val = tmp2->val;

			if (root != tmp1)
			{
				tmp1->right = tmp2->left;
			}
			else
			{
				tmp1->left = tmp2->right;
			}

			delete(tmp2);
		}

		return root;
	}

	//二叉树的前序遍历
	void Preorder_Traversal()
	{
		preorder_Traversal(root);
	}

	void preorder_Traversal(TreeNode<T>* root)
	{
		if (root == NULL)
		{
			return;
		}

		std::cout << root->val << "  ";

		preorder_Traversal(root->left);

		preorder_Traversal(root->right);
	}

	//二叉树的中序遍历
	void  Middle_Order_Traversal()
	{
		middle_Order_Traversal(root);
	}
	void middle_Order_Traversal(TreeNode<T>* root)
	{
		if (root == NULL)
		{
			return;
		}

		middle_Order_Traversal(root->left);

		std::cout << root->val << "   ";

		middle_Order_Traversal(root->right);
	}

	//二叉树的后序遍历
	void  Postorder_Traversal()
	{
		postorder_Traversal(root);
	}
	void postorder_Traversal(TreeNode<T>* root)
	{
		if (root == NULL)
		{
			return;
		}

		postorder_Traversal(root->left);

		postorder_Traversal(root->right);

		std::cout << root->val << "   ";
	}

	//层序遍历
	void Level_Traversal()
	{
		if (root == NULL)
		{
			return;
		}

		queen_BinaryTree.push(root);

		while (!queen_BinaryTree.empty())
		{
			TreeNode<T>* tmp = queen_BinaryTree.front();

			std::cout << tmp->val << "  ";

			queen_BinaryTree.pop();

			if (tmp->left != NULL)
			{
				queen_BinaryTree.push(tmp->left);
			}
			else if (tmp->right != NULL)
			{
				queen_BinaryTree.push(tmp->right);
			}
		}

	}
};



// 数据结构.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include "预编译.h"
#include"二叉树.h"
using namespace std;
int main()
{
    int val = 50;

    BinaryTree<int>* root = new BinaryTree<int>(val);

    root->AddTreeNode(46);

    root->AddTreeNode(55);

    root->AddTreeNode(56);

    root->AddTreeNode(100);

    root->AddTreeNode(15);

    root->AddTreeNode(45);

    std::cout << "---------------------------" << endl;
    std:; cout << endl;

    root->Middle_Order_Traversal();
    std::cout << endl;

    root->Preorder_Traversal();
    std::cout << endl;
    root->Postorder_Traversal();
    std::cout << endl;

    root->IsExist(100);

    root->DeleteTreeNode(100);

    root->Preorder_Traversal();


    BinaryTree<int>* tmp2(root);

    tmp2->Preorder_Traversal();

    std::cout << "Hello World!\n";
}