C++实现简单二叉树

二叉树是重要的数据结构， 这里用c++简单实现，暂时不考虑其增加、删除和修改。
二叉树在底层其实就是用数组存储，可以用数组实现二叉树
首先创建一个结构体，在其中存储指针以及数据，这个结构体作为二叉树的节点使用

template <class T>struct BinaryTreeNode   //定义节点{    BinaryTreeNode <T>* _left;    BinaryTreeNode <T>* _right;    T _data;    BinaryTreeNode(const T& data)        :_data(data)        ,_left(NULL)        ,_right(NULL)    {}};

然后就可以利用数组建立二叉树：

BinaryTree(T * a, size_t n, const T& invalid)  //创建二叉树，invalid为非法数据    {        size_t index = 0;        _root = CreateTree(a, n, invalid, index);    }Node* CreateTree(T *a, size_t n, const T& invalid, size_t& index)    {        Node * root = NULL;        if (index < n && a[index] != invalid)        {            root = new Node(a[index]);            root->_left = CreateTree(a, n, invalid, ++index);            root->_right = CreateTree(a, n, invalid, ++index);        }        return root;    }

建立二叉树之后就得实现它的遍历，前序、中序和后序遍历用递归可以实现（二叉树较小可以使用，数据量太大时递归容易栈溢出）。
前序遍历：
前序遍历先访问根节点，其次是左根，最后才是右根

如图，从根节点开始，先访问根节点，然后是其左子树的根节点，继续往左边访问左子树的子树，当遇到NULL时则已经是叶子节点，此时最小的左子树已经访问完毕，即图中a区访问完毕，接下来就是a区根节点的右子树即b区，访问完毕之后就该b区根节点的右子树了，如此类推。
在访问完a区之后，访问b区和c区时的逻辑和访问a区相同，可以用递归实现，代码如下：

void PrevOrder()//前序遍历    {        _PrevOrder(_root);        cout << endl;    }void _PrevOrder(Node* root)    {        if (NULL == root)            return;        cout << root->_data << " ";        _PrevOrder(root->_left);        _PrevOrder(root->_right);    }

中序遍历和后序遍历：
中序遍历和后序遍历的逻辑和前序遍历的逻辑相似，只是访问的顺序不同而已，代码见下：

void InOrder()//中序遍历    {        _InOrder(_root);        cout << endl;    }void PostOrder()//后序遍历    {        _PostOrder(_root);        cout << endl;    }void _InOrder(Node* root)    {        if (NULL == root)            return;        _InOrder(root->_left);        cout << root->_data << " ";        _InOrder(root->_right);    }void _PostOrder(Node* root)    {        if (NULL == root)            return;        _PostOrder(root->_left);        _PostOrder(root->_right);        cout << root->_data << " ";    }

层序遍历：
层序遍历需要用到队列实现，队列只能从队尾入队、从对头出队，先将根节点入队，然后在访问，访问之后就需要将其左根和右根分别入队，之后将对头的根节点删除，左根变为对头数据，取出访问再将其左右根节点分别入队，再删除头结点，拿出新的头结点访问……
整个过程逻辑相同，可以用一个循环就能实现，如下：

void LevlOrder()//层序遍历    {        _LevlOrder(_root);    }void _LevlOrder(Node* root)//层序遍历依靠队列实现    {        queue<Node*> q;        if (NULL != root)            q.push(root);        while (!q.empty())        {            Node* front = q.front();            cout << front->_data << " ";            if (NULL != front->_left)                q.push(front->_left);            if (NULL != front->_right)                q.push(front->_right);            q.pop();        }        cout << endl;    }

除了遍历，还要实现查找函数、求深度、叶子结点的个数、每层的个数等等接口，完整代码如下：

#pragma once#include <queue>#include<iostream>using namespace std;template <class T>struct BinaryTreeNode   //节点{    BinaryTreeNode <T>* _left;    BinaryTreeNode <T>* _right;    T _data;    BinaryTreeNode(const T& data)        :_data(data)        ,_left(NULL)        ,_right(NULL)    {}};template <class T>class BinaryTree       //二叉树{    typedef BinaryTreeNode <T> Node;public:    BinaryTree()        :_root(NULL)    {}    BinaryTree(T * a, size_t n, const T& invalid)//创建二叉树    {        size_t index = 0;        _root = CreateTree(a, n, invalid, index);    }    BinaryTree(const BinaryTree<T>& t)//拷贝构造函数    {        _root = _CopyBinaryTree(t._root);    }    //BinaryTree<T>& operator=(const BinaryTree<T>& t)//赋值运算符的重载    //{    //  if (this != &t)    //  {    //      Destory(_root); //释放旧空间    //      _root = _CopyBinaryTree(t._root);    //  }    //  return *this;    //}    BinaryTree<T>& operator=(BinaryTree<T>& t)//赋值运算符的重载    {        swap(_root, t._root);        return *this;    }    void PrevOrder()//前序遍历    {        _PrevOrder(_root);        cout << endl;    }    void InOrder()//中序遍历    {        _InOrder(_root);        cout << endl;    }    void PostOrder()//后序遍历    {        _PostOrder(_root);        cout << endl;    }    void LevlOrder()//层序遍历    {        _LevlOrder(_root);    }    Node* Find(const T& data)    {        return _Find(_root, data);    }    size_t Size()//节点数    {        return _Size(_root);    }    size_t LeafSize()//叶子结点数    {        return _LeafSize(_root);    }    size_t Depth()//深度    {        return _Depth(_root);    }    size_t GetKLevel(size_t k)//第k层的数据个数    {        return _GetKLevel(_root, k);    }    ~BinaryTree()    {        Destroy(_root);    }protected:    Node * CreateTree(T *a, size_t n, const T& invalid, size_t& index)    {        Node * root = NULL;        if (index < n && a[index] != invalid)        {            root = new Node(a[index]);            root->_left = CreateTree(a, n, invalid, ++index);            root->_right = CreateTree(a, n, invalid, ++index);        }        return root;    }    Node* _CopyBinaryTree(Node* root)    {        if (NULL == root)        {            return NULL;        }        Node* newRoot = new Node(root->_data);//拷贝根节点        newRoot->_left = _CopyBinaryTree(root->_left);        newRoot->_right = _CopyBinaryTree(root->_right);        return newRoot;    }    void Destroy(Node * root)    {        if (root == NULL)            return;        Destroy(root->_left);        Destroy(root->_right);        delete root;    }    void _PrevOrder(Node* root)    {        if (NULL == root)            return;        cout << root->_data << " ";        _PrevOrder(root->_left);        _PrevOrder(root->_right);    }    void _InOrder(Node* root)    {        if (NULL == root)            return;        _InOrder(root->_left);        cout << root->_data << " ";        _InOrder(root->_right);    }    void _PostOrder(Node* root)    {        if (NULL == root)            return;        _PostOrder(root->_left);        _PostOrder(root->_right);        cout << root->_data << " ";    }    void _LevlOrder(Node* root)//层序遍历依靠队列实现    {        queue<Node*> q;        if (NULL != root)            q.push(root);        while (!q.empty())        {            Node* front = q.front();            cout << front->_data << " ";            if (NULL != front->_left)                q.push(front->_left);            if (NULL != front->_right)                q.push(front->_right);            q.pop();        }        cout << endl;    }    Node* _Find(Node* root, const T& x)    {        if (NULL == root)            return 0;        if (x == root->_data)            return root;        Node* ret = _Find(root->_left, x);        if (ret)            return ret;        return _Find(root->_right, x);    }    size_t _Size(Node* root)    {        if (NULL == root)            return 0;        return _Size(root->_left) + _Size(root->_right) + 1;    }    size_t _LeafSize(Node* root)    {        if (NULL == root)            return 0;        if ((NULL == root->_left) || (NULL == root->_right))        {            return 1;        }        return _LeafSize(root->_left) + _LeafSize(root->_right);    }    size_t _Depth(Node* root)    {        if (NULL == root)            return 0;        if ((NULL == root->_left) && (NULL == root->_right))            return 1;        size_t left = _Depth(root->_left);        size_t right = _Depth(root->_right);        return left > right ? left + 1 : right + 1;    }    size_t _GetKLevel(Node* root, size_t k)    {        if (NULL == root)            return 0;        if (1 == k)            return 1;        return _GetKLevel(root->_left, k - 1) + _GetKLevel(root->_right, k - 1);    }protected:    Node * _root;};