二叉树的建立、遍历以及一些简单的操作

需要完成的操作

1、前序遍历

前序：先访问根结点，再前序遍历左子树，后前序遍历右子树（采用了递归）

2、运用前序遍历产生的数组建立一个二叉树

3、中序遍历

中序：先访问左子树，再访问根结点，最后访问右子树

4、后序遍历

后序：先访问左子树，再访问右子树，最后访问根结点。

5、层次遍历

以层位单位，输出每一层中的结点。（运用到了队列的知识，用队列来存储结点信息）

6、计算叶结点的个数

7、计算所有结点的个数

8、计算树的高度

9、计算树中第k层的结点个数

上述问题的代码实现

该代码中运用了较多的递归。

#include<iostream>
#include<queue>
using namespace std;
typedef struct node
{
    struct node* left;
    struct node* right;
    char data;
}node;
class tree
{
private:
    node* root;
public:
    node* Createtree( char*s, int& i);//建树
    void preorder(node* tool);    
    void preorder();//前序遍历
    tree(char* s, int& i);
    void inorder(node* tool);
    void inorder();//中序遍历
    void lastorder(node* tool);
    void lastorder();//后序遍历
    void lvlorder();//层次遍历
    int LeftNumber(node* a);//计算叶子结点的个数
    void LeftNumber();//计算叶子结点的个数
    int NodeNumber(node* a);//计算结点的个数
    void NodeNumber();//计算结点的个数
    int TreeHeight(node*a);//计算树的高度
    void TreeHeight();//计算树的高度
    int KNumbers(int k, node* a);//求二叉树第k层的结点个数
    void KNumbers(int k);//求二叉树第k层的结点个数

};
node* tree::Createtree( char* s, int& i)
{
    node* NODE = NULL;
    if (s[i] != '#')
    {
        NODE = new node;
        NODE->data = s[i];
        NODE->left = Createtree(s, ++i);
        NODE->right = Createtree(s, ++i);
    }
    return NODE;
}
tree::tree(char* s, int& i)
{
    root = new node();
    root = Createtree(s, i);
}
void tree::preorder(node*tool)
{
    if (tool == NULL)
    {
        return;
    }
    else
    {
        cout << tool->data << '\t';
        preorder(tool->left);
        preorder(tool->right);
    }
}
void tree::preorder()
{
    preorder(root);
    cout << endl;
}
void tree::inorder(node* tool)
{
    if (tool == NULL)
    {
        return;
    }
    else
    {
        inorder(tool->left);
        cout << tool->data << '\t';
        inorder(tool->right);
    }
}
void tree::inorder()
{
    inorder(root);
    cout << endl;
}
void tree::lastorder(node* tool)
{
    if (tool == NULL)
    {
        return;
    }
    else
    {
        lastorder(tool->left);
        lastorder(tool->right);
        cout << tool->data << '\t';
    }

}
void tree::lastorder()
{
    lastorder(root);
    cout << endl;
}
void tree::lvlorder()
{
    queue<node*> q;
    q.push(root);
    while (!q.empty())
    {
        node* tool = q.front();
        q.pop();
        cout << tool->data << '\t';
        if (tool->left!= NULL)
        {
            q.push(tool->left);
        }
        if (tool->right != NULL)
        {
            q.push(tool->right);
        }
    }
    cout << endl;
}
int tree::LeftNumber(node *a)
{
    if (a == NULL)
    {
        return 0;
    }
    else if (a->left == NULL && a->right == NULL)
    {
        return 1;
    }
    return LeftNumber(a->left) + LeftNumber(a->right);
}
void tree::LeftNumber()
{
    cout << "叶子结点的个数为："<<LeftNumber(root)<<endl;
}
int tree::NodeNumber(node* a)
{
    if (a == NULL)
    {
        return 0;
    }
    else
    {
        return NodeNumber(a->left) + NodeNumber(a->right)+1;
    }
}
void tree::NodeNumber()
{
    cout << "树的结点个数为：" << NodeNumber(root) << endl;
}
int tree::TreeHeight(node* a)
{
    if (a == NULL)
    {
        return 0;
    }
    return TreeHeight(a->left) > TreeHeight(a->right) ? TreeHeight(a->left) + 1 : TreeHeight(a->right) + 1;
}
void tree::TreeHeight()
{
    cout << "树的高度为：" << TreeHeight(root) << endl;
}
int tree::KNumbers(int k, node* a)
{
    if (a == NULL)
    {
        return 0;
    }
    else if (k == 1)
    {
        return 1;
    }
    else
    {
        return KNumbers(k - 1, a->left) + KNumbers(k - 1, a->right);
    }
}
void tree::KNumbers(int k)
{
    if (k > TreeHeight(root))
    {
        cout << "输入的层数不存在" << endl;
        return;
    }
    cout << "第" << k << "层共有" << KNumbers(k, root) << "个结点" << endl;
}
int main()
{
    char s[20] = {"AB#DG##H##IJL####"};
    int i = 0;
    tree test(s, i);
    test.preorder();
    test.inorder();
    test.lastorder();
    test.lvlorder();
    test.LeftNumber();
    test.NodeNumber();
    test.TreeHeight();
    test.KNumbers(4);
    return 0;
}