C++实现简单二叉树

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;
};
  • 21
    点赞
  • 73
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值