最新公告
  • 欢迎您光临波比源码,本站秉承服务宗旨 履行“站长”责任,销售只是起点 服务永无止境!立即加入我们
  • 算法与数据结构基础4:C++二叉树实现及遍历方法大全

    binary search tree,中文翻译为2叉搜索树、2叉查找树或2叉排序树。简称为BST。

    本文集齐了2叉树的5大遍历算法:先序遍历、中序遍历、后序遍历、深度优先遍历和广度优先遍历(同层遍历也就是深度优先遍历)。

    // BSTree.h

    #include <cstdio>
    #include <iostream>
    #include <stack>
    #include <queue>

    using namespace std;

    // binary search tree,中文翻译为2叉搜索树、2叉查找树或2叉排序树。简称为BST
    class BSTree
    {
    struct Node{
    Node(int x = 0):data(x), lchild(NULL), rchild(NULL){}
    struct Node* lchild;
    struct Node* rchild;
    int data;
    };

    public:
    // **************************************************************************
    // 类的4大函数:构造函数、拷贝构造函数、重载赋值运算符、析构函数
    // **************************************************************************
    BSTree();
    ~BSTree();

    // **************************************************************************
    // 增删改查
    // **************************************************************************
    void Insert(int x);

    // 返回2叉树的个数
    unsigned short Size();
    unsigned short Deep();
    unsigned short Leaf();

    bool IsEmpty();

    // 遍历
    void PreorderTraversal(); // 先序遍历
    void InorderTraversal(); // 中序遍历
    void PostorderTraversal(); // 后序遍历
    void DepthFirstSearch(); // 深度优先遍历
    void BreadthFirstSearch(); // 广度优先遍历

    private:
    // 递归计算2叉树个数
    unsigned short CountSize(Node* n);
    unsigned short CountDeep(Node* n);
    unsigned short CountLeaf(Node* n);

    // 递归遍历
    void PreorderTraversal(Node* n);
    void InorderTraversal(Node* n);
    void PostorderTraversal(Node* n);
    void DepthFirstSearch(Node* n);
    void BreadthFirstSearch(Node* n);

    void Free(Node* node);
    private:
    Node* m_root;
    };

    // **************************************************************************
    // 私有方法
    // **************************************************************************
    unsigned short BSTree::CountSize(Node* n)
    {
    if(!n){
    return 0;
    }

    return CountSize(n->lchild) + CountSize(n->rchild) + 1;
    }

    unsigned short BSTree::CountDeep(Node* n)
    {
    if (!n) {
    return 0;
    }
    int ldeep = CountDeep(n->lchild);
    int rdeep = CountDeep(n->rchild);
    return ( ldeep > rdeep ) ? (ldeep + 1) : (rdeep + 1);
    }

    unsigned short BSTree::CountLeaf(Node* n)
    {
    if (!n){
    return 0;
    }
    if (!n->lchild&& !n->rchild){
    return 1;
    }
    return CountLeaf(n->lchild) + CountLeaf(n->rchild);
    }

    void BSTree::PreorderTraversal(Node* n)
    {
    if (n) {
    cout << n->data << ",";
    PreorderTraversal(n->lchild);
    PreorderTraversal(n->rchild);
    }
    }

    void BSTree::InorderTraversal(Node* n)
    {
    if (n) {
    InorderTraversal(n->lchild);
    cout << n->data << ",";
    InorderTraversal(n->rchild);
    }
    }

    void BSTree::PostorderTraversal(Node* n)
    {
    if (n) {
    PostorderTraversal(n->lchild);
    PostorderTraversal(n->rchild);
    cout << n->data << ",";
    }
    }

    void BSTree::DepthFirstSearch(Node* root)
    {
    stack<Node *> nodeStack;
    nodeStack.push(root);
    Node* node = NULL;
    while(!nodeStack.empty()){
    node = nodeStack.top();
    cout << node->data << ",";
    nodeStack.pop();
    if (node->rchild) {
    nodeStack.push(node->rchild);
    }
    if (node->lchild) {
    nodeStack.push(node->lchild);
    }
    }
    }

    void BSTree::BreadthFirstSearch(Node* root)
    {
    queue<Node *> nodeQueue;
    nodeQueue.push(root);
    Node* node = NULL;
    while(!nodeQueue.empty()){
    node = nodeQueue.front();
    nodeQueue.pop();
    cout << node->data << ",";
    if (node->lchild) {
    nodeQueue.push(node->lchild);
    }
    if (node->rchild) {
    nodeQueue.push(node->rchild);
    }
    }
    }

    void BSTree::Free(Node* n)
    {
    if (n) {
    Free(n->lchild);
    Free(n->rchild);
    delete n;
    n = NULL;
    }
    }

    // **************************************************************************
    // 类的4大函数:构造函数、拷贝构造函数、重载赋值运算符、析构函数
    // **************************************************************************
    BSTree::BSTree()
    {
    m_root = NULL;
    }

    BSTree::~BSTree()
    {
    Free(m_root);
    }

    // **************************************************************************
    // 增删改查
    // **************************************************************************
    void BSTree::Insert(int x)
    {
    Node* tmp = new Node(x);
    if (!m_root){
    m_root = tmp;
    }
    else{
    Node* pre = m_root;
    Node* cur = m_root;
    while (cur){
    pre = cur;
    cur = (x < cur->data) ? (cur->lchild) : (cur->rchild);
    }
    (x < pre->data) ? (pre->lchild = tmp) : (pre->rchild = tmp);
    }
    }

    unsigned short BSTree::Size()
    {
    return CountSize(m_root);
    }

    unsigned short BSTree::Deep()
    {
    return CountDeep(m_root);
    }

    unsigned short BSTree::Leaf()
    {
    return CountLeaf(m_root);
    }

    bool BSTree::IsEmpty()
    {
    return m_root == NULL;
    }

    void BSTree::PreorderTraversal()
    {
    PreorderTraversal(m_root);
    cout << endl;
    }

    void BSTree::InorderTraversal()
    {
    InorderTraversal(m_root);
    cout << endl;
    }

    void BSTree::PostorderTraversal()
    {
    PostorderTraversal(m_root);
    cout << endl;
    }

    void BSTree::DepthFirstSearch()
    {
    DepthFirstSearch(m_root);
    cout << endl;
    }

    void BSTree::BreadthFirstSearch()
    {
    BreadthFirstSearch(m_root);
    cout << endl;
    }

    // mian.cpp

    // test for BSTree
    #include "BSTree.h"
    #include <cstdlib>
    #include <iostream>

    using namespace std;

    int main()
    {
    BSTree tree;
    int arr[6] = {5, 4, 8, 1, 7, 10};
    for (int i = 0; i < 6; ++i){
    tree.Insert(arr[i]);
    }

    tree.PreorderTraversal();
    tree.InorderTraversal();
    tree.PostorderTraversal();
    tree.DepthFirstSearch();
    tree.BreadthFirstSearch();

    cout << "size:" << tree.Size() << endl;
    cout << "deep:" << tree.Deep() << endl;
    cout << "leaf:" << tree.Leaf() << endl;

    system("pause");
    return 0;
    }

    // 输出截图

    波比源码 – 精品源码模版分享 | www.bobi11.com
    1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
    2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
    3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
    4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
    5. 如有链接无法下载、失效或广告,请联系管理员处理!
    6. 本站资源售价只是赞助,收取费用仅维持本站的日常运营所需!
    7. 如遇到加密压缩包,请使用WINRAR解压,如遇到无法解压的请联系管理员!

    波比源码 » 算法与数据结构基础4:C++二叉树实现及遍历方法大全

    常见问题FAQ

    免费下载或者VIP会员专享资源能否直接商用?
    本站所有资源版权均属于原作者所有,这里所提供资源均只能用于参考学习用,请勿直接商用。若由于商用引起版权纠纷,一切责任均由使用者承担。更多说明请参考 VIP介绍。
    提示下载完但解压或打开不了?
    最常见的情况是下载不完整: 可对比下载完压缩包的与网盘上的容量,若小于网盘提示的容量则是这个原因。这是浏览器下载的bug,建议用百度网盘软件或迅雷下载。若排除这种情况,可在对应资源底部留言,或 联络我们.。
    找不到素材资源介绍文章里的示例图片?
    对于PPT,KEY,Mockups,APP,网页模版等类型的素材,文章内用于介绍的图片通常并不包含在对应可供下载素材包内。这些相关商业图片需另外购买,且本站不负责(也没有办法)找到出处。 同样地一些字体文件也是这种情况,但部分素材会在素材包内有一份字体下载链接清单。
    波比源码
    一个高级程序员模板开发平台
    升级波友尊享更多特权立即升级