数学结构之二叉树学习

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

template <class T>
struct TreeNode
{
    T tvalue;
    TreeNode<T> *lChild, *rChild; //左子树与右子树

    TreeNode(T Nodevalue = 0, TreeNode<T> *leftnode = NULL, TreeNode<T> *rightnode = NULL) \
        : tvalue(Nodevalue), lChild(leftnode), rChild(rightnode)
    {

    }
};

//创建二叉树
template <class T>
bool CreateBinaryTree(TreeNode<T> *&root) //传递指针的引用
{
    T newvalue;
    cout << "input newvalue:";
    cin >> newvalue;
    if (newvalue == -1)
    {
        root = NULL;
    }
    else
    {
        root = new TreeNode<T>;
        root->tvalue = newvalue;
        CreateBinaryTree(root->lChild); //递归创建左右子树
        CreateBinaryTree(root->rChild);
    }
    return true;
}

//二叉树先序遍历
//1.访问根结点
//2.先序遍历左子树
//3.先序遍历右子树
template <class T>
void preOder(TreeNode<T> *&root)
{
    if (root)
    {
        cout << root->tvalue << "  ";
        preOder(root->lChild);
        preOder(root->rChild);
    }
}

//二叉树中序遍历
// 1. 中序遍历左子树
// 
// 2. 访问根结点
// 
// 3.  中序遍历右子树
template <class T>
void inOrder(TreeNode<T> *&root)
{
    if (root)
    {
        inOrder(root->lChild);
        cout << root->tvalue << "  ";
        inOrder(root->rChild);
    }
}

//二叉树后序遍历
// 1. 后序遍历左子树
// 
// 2. 后序遍历右子树
// 
// 3.  访问根结点

template <class T>
void postorder(TreeNode<T> *&root)
{
    if (root)
    {
        postorder(root->lChild);
        postorder(root->rChild);
        cout << root->tvalue << "  ";
    }
}

//统计二叉中的结点数
template <class T>
int countNode(TreeNode<T> *&root)
{
    if (root == NULL)
    {
        return 0;
    }
    return 1 + countNode(root->lChild) + countNode(root->rChild);
}

//求二叉树的深度 
template <class T>
int depth(TreeNode<T> *&root)
{
    if (root == NULL)
    {
        return -1;
    }
    int h1 = depth(root->lChild);
    int h2 = depth(root->rChild);
    if (h1 > h2)
    {
        return h1 + 1;
    }
    return h2 + 1;
}

//二叉树的销毁操作
template <class T>
void destory(TreeNode<T> *&root)
{
    if (root)
    {
        destory(root->lChild);
        destory(root->rChild);

        delete root;

        root = NULL;
    }
}

//横向打印的好处是规避命令界面一行多个字符的缩进问题，每行只用控制一个数字的缩进
//按树状结构打印二叉树
//先打印右子树，打印完右子树，打印本结点，再打印左子树
template <class T>
void printfTree(TreeNode<T> *&root, int nLayer)
{
    if (root == NULL)
    {
        return;
    }
    printfTree(root->rChild, nLayer + 3);
    for (int i = 0; i < nLayer; i++)
    {
        cout << " ";
    }
    cout << root->tvalue << endl;
    printfTree(root->lChild, nLayer + 3);
}

int _tmain(int argc, _TCHAR* argv[])
{
    TreeNode<int> *root;
    CreateBinaryTree(root);
    cout << "先序遍历:"; preOder(root); cout << endl;
    cout << "中序遍历:"; inOrder(root); cout << endl;
    cout << "后序遍历:"; postorder(root); cout << endl;
    cout << "树的结点数:" << countNode(root) << endl;
    cout << "树的深度:" << depth(root) << endl;
    cout << "销毁二叉树" << endl;
    destory(root);
	return 0;
}