二叉树的初步实现

二叉树的初步实现，写了有一段时间了，先放出来，然后，有时间的话，会写图解以及注释的，如果有大神发现不足之处，希望可以帮我指出来，感激不尽！

//本程序的目的是利用链表实现二叉树，并且实现先序遍历，中序遍历，后序遍历
#include<iostream>
using namespace std;

//二叉树的结点
template<class T>
class BinaryTreeNode
{
public:
    BinaryTreeNode<T>* leftnode;            //左边的结点
    BinaryTreeNode<T>* rightnode;            //右边的结点
    T content;                                //结点中内容
};

//创建二叉树，利用递归从左到右创建，如果输入-1则表示该结点为空
//创建二叉树函数的模块的思路是在csdn上找到的思路，利用递归函数创建,
//关于创建二叉树也有三种递归的思路，分别为先序，中序，后序，每种算法输入时也会出现不同的储存结果
//这里一定要注意
//先序的思路
template<class T>
void PreCreatBinaryTree(BinaryTreeNode<T>*&head)
{
//------首先判断输入的内容是否为-1，如果为-1那么返回上一层
    //临时变量，用来储存输入的内容
    T linshi;
    cout << "请输入值：";
    cin >> linshi;
    if (linshi == -1)
    {
        //如果输入的是#号，那么当前指针指向空参数
        head = NULL;
    }
    //如果输入的不是#号，那么，做相应的操作
    else
    {
        //为当前head指针创建新的结点
        head = new BinaryTreeNode<T>;

        //为当前结点的内容赋值
        head->content = linshi;

        //用当前左儿子的结点作参数，再次调用CreatBinaryTree()函数
        CreatBinaryTree(head->leftnode);

        //用当前右儿子的结点做参数，再次调用CreatBianryTree()函数
        CreatBinaryTree(head->rightnode);
    }

}

//创建二叉树中序的思路
template<class T>
void InCreatBinaryTree(BinaryTreeNode<T>*&head)
{
    //T为临时变量，用来储存输入的值
    T linshi;
    cout << "请输入值：";
    cin >> linshi;
    //判断输入值是否为-1，如果为-1，那么当前结点的指针为空，返回上一层，如果不为-1，执行相应操作
    if (linshi == -1)
    {
        head = NULL;
        return;
    }
    //如果不为-1，执行相应的操作
    else
    {
        //为当前结点创建新的空间
        head = new BinaryTreeNode<T>;

        //以当前结点的左指针为参数，调用InCreatBinaryTree()函数
        InCreatBinaryTree(head->leftnode);

        //为当前结点赋值
        head->content = linshi;

        //以当前结点的右指针为参数，调用InCreatBinaryTree()函数
        InCreatBinaryTree(head->rightnode);

    }


}

//创建二叉树后序的思路
template<class T>
void PostCreatBinaryTree(BinaryTreeNode<T>*&head)
{
    //为当前结点分配新的内存s
    head = new BinaryTreeNode<T>;
    //临时变量，用来储存输入的值，如果为-1，那么当前结点为空，返回上一层,如果不为-1，执行相应操作
    T linshi;
    //输入数值
    cout << "请输入数值：";
    cin >> linshi;
    //如果输入值为-1，那么当前结点为空，返回上一层
    if (linshi == -1)
    {
        //设置当前结点为空
        head = NULL;
        //返回上一层
        return;

    }
    //如果不为空，那么执行相应操作
    else
    {
        //为当前结点创建新的内存空间
        head = new BinaryTreeNode<T>;
        //以当前结点的左结点为参数调用PostCreatBinarry()函数
        PostCreatBinaryTree(head->leftnode);
        //以当前结点的右结点为参数调用PostCreatBinarry()函数
        PostCreatBinaryTree(head->rightnode);
        //为当前结点的内容赋值
        head->content = linshi;

    }

}

//输出二叉树结点，利用递归，先序遍历
template<class T>
void PreorderTraversal(BinaryTreeNode<T>*head)
{
    if (head == NULL)
        return;
    else
    {
        //输出当前结点
        cout << head->content << " ";
        //以当前结点的左结点为参数，再次调用PrintBinaryTree()函数
        PreorderTraversal(head->leftnode);
        //以当前结点的右结点为参数，再次调用PrintBinaryTree()函数
        PreorderTraversal(head->rightnode);
    }

}

//输出二叉树结点，利用递归，中序遍历
template<class T>
void InorderTraversal(BinaryTreeNode<T>*head)
{
    if (head == NULL)
        return;
    else
    {
        //以当前结点的左结点为参数，调用InorderTraversal()函数
        InorderTraversal(head->leftnode);
        //输出当前结点的内容
        cout << head->content << " ";
        //以当前结点的右结点为参数，调用InorderTraversal()函数
        InorderTraversal(head->rightnode);
    }

}

//输出二叉树结点，利用递归，后序遍历
template<class T>
void PostorderTraversal(BinaryTreeNode<T>*head)
{
    //如果结点为空，返回上一层
    if (head == NULL)
        return;
    //如果不为空，执行相应的操作
    else
    {
        //以当前结点的左结点为参数，调用PostorderTraversal()函数
        PostorderTraversal(head->leftnode);
        //以当前结点的右结点为参数，调用PostorderTraversal()函数
        PostorderTraversal(head->rightnode);
        //输出当前结点的内容
        cout << head->content << " ";
    }

}

//销毁二叉树，利用递归，后序遍历(销毁是用后序遍历，如果用先序遍历或者中序遍历会使树断掉)
//关于销毁二叉树的函数让我十分惊喜，因为，他可以将头节点一并删除
template<class T>
void DestoryBinaryTree(BinaryTreeNode<T>* &head)
{
    //如果结点为空，返回上一层结点
    if (head == NULL)
        return;
    //如果结点不为空，执行相应操作
    else
    {
        //调试信息
        BinaryTreeNode<int>*head1 = head;

        //以当前结点的左结点为参数，调用DestoryBinaryTree()函数
        DestoryBinaryTree(head->leftnode);
        //以当前结点的右结点为参数，调用DestoryBinaryTree()函数
        DestoryBinaryTree(head->rightnode);
        //销毁当前结点
        delete head;
    }

}


//主函数
int main()
{
    BinaryTreeNode <int>*a = new BinaryTreeNode<int>;
    PostCreatBinaryTree(a);

    cout << "先序输出：";
    PreorderTraversal<int>(a);
    cout << endl;

    cout << "中序输出：";
    InorderTraversal<int>(a);
    cout << endl;
    
    cout << "后序输出：";
    PostorderTraversal<int>(a);
    cout << endl;

    //销毁二叉树
    DestoryBinaryTree<int>(a);


    //销毁新创建的二叉树结点
    //delete a;
    
    system("pause");
    return 0;
}