数据结构：二叉树的基本实现

头文件：BinaryTree.h

#pragma once

template  						  // 二叉树的元素类型为elemType
class binaryTree 
{								                  // 二叉树的抽象数据类型
public:
	virtual int height() const = 0;				  // 二叉树的高度
	virtual int size() const = 0;				  // 二叉树的结点总数
	virtual void clear() = 0;					  // 清空
	virtual bool empty() const = 0;				  // 判空
	virtual void preOrderTraverse() const = 0;    // 前序遍历
	virtual void inOrderTraverse() const = 0;	  // 中序遍历
	virtual void postOrderTraverse() const = 0;	  // 后序遍历
	virtual void levelOrderTraverse() const = 0;  // 层次遍历
	virtual ~binaryTree() {};
};

 头文件：BinaryLinkedList.h

#pragma once
#include"BinaryTree.h"

template 
class BinaryLinkList :public binaryTree 
{
private:
    struct Node
    {
        Node* left, * right;							// 指向左、右孩子的指针
        elemType data;									// 结点的数据域
        Node()                                          // 无参构造函数
            : left(NULL)
            , right(NULL) 
        { }			
        Node(elemType value, Node* l = NULL, Node* r = NULL)
        {
            data = value; left = l; right = r;
        }
        ~Node() {}
    };

    Node* root;										      // 指向二叉树的根结点
    void clear(Node* t);                                  // 清空
    int size(Node* t) const;                              // 二叉树的结点总数
    int height(Node* t) const;                            // 二叉树的高度
    int leafNum(Node* t)const;                            // 二叉树的叶子数
    void preOrder(Node* t) const;						  // 递归前序遍历
    void inOrder(Node* t) const;						  // 递归中序遍历
    void postOrder(Node* t) const;						  // 递归后序遍历
    void preOrderCreate(elemType flag, Node*& t);		  // 注意t为引用 
public:
    BinaryLinkList() : root(NULL) {}						       // 构造空二叉树
    ~BinaryLinkList() { clear(); }                                 //析构函数
    bool empty() const { return root == NULL; }				       // 判空
    void clear() { if (root) clear(root); root = NULL; }           // 清空
    int size() const { return size(root); }					       // 二叉树的结点总数
    int height() const { return height(root); }				       // 二叉树的高度
    int leafNum()const { return leafNum(root); }				   // 二叉树的叶子数
    void preOrderTraverse() const { if (root) preOrder(root); }	   // 前序遍历 
    void inOrderTraverse() const { if (root) inOrder(root); }	   // 中序遍历
    void postOrderTraverse() const { if (root) postOrder(root); }  // 后序遍历
    void levelOrderTraverse() const;						       // 层次遍历
    void preOrderCreate(elemType flag) { 		                   // 利用带外部结点的前序序列创建二叉树
        preOrderCreate(flag, root);
    }

};

template 
void BinaryLinkList::clear(Node* t)
{
   
    if (root == nullptr)
    {
        return;
    }
    clear(t->left);
    clear(t->right);
    delete t;

}

template 
int BinaryLinkList::size(Node* t) const
{
    return t == nullptr ? 0 :
        size(t->left) +
        size(t->right) + 1;

}
template 
int BinaryLinkList::height(Node* t) const
{
    
    if (t == nullptr)
    {
        return 0;
    }

    int LeftHeight = height(t->left);
    int RightHeight = height(t->right);

    return LeftHeight > RightHeight ? LeftHeight + 1 : RightHeight + 1;

    
}
template 
int BinaryLinkList::leafNum(Node* t)const
{
    

    if (t == nullptr)
    {
        return 0;
    }
    if (t->left == nullptr
        && t->right == nullptr)
    {
        return 1;
    }

    return leafNum(t->left) +
        leafNum(t->right);
    
}
template 
void BinaryLinkList::preOrder(Node* t) const
{
    
    if (t == nullptr)
    {
        return;
    }
    cout << t->data << " ";
    preOrder(t->left);
    preOrder(t->right);


    
}
template 
void BinaryLinkList::inOrder(Node* t) const
{
    
    if (t)
    {
        inOrder(t->left);
        cout << t->data << " ";
        inOrder(t->right);
    }

    
}
template 
void BinaryLinkList::postOrder(Node* t) const
{
    
    if (t)
    {
        preOrder(t->left);
        preOrder(t->right);
        cout << t->data << " ";
    }

   
}
template 
void BinaryLinkList::levelOrderTraverse() const
{
    queue que;							// 使用STL中的队列
    Node* p = root;
   
    if (p)
    {
        que.push(p);
    }

    while (!que.empty())
    {
        p = que.front();
        que.pop();
        cout << p->data << " ";
        if (p->left)
        {
            que.push(p->left);
        }
        if (p->right)
        {
            que.push(p->right);
        }
    }

   
}
template 
void BinaryLinkList::preOrderCreate(elemType flag, Node*& t)
{ 
    //按带外部结点的前序序列构造二叉链表表示的二叉树
    elemType value;
    cin >> value;
    cout << value;
    if (value != flag)						// 递归出口value==flag
    {
        t = new Node(value);
        preOrderCreate(flag, t->left);
        preOrderCreate(flag, t->right);

       
    }
}