二叉树的递归和非递归

最新推荐文章于 2022-11-05 17:00:50 发布
最新推荐文章于 2022-11-05 17:00:50 发布
阅读量267 收藏 1
点赞数 1
分类专栏： C++ 文章标签： 二叉树 递归 非递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aisheng_huo/article/details/71731540
版权

二叉树

递归 非递归

递归版本

构造一颗二叉树

代码
   Node* _CreatTree(T* a, size_t n, const T& invalid, size_t& index)
   {
       assert(NULL != a && n > 0);
       Node* root = NULL;
       if (index < n && a[index] != invalid)
       {
           root = new Node(a[index]);
           root->_Lchild = _CreatTree(a, n, invalid, ++index);
           root->_Rchild = _CreatTree(a, n, invalid, ++index);
       }
       return root;
   }

中序创建一颗树，碰到invalid就返回，先构造根节点，构造左子树，构造右子树

图示

CreatTree

先序遍历

代码
   void  _PreOder(Node* root)
   {
       if (NULL == root){return;}
       cout<<root->_data<<" ";
       _PreOder(root->_Lchild);
       _PreOder(root->_Rchild);
   }
图示

PreOder

先读取节点数据随后遍历左子树，再遍历右子树。

中序遍历

代码
   void  _InOder(Node* root)
   {
       if (NULL == root){return;}
       _InOder(root->_Lchild);
       cout<<root->_data<<" ";
       _InOder(root->_Rchild);
   }

后序遍历

代码
   void  _PostOder(Node* root)
   {
       if (NULL == root){return;}
       _PostOder(root->_Lchild);
       _PostOder(root->_Rchild);
       cout<<root->_data<<" ";
   }

当前节点的左孩子为空时访问数据，随后将他的右孩子当成子问题继续访问

析构

代码
   void  _Destroy(Node* root)
   {
       if (NULL == root){return;}
       _Destroy(root->_Lchild);
       _Destroy(root->_Rchild);
       //cout<<root->_data<<" ";
       delete root;
   }

注意最后释放根节点数据

Find

代码
   Node* _Find(Node* root, const T& data)
   {
       if (NULL == root){return NULL;}

       if (data == root->_data){return root;}

       Node* Left = _Find(root->_Lchild,data);
       return Left != NULL ? Left:_Find(root->_Rchild,data);
   }

当前根节点找到就返回，else遍历左子树将结果给left，left如果为空时再遍历右子树寻找

Size

代码
   size_t _Size(Node* root)
   {
       if (NULL == root){return NULL;}
       return _Size(root->_Lchild) + _Size(root->_Rchild) + 1; 
   }

返回左子树节点个数+右子树节点个数+1(1是根节点)

LeafSize

代码
   size_t _LeafSize(Node* root)
   {
       if (NULL == root){return NULL;}

       if (NULL == root->_Lchild && NULL == root->_Rchild){return 1;}   //找到一个叶子节点

       return  _LeafSize(root->_Lchild) + _LeafSize(root->_Rchild);
   }

若当前节点同时无左右孩子返回1,最后返回左子树+右子树的叶子节点

GetKLevelSize

代码
   size_t _GetKLevelSize(Node* root,size_t K)
   {
       if (NULL == root){return NULL;}

       if (K == 1){return 1;} //到达第K层     
                /*右子树的第K-1层阶节点数   +   左子树的第K-1层阶节点数*/
       return _GetKLevelSize(root->_Lchild,K-1) + _GetKLevelSize(root->_Rchild,K-1);
   }

到达第K层时当前函数返回1，递归实现左树+右树第K-1层结点个数

Depth

代码
   size_t _Depth(Node* root)
   {
       if (NULL == root){return NULL;}

       if (NULL == root->_Lchild && NULL == root->_Rchild){return 1;}

       size_t Left = _Depth(root->_Lchild);
       size_t Right = _Depth(root->_Rchild);
       return Left > Right? Left + 1:Right+1;
   }

分别递归求左子树和右子树的深度，返回深的那个

非递归

先序遍历

代码
    void PreOderNoR()
    {
        if (NULL == _root){return;}

        Node* cur = _root;
        stack<Node*> s;

        while (cur || !s.empty())
        {
            while(cur)
            {
                s.push(cur);
                cout<<cur->_data<<" ";
                cur = cur->_Lchild;
            }
            //右子树走完了
            Node*top = s.top(); //将最右端的节点拿出来
            s.pop();

            cur = top->_Rchild; //将最右端节点的左节点当成子问题
        }
        cout<<endl;
    }

中序遍历

代码
    void InOderNoR()
    {
        if (NULL == _root){return;}

        stack<Node*> s;
        Node* cur = _root;

        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_Lchild;
            }
            //右子树走完
            Node* top = s.top();
            s.pop();

            cout<<top->_data<<" ";
            cur = top->_Rchild;
        }
        cout<<endl;
    }

后序遍历

代码
    void PostOderNoR()
    {
        if (NULL == _root){return;}

        stack<Node*> s;
        Node* cur = _root;
        Node* prev = NULL;

        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_Lchild;
            }

            Node* front = s.top();
            /*这里注意判断根节点的左子树是否已经访问过了*/
            if (NULL == front->_Rchild || prev == front->_Rchild)
            {
                cout<<front->_data<<" ";
                prev = front;
                s.pop();
            }
            else
            {
                cur = front->_Rchild;
            }
        }    
        cout<<endl;
    }

后序遍历的条件要注意，在走完右子树返回根节点是要判断一下右子树是否走过，如果走过就不能再走

All_Code

#ifndef __BINARYTREE_H__
#define __BINARYTREE_H__

#include <iostream>
#include <stack>
#include <queue>
#include <assert.h>
#include <windows.h>

using namespace std;

template <class T>
struct BinaryNode
{
    T _data;
    BinaryNode<T>* _Lchild;
    BinaryNode<T>* _Rchild;

    BinaryNode<T>(const T& data)
        :_data(data)
        ,_Lchild(NULL)
        ,_Rchild(NULL)
    {}
};
template <class T>
class BinaryTree
{
    typedef BinaryNode<T> Node;
public:
    BinaryTree()
        :_root(NULL)
    {}
    BinaryTree(T* a, size_t n, const T& invalid)
    {
        size_t index = 0;
        _root = _CreatTree(a, n, invalid, index);
    }

    BinaryTree(const BinaryTree<T>& t)
    {
        _root = _CopyBinaryTree(t._root);
    }
    /*BinaryTree<T> operator=(const BinaryTree<T> tree)
    {
        _root = _OperatorCopy(tree._root);
    }*/
    BinaryTree<T> operator=(BinaryTree<T> tree)
    {
        swap(_root, tree._root);
        return *this;
    }
    ~BinaryTree()
    {
        _Destroy(_root);
    }

    void PreOder()
    {
        _PreOder(_root);
        cout<<endl;
    }
    void PreOderNoR()
    {
        if (NULL == _root){return;}

        Node* cur = _root;
        stack<Node*> s;

        while (cur || !s.empty())
        {
            while(cur)
            {
                s.push(cur);
                cout<<cur->_data<<" ";
                cur = cur->_Lchild;
            }
            //右子树走完了
            Node*top = s.top(); //将最右端的节点拿出来
            s.pop();

            cur = top->_Rchild; //将最右端节点的左节点当成子问题
        }
        cout<<endl;
    }
    void InOder()
    {
        _InOder(_root);
        cout<<endl;
    }

    void InOderNoR()
    {
        if (NULL == _root){return;}

        stack<Node*> s;
        Node* cur = _root;

        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_Lchild;
            }
            //右子树走完
            Node* top = s.top();
            s.pop();

            cout<<top->_data<<" ";
            cur = top->_Rchild;
        }
        cout<<endl;
    }
    void LevelOder()
   {
       queue<Node*> q;
       if (NULL != _root){q.push(_root);}   //先将根节点放入队列中

       while (!q.empty())
       {
           Node* front = q.front();//把上一个节点节点拿出来访问

           cout<<front->_data<<" ";
           if (front->_Lchild)      //访问右子树
           {
               q.push(front->_Lchild);
           }

           if (front->_Rchild)  //访问左子树
           {
               q.push(front->_Rchild);
           }

           q.pop(); //将上一个根节点pop掉
       }
       cout<<endl;
   }

    void PostOder()
    {
        _PostOder(_root);
        cout<<endl;
    }

    void PostOderNoR()
    {
        if (NULL == _root){return;}

        stack<Node*> s;
        Node* cur = _root;
        Node* prev = NULL;

        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_Lchild;
            }

            Node* front = s.top();
            if (NULL == front->_Rchild || prev == front->_Rchild)
            {
                cout<<front->_data<<" ";
                prev = front;
                s.pop();
            }
            else
            {
                cur = front->_Rchild;
            }
        }    
        cout<<endl;
    }
    size_t Size()
    {
        return _Size(_root); 
    }
    size_t LeafSize()
    {
        return _LeafSize(_root);
    }
    size_t Depth()
   {
       return _Depth(_root); 
   }

    size_t GetKLevelSize(size_t K)
    {
        return _GetKLevelSize(_root, K);
    }
    Node* Find(const T& data)
    {
        return _Find(_root, data);
    }
protected:
   Node* _CopyBinaryTree(Node* root)
   {
       if (NULL == root){return NULL;}
       Node* NewNode = new Node(root->_data);//拷贝当前根节点
       NewNode->_Lchild = (_CopyBinaryTree(root->_Lchild));//拷贝左子树
       NewNode->_Rchild = (_CopyBinaryTree(root->_Rchild));//拷贝右子树
       return NewNode;
   }

   Node* _CreatTree(T* a, size_t n, const T& invalid, size_t& index)
   {
       assert(NULL != a && n > 0);
       Node* root = NULL;
       if (index < n && a[index] != invalid)
       {
           root = new Node(a[index]);
           root->_Lchild = _CreatTree(a, n, invalid, ++index);
           root->_Rchild = _CreatTree(a, n, invalid, ++index);
       }
       return root;
   }
   Node* _OperatorCopy(Node* root)
   {
       if (_root != root)
       {
           ~BinaryTree();
       }
       return _CopyBinaryTree(root);
   }
   Node* _Find(Node* root, const T& data)
   {
       if (NULL == root){return NULL;}

       if (data == root->_data){return root;}

       Node* Left = _Find(root->_Lchild,data);
       return Left != NULL ? Left:_Find(root->_Rchild,data);
   }
   void  _Destroy(Node* root)
   {
       if (NULL == root){return;}
       _Destroy(root->_Lchild);
       _Destroy(root->_Rchild);
       //cout<<root->_data<<" ";
       delete root;
   }
   void  _PreOder(Node* root)
   {
       if (NULL == root){return;}
       cout<<root->_data<<" ";
       _PreOder(root->_Lchild);
       _PreOder(root->_Rchild);
   }

   void  _PostOder(Node* root)
   {
       if (NULL == root){return;}
       _PostOder(root->_Lchild);
       _PostOder(root->_Rchild);
       cout<<root->_data<<" ";
   }

   void  _InOder(Node* root)
   {
       if (NULL == root){return;}
       _InOder(root->_Lchild);
       cout<<root->_data<<" ";
       _InOder(root->_Rchild);
   }
   size_t _Size(Node* root)
   {
       if (NULL == root){return NULL;}
       return _Size(root->_Lchild) + _Size(root->_Rchild) + 1; 
   }
   size_t _LeafSize(Node* root)
   {
       if (NULL == root){return NULL;}

       if (NULL == root->_Lchild && NULL == root->_Rchild){return 1;}   //找到一个叶子节点

       return  _LeafSize(root->_Lchild) + _LeafSize(root->_Rchild);
   }
   size_t _GetKLevelSize(Node* root,size_t K)
   {
       if (NULL == root){return NULL;}

       if (K == 1){return 1;} //到达第K层

                /*右子树的第K-1层阶节点数   +   左子树的第K-1层阶节点数*/
       return _GetKLevelSize(root->_Lchild,K-1) + _GetKLevelSize(root->_Rchild,K-1);
   }
   size_t _Depth(Node* root)
   {
       if (NULL == root){return NULL;}

       if (NULL == root->_Lchild && NULL == root->_Rchild){return 1;}

       size_t Left = _Depth(root->_Lchild);
       size_t Right = _Depth(root->_Rchild);
       return Left > Right? Left + 1:Right+1;
   }
protected:
    Node* _root;
};
void TestBinaryTree()
{
    int a[] = {1,2,3,'#','#',4,'#','#',5,6};
    int b[] = {1,2,4,'#','#',5,8,'#',9,10,'#','#','#','#',3,6,'#',11,'#',12,13,'#',14,'#','#','#',7};

    //BinaryTree<int> tree(a,sizeof(a)/sizeof(a[0]),'#');
    BinaryTree<int> tree(b,sizeof(b)/sizeof(b[0]),'#');
}

#endif //__BINARYTREE_H__

欢迎提出问题和建议，这是我的邮箱：blbagony@163.com

aisheng_huo
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的操作--递归与非递归
每天学习一点点，成长一小步
05-29 543
由于此前已对二叉树介绍过，在此便不多做解释；全是递归操作，先左后右；创建一个变量： BinaryTreeNode<T>* _pRoot;以下是操作是创建树 void _CreateTree(Node*& pRoot, const T array[], size_t size, size_t& index, const T& invalid) //创建一个树 { if(index<size&&
二叉树递归与非递归遍历
QAQ
04-03 750
二叉树是一种常见的数据结构。二叉树有以下特点： 二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。 二叉树的第i层至多有2^{i-1}个结点； 深度为k的二叉树至多有2^k-1个结点； 对任何一棵二叉树T，如果其终端结点数为n_0，度为2的结点数为n_2，则n_0=n_2+1。 谈到二叉树，就不得不提到二叉树的遍历操作。其中，有三种
二叉树的创建——递归与非递归
ting_happy的博客
11-05 1009
初学者对于二叉树的遍历，这些放在最早学习的内容，应该是非常熟悉的，但是渐渐的就会发现，对于如何创建一颗二叉树，初学者对此过程还不甚清晰。直接一个一个结点插入吗？当树的深度过大时，这显然是一个费时费力的过程。以下我们介绍二叉树的创建的两种方法——递归与非递归。
二叉树的递归和非递归遍历
GoWilli的CSDN
09-12 1162
二叉树的各种遍历方式，包括前序、中序、后序、层次遍历及它们各种实现方式 （递归、迭代）
二叉树的层次、递归与非递归遍历
Yweic的博客
11-22 1289
本文主要讲解二叉树的遍历方法
二叉树遍历-递归与非递归遍历
雪的期许
08-14 1186
二叉树的遍历原则 先序遍历：①访问当前结点，②遍历左子树，③遍历右子树 中序遍历：①遍历左子树，②访问当前结点，③遍历右子树 后序遍历：①遍历左子树，②遍历右子树，③访问当前结点 递归遍历 递归写法易懂，按照遍历原则递归即可，详见代码21~41行 非递归遍历 非递归先序和中序遍历套路相似，后序遍历比较麻烦，因为先序和中序都是在右子树之前就输出了根结点，而后序必须记住根结点，等待右子树...
二叉树递归和非递归遍历以及层次构建节点数为n的二叉树
12-17
二种非递归实现 二叉树中序遍历： 递归实现 非递归实现 二叉树后序遍历： 递归实现 非递归实现 二叉树层次遍历 二叉树层次创建，创建方法遵循卡特兰数 http://write.blog.csdn.net/postedit/17380455
C++基于递归和非递归算法求二叉树镜像的方法
08-30
基于递归和非递归算法求二叉树镜像的方法 本文主要介绍了C++语言中基于递归和非递归算法求二叉树镜像的方法。二叉树镜像是指将二叉树的左右子树交换，使其成为镜像的过程。本文将详细讲述递归和非递归算法的实现与...
深入理解二叉树的非递归遍历
09-05
总结来说，二叉树的非递归遍历主要依赖于栈来模拟递归调用的过程，通过控制栈中节点的顺序和状态，可以实现与递归相同的效果。这种实现方式在某些场景下比递归更高效，因为它避免了系统调用的开销，特别是对于深度较...
C++非递归建立二叉树实例
09-03
在C++编程中，二叉树是一种非常重要的数据结构，它由节点组成，每个节点包含一个值以及两个指向其他节点的...同时，对于学习数据结构和算法的初学者来说，掌握这种非递归构建方法有助于深入理解二叉树的性质和操作。
C语言二叉树的遍历，递归和非递归
大前端程序猿
11-21 4159
代码包含如下几个文件： 下面一一贴出来： Stack.h文件： #ifndef STACK_H_ #define STACK_H_ #include "BinaryTree.h" #include #define STACK_INIT_SZIE 20 #define STACK_INCREMENT_SIZE 10 typedef struct { int size;/** 栈
C语言实现二叉树遍历的递归和非递归算法
热门推荐
From Zero to Hero
04-06 2万+
本文主要介绍二叉树的各种遍历方法。 二叉树的遍历 所谓二叉树的遍历，是指按某条搜索路径访问树中的每个结点，使得每个结点均被访问一次，而且仅被访问一次。 由二叉树的递归定义可知，遍历一棵二叉树便要决定对根结点NNN、**左子树LLL和右子树RRR**的访问顺序。按照先遍历左子树再遍历右子树的原则，常见的遍历次序有： 前序遍历：（N L R） 中序遍历：（L N R） 后序遍历：（L R L） 这...
二叉树的中序遍历（递归与非递归）
zhangxu
04-20 2660
二叉树中序遍历 上篇我简单的给大家介绍了一下二叉树的先序遍历，那么这次我就给大家介绍一下二叉树的中序遍历 请看大屏幕 。。。。 上图是一棵二叉树，中序遍历结果：4 2 5 1 3 6 同理，我想你可能会问什么叫做中序遍历，其实很简单，就是按照 左 -》 右 -》 根 的方式去遍历二叉树。 首先让我们来看看如何递归的去中序遍历二叉树 注：在这里我特别强调一点...
二叉树的深度 (递归与非递归方法整理)
hyqsong的专栏
03-05 1万+
题目描述 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 解法及思路一、 递归的方法思路： 我们可以从另一个角度来理解树的深度：如果一棵树只有一个结点，那么它的深度为1； 如果根结点只有左子树没有右子树，那么树的深度是左子树的深度加1，加1是加上根节点这一层 如果既有左子树又有右子树，那么树的深度应该是左、右子树中深度
二叉树的递归与非递归遍历
wusecaiyun的专栏
08-11 739
二叉树遍历是二叉树中最基本的问题，其实现的方法非常多，有简单粗暴但容易爆栈的递归算法，还有稍微高级的使用栈模拟递归的非递归算法，另外还有不用栈而且只需要常数空间和线性时间的神奇Morris遍历算法，本文将对这些算法进行讲解和实现。 递归算法 二叉树节点使用以下数据结构进行表示，包括关键字、左儿子、右儿子属性和一个带默认参数的构造函数。 struct成员的默认属性为public
2024年欧洲铝桁架市场主要企业市场占有率及排名.docx
最新发布
07-17
2024年欧洲铝桁架市场主要企业市场占有率及排名.docx
二叉树递归和非递归遍历设计思路，要求1500字
05-24
本文将分别介绍二叉树的递归和非递归遍历的设计思路。 一、递归遍历 递归遍历二叉树是一种非常简单的方法，其实现思路也非常直观。以前序遍历为例，其递归实现方式如下： ```python def preorderTraversal(root: ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值