[数据结构] 二叉树

数据结构的练习与巩固
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
using namespace std;

struct BTNode
{
    char Data;
    BTNode* lChild, * rChild;
    BTNode()
    {
        lChild = NULL;
        rChild = NULL;
    }
    BTNode(char& data, BTNode* l = NULL, BTNode* r = NULL)
    {
        Data = data;
        lChild = l;
        rChild = r;
    }
};

class BT
{
public:
    BTNode* root;
    char RefValue;

public:
    BT() { root = NULL; }
    BT(char value)
        { RefValue = value, root = NULL; }

    BTNode* lChild(BTNode* t)
        { return(t != NULL) ? t->lChild : NULL; }
    BTNode* rChild(BTNode* t)
        { return(t != NULL) ? t->lChild : NULL; }
    BTNode*& getRoot()
        { return root; }

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

    void preOrder(BTNode*& subTree)
    {
        if (subTree != NULL)
        {
            cout << subTree->Data << ' ';
            preOrder(subTree->lChild);
            preOrder(subTree->rChild);
        }
    }
    void inOrder(BTNode*& subTree)
    {
        if (subTree != NULL)
        {
            inOrder(subTree->lChild);
            cout << subTree->Data << ' ';
            inOrder(subTree->rChild);
        }
    }
    void postOrder(BTNode*& subTree)
    {
        if (subTree != NULL)
        {
            postOrder(subTree->lChild);
            postOrder(subTree->rChild);
            cout << subTree->Data << ' ';
        }
    }

    void createBT(BTNode*& subTree)
    {
        char ch;
        cin >> ch;
        if (ch == RefValue)subTree = NULL;
        else
        {
            subTree = new BTNode(ch);
            createBT(subTree->lChild);
            createBT(subTree->rChild);
        }
    }
    
    void size(BTNode*& subTree, int& count)
    {
        if (subTree != NULL)
        {
            count++;
            size(subTree->lChild, count);
            size(subTree->rChild, count);
        }
        else
            return;
    }

    void leaf(BTNode*& subTree, int& count)
    {
        if (subTree != NULL)
        {
            if (subTree->lChild == NULL && subTree->rChild == NULL)
            {
                count++;
                return;
            }
            else
            {
                leaf(subTree->lChild, count);
                leaf(subTree->rChild, count);
            }
        }

        else return;
    }

    void IsBST(BTNode*& subTree, int& Flag)
    {
        if (subTree != NULL)
        {
            if (subTree->lChild == NULL && subTree->lChild == NULL)
            {
                return;
            }

            if (subTree->lChild == NULL)
            {
                if (subTree->rChild->Data < subTree->Data) Flag = 0;
                IsBST(subTree->rChild, Flag);
            }

            if (subTree->rChild == NULL)
            {
                if (subTree->lChild->Data > subTree->Data) Flag = 0;
                IsBST(subTree->lChild, Flag);
            }

            else
            {
                if (subTree->lChild->Data > subTree->Data) Flag = 0;
                if (subTree->rChild->Data < subTree->Data) Flag = 0;

                IsBST(subTree->lChild, Flag);
                IsBST(subTree->rChild, Flag);
            }
        }
    }

    void height(BTNode*& subTree, char X, int& Height)
    {
        if (subTree != NULL)
        {
            if (subTree->Data == X)
            {
                return;
            }
            else if (subTree->Data > X)
            {
                Height++;
                height(subTree->lChild, X, Height);
            }
            else if (subTree->Data < X)
            {
                Height++;
                height(subTree->rChild, X, Height);
            }
        }
    }
};

int main()
{
    int c1 = 0;
    int c2 = 0;
    int Height = 1;
    int Flag = 1;
    BT t('#');
    t.createBT(t.getRoot());

    cout << endl << "前序遍历" << endl;
    t.preOrder(t.getRoot());
    cout << endl << "中序遍历" << endl;
    t.inOrder(t.getRoot());
    cout << endl << "后序遍历" << endl;
    t.postOrder(t.getRoot());

    t.size(t.getRoot(), c1);
    cout << endl << "结点个数：" << c1 << endl;
    t.leaf(t.getRoot(), c2);
    cout << endl << "叶子个数：" << c2 << endl;

    t.IsBST(t.getRoot(), Flag);
    if (Flag) cout << "是排序树" << endl;
    else cout << "非排序树" << endl;

    char X;
    cin >> X;
    t.height(t.getRoot(), X, Height);
    cout << endl << "当前高度：" << Height << endl;
}