数据结构实训（三）--- 在二叉树中判断是否存在值为x的结点

以二叉链表为存储结构，编写算法判断二叉树中是否存在值为x的结点。

【输入形式】两行，第一行是扩展二叉树的前序遍历序列，第二行是待查询结点x
【输出形式】如果结点x存在，则输出"YES"；否则输出“NO”。
【样例输入】AB#D##C##
D
【样例输出】
YES

main.cpp文件：

#include <iostream>
#include"BiTree.h"
using namespace std;

int main()
{
    BiTree<char> t;
    char ch;
    cin >> ch;
    if(t.ExistX(ch)){
        cout<<"YES";
    }
    else{
        cout<<"NO";
    }
}

BiTree.h文件（包含前中后序遍历）：

#ifndef BITREE_H_INCLUDED
#define BITREE_H_INCLUDED
using namespace std;
//定义结点
template <typename DataType>
struct BiNode
{
    DataType  data;
    BiNode<DataType> *lchild,*rchild;
};

template <typename DataType>
class BiTree
{
public :
    // 构建函数，建立一颗二叉树
    BiTree()
    {
        root = Creat();
    }

    // 析构函数，释放格结点的存储空间
    ~BiTree()
    {
        Release(root);
    }

    // 前序遍历二叉树
    void PreOrder()
    {
        PreOrder(root);
    }

    // 中序遍历二叉树
    void InOrder()
    {
        InOrder(root);
    }

    // 后序遍历二叉树
    void PostOrder()
    {
        PostOrder(root);
    }

    // 判断数中是否存在X
    bool ExistX(DataType x)
    {
        return ExistX(root, x);
    }
private:
    BiNode<DataType> * Creat();
    void Release(BiNode<DataType> *bt);
    void PreOrder(BiNode<DataType> *bt);
    void InOrder(BiNode<DataType> *bt);
    void PostOrder(BiNode<DataType> *bt);
    bool ExistX(BiNode<DataType> *bt, DataType x);
    BiNode<DataType> *root;

};

// 构建函数，建立一颗二叉树
template <typename DataType>
BiNode<DataType> *BiTree<DataType>::Creat()
{
    BiNode<DataType>* bt;
    char ch;
    cin>>ch;                    // 输入结点的数据信息
    if(ch == '#')
        bt=nullptr;    // 建立一棵空树
    else
    {
        bt = new BiNode<DataType>;
        bt->data = ch;
        bt->lchild = Creat();   // 递归建立左子树
        bt->rchild = Creat();   // 递归建立右子树
    }
    return bt;
}

// 析构函数，释放格结点的存储空间
template <typename DataType>
void BiTree<DataType> ::Release(BiNode<DataType> * bt)
{
    if(bt == nullptr)
        return;
    else
    {
        Release(bt ->lchild);
        Release(bt->rchild);
        delete bt;
    }
}

// 前序遍历二叉树
template <typename DataType>
void BiTree<DataType> :: PreOrder(BiNode<DataType> * bt)
{
    if(bt == nullptr)
        return ;
    else
    {
        cout<<bt->data;
        PreOrder(bt->lchild);
        PreOrder(bt->rchild);
    }
}

// 中序遍历二叉树
template <typename DataType>
void BiTree<DataType> :: InOrder(BiNode<DataType> * bt)
{
    if(bt == nullptr)
        return ;
    else
    {
        InOrder(bt->lchild);
        cout<<bt->data;
        InOrder(bt->rchild);
    }
}

// 后序遍历二叉树
template <typename DataType>
void BiTree<DataType> :: PostOrder(BiNode<DataType> * bt)
{
    if(bt == nullptr)
        return ;
    else
    {
        PostOrder(bt->lchild);
        PostOrder(bt->rchild);
        cout<<bt->data;
    }
}

// 判断是否存在X
template <typename DataType>
bool BiTree<DataType> :: ExistX(BiNode<DataType> * bt, DataType x)
{
    if(bt == nullptr)
        return false;
    else if(bt->data == x)
    {
        return true;
    }
    else
    {
        if(ExistX(bt->lchild, x))
            return true;
        if(ExistX(bt->rchild, x))
            return true;
    }
    return false;
}

#endif // BITREE_H_INCLUDED