数据结构：二叉树，二叉树的前中后序、层序遍历（递归法，非递归法），得到一个数叶子节点的个数……

最新推荐文章于 2022-06-15 23:14:41 发布
最新推荐文章于 2022-06-15 23:14:41 发布
阅读量1.2k 收藏
点赞数 2
分类专栏： C++ 数据结构 文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_36101354/article/details/66478615
版权

二叉树

在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。
二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^{i-1}个结点；深度为k的二叉树至多有2^k-1个结点；对任何一棵二叉树T，如果其终端结点数为n_0，度为2的结点数为n_2，则n_0=n_2+1。
一棵深度为k，且有2^k-1个节点称之为满二叉树；深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中，序号为1至n的节点对应时，称之为完全二叉树。

二叉树的五种形式
(1)空二叉树——如图(a)；
(2)只有一个根结点的二叉树——如图(b)；
(3)只有左子树——如图(c)；
(4)只有右子树——如图(d)；
(5)完全二叉树——如图(e)。
这里写图片描述

在阅读的大部分书籍中，二叉树的实现都使用的是递归的方法，当然我也不例外：

二叉树的遍历是一个大问题，下面我将用递归法与非递归法分别实现
递归方法：
因为是使用的C++语言，所以可能有些变量可能你会不太理解，不过在下面会有完整的代码：

//前序
    void _PrevOrder(Node* root)
    {
        if (root == NULL)
            return;
        cout << root->_data << " ";
        _PrevOrder(root->_left);
        _PrevOrder(root->_right);
    }
//中序
    void _InOrder(Node* root)
    {
        if (root == NULL)
            return;
        _InOrder(root->_left);
        cout << root->_data << " ";
        _InOrder(root->_right);
    }
//后序
    void _PostOrder(Node* root)
    {
        if (root == NULL)
            return;
        _PostOrder(root->_left);
        _PostOrder(root->_right);
        cout << root->_data << " ";
    }

非递归法：

    void LevelOrder()//层序遍历
    {
        if (_root == NULL)
            return;
        queue<BinaryTreeNode<T>*> q;
        q.push(_root);

        while (!q.empty())
        {
            BinaryTreeNode<T>* root = q.front();
            if (root->_left)
            {
                q.push(root->_left);
            }
            if (root->_right)
            {
                q.push(root->_right);
            }
            cout << root->_data << " ";
            q.pop();
        }
        cout << endl;
    }
    //层序使用的是队列的先进先出性质，将每一层的节点从左到右分别遍历打印
//方法一：
    void PrevOrder_NonR()//前序遍历非递归
    {
        stack<Node*> s;
        if (_root)
            s.push(_root);
        while (!s.empty())
        {
            Node* root = s.top();
            cout << root->_data << " ";
            s.pop();
            if (root->_right)
            {
                s.push(root->_right);
            }
            if (root->_left)
            {
                s.push(root->_left);
            }
        }
        cout << endl;
    }
//方法二：
void PrevOrder_NonR()//前序便利非递归
    {
        cout << "PrevOrder_NonR: ";
        stack<Node*> s;
        Node* root = _root;
        while (!s.empty()||root!=NULL)
        {
            while (root)
            {
                cout << root->_data << " ";
                s.push(root);
                root = root->_left;
            }
            while (!s.empty())
            {
                root = s.top();
                s.pop();
                root = root->_right;
                break;
            }
        }
        cout << endl;
    }

    void InOrder_NonR()//中序遍历非递归
    {
        stack<Node*> s;
        Node* root = _root;
        while (root != NULL || !s.empty())
        {
            while (root)
            {
                s.push(root);
                root = root->_left;
            }
            while (!s.empty())
            {
                root = s.top();
                cout << root->_data << " ";
                s.pop();
                root = root->_right;
            }
        }
        cout << endl;
    }

    void PostOrder_NonR()//后序遍历非递归
    {
        stack<Node*> s;
        Node* cur = _root;
        Node* prev = NULL;

        while (cur || !s.empty())
        {
            // 入栈做孩子节点  
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }

            // 2.右节点为空/之前右节点已经访问过了的时候访问当前的栈顶节点  
            Node* top = s.top();
            if (top->_right == NULL || prev == top->_right)
            {
                cout << top->_data << " ";
                s.pop();
                prev = top;
            }
            else
            {
                cur = top->_right;
            }
        }

        cout << endl;

    }

完整代码

#pragma once
#include<iostream>
#include<stdlib.h>
using namespace std;
#include<queue>
#include<stack>

template<class T>
struct BinaryTreeNode
{
    BinaryTreeNode<T>* _left;
    BinaryTreeNode<T>* _right;
    T _data;
    BinaryTreeNode(const T& x)
        :_data(x)
        , _left(NULL)
        , _right(NULL)
    {}
};

template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree()
        :_root(NULL)
    {}

    BinaryTree(const T* arr, size_t size, const T& invalid)//默认参数列表，构造函数,(数组，大小，非法值)
    {
        size_t index = 0;
        _CreateTree(_root, arr, size, index, invalid);//（根,数组，大小，非法值）
    }

    BinaryTree(BinaryTree<T>& t)//拷贝构造函数
    {
            this->_root = _CopyBinaryTree(t._root);
    }

    /*BinaryTree<T>& operator=(BinaryTree<T> t)
    {
    if (this != &t)
    {
    this->Destory();
    this->_root = _CopyBinaryTree(t._root);
    }

    return *this;
    }*/
    BinaryTree<T>& operator=(BinaryTree<T> t)
    {
        swap(_root, t._root);
        return *this;
    }

    ~BinaryTree()//析构函数
    {
        Destory();
    }

    void PrevOrder()//递归前置遍历
    {
        cout << "PrevOrder: ";
        _PrevOrder(_root);
        cout << endl;
    }

    void InOrder()//递归中序遍历
    {
        cout << "InOrder: ";
        _InOrder(_root);
        cout << endl;
    }

    void PostOrder()//递归后序遍历
    {
        cout << "PostOrder: ";
        _PostOrder(_root);
        cout << endl;
    }

    void LevelOrder()//层序遍历
    {
        cout << "LeveOrder: ";
        if (_root == NULL)
            return;
        queue<BinaryTreeNode<T>*> q;
        q.push(_root);

        while (!q.empty())
        {
            BinaryTreeNode<T>* root = q.front();
            if (root->_left)
            {
                q.push(root->_left);
            }
            if (root->_right)
            {
                q.push(root->_right);
            }
            cout << root->_data << " ";
            q.pop();
        }
        cout << endl;
    }

    void PrevOrder_NonR()//前序便利非递归
    {
        cout << "PrevOrder_NonR: ";
        stack<Node*> s;
        if (_root)
            s.push(_root);
        while (!s.empty())
        {
            Node* root = s.top();
            cout << root->_data << " ";
            s.pop();
            if (root->_right)
            {
                s.push(root->_right);
            }
            if (root->_left)
            {
                s.push(root->_left);
            }
        }
        cout << endl;
    }

    void InOrder_NonR()//中序遍历非递归
    {
        cout << "InOrder_NoR: ";
        stack<Node*> s;
        Node* root = _root;
        while (root != NULL || !s.empty())
        {
            while (root)
            {
                s.push(root);
                root = root->_left;
            }
            while (!s.empty())
            {
                root = s.top();
                cout << root->_data << " ";
                s.pop();
                root = root->_right;
            }
        }
        cout << endl;
    }

    void PostOrder_NonR()//后序遍历非递归
    {
        cout << "PastOrder_NonR: ";
        stack<Node*> s;
        Node* cur = _root;
        Node* prev = NULL;

        while (cur || !s.empty())
        {
            // 入栈做孩子节点  
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }

            // 2.右节点为空/之前右节点已经访问过了的时候访问当前的栈顶节点  
            Node* top = s.top();
            if (top->_right == NULL || prev == top->_right)
            {
                cout << top->_data << " ";
                s.pop();
                prev = top;
            }
            else
            {
                cur = top->_right;
            }
        }

        cout << endl;

    }

    int Size()//节点个数
    {
        return _Size(_root);
    }

    int Depth()//树的深度
    {
        return _Depth(_root);
    }

    int LeafSize()//叶子节点的个数
    {
        size_t count = 0;
        return _LeafSize(_root, count);
    }

    int GetKLevel(size_t k)//第K层节点个数
    {
        size_t count = 0;
        return _GetKlevel(_root, k, count);
    }

    void Destory()
    {
        _Destory(_root);
        _root = NULL;
    }

protected:
    void _CreateTree(BinaryTreeNode<T>*& root, const T array[], size_t size, size_t& index, const T& invalid)
    {
        if (index < size && array[index] != invalid)
        {
            root = new BinaryTreeNode<T>(array[index]);
            _CreateTree(root->_left, array, size, ++index, invalid);
            _CreateTree(root->_right, array, size, ++index, invalid);
        }
    }

    Node* _CopyBinaryTree(Node* root)
    {
        Node* newRoot = NULL;
        if (root)
        {
            newRoot = new Node(root->_data);
            newRoot->_left = _CopyBinaryTree(root->_left);
            newRoot->_right = _CopyBinaryTree(root->_right);
        }

        return newRoot;
    }

    void _Destory(Node* root)
    {

        if (root == NULL)
            return;

        _Destory(root->_left);
        _Destory(root->_right);

        delete root;
    }

    void _PrevOrder(Node* root)
    {
        if (root == NULL)
            return;
        cout << root->_data << " ";
        _PrevOrder(root->_left);
        _PrevOrder(root->_right);
    }

    void _InOrder(Node* root)
    {
        if (root == NULL)
            return;
        _InOrder(root->_left);
        cout << root->_data << " ";
        _InOrder(root->_right);
    }

    void _PostOrder(Node* root)
    {
        if (root == NULL)
            return;
        _PostOrder(root->_left);
        _PostOrder(root->_right);
        cout << root->_data << " ";
    }

    int _Size(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }

        return _Size(root->_left) + _Size(root->_right) + 1;
    }

    int _Depth(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }

        int leftDepth = _Depth(root->_left) + 1;
        int rightDepth = _Depth(root->_right) + 1;

        return leftDepth > rightDepth ? leftDepth : rightDepth;
    }

    int _LeafSize(Node* root, size_t& count)
    {
        if (root)
        {
            if ((root->_left == NULL) && (root->_right == NULL))
            {
                count++;
            }
            _LeafSize(root->_left, count);
            _LeafSize(root->_right, count);
        }
        return count;
    }

    int _GetKlevel(Node* root, size_t k, size_t& count)
    {
        if (root)
        {
            if (1 == k)
            {
                count++;
            }
            else
            {
                _GetKlevel(root->_left, k - 1, count);
                _GetKlevel(root->_right, k - 1, count);
            }
        }
        return count;
    }

protected:
    Node* _root;
};

测试用例

#include"BinaryTree.h"

void TestBinaryTree()
{
    cout << "TestBinaryTree:" << endl;

    int array[20] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
    BinaryTree<int> tree(array, 10,'#');
    tree.PrevOrder();

    tree.PrevOrder();
    tree.PrevOrder_NonR();
    tree.InOrder();
    tree.InOrder_NonR();
    tree.PostOrder();
    tree.PostOrder_NonR();
    tree.LevelOrder();

    cout << "Height:" << tree.Depth() << endl;
    cout << "LeafSzie:" << tree.LeafSize() << endl;
    cout << "KLeveSzie of 2:" << tree.GetKLevel(10) << endl;
    cout << "Size:" << tree.Size() << endl;

    BinaryTree<int> treeCopy1 = tree;
    treeCopy1.PrevOrder();

    BinaryTree<int> treeCopy2;
    treeCopy2 = tree;
    treeCopy2.PrevOrder();
}

int main()
{
    TestBinaryTree();
    system("pause");
    return 0;
}
Wang__Peter
关注
专栏目录
二叉树的前中后序以及层序遍历（递归与非递归方法实现）
tensor329的博客
04-01 663
1.前序遍历 前序遍历是二叉树遍历的一种方式，也称做先序遍历。其遍历规则为：根节点→左子树→右子树。以下分别以递归和非递归的方法实现对二叉树的前序遍历。 1.1 递归方法 class Solution { List<Integer> res=new ArrayList<>(); public List<Integer> preorderTraversal(TreeNode root) { if(root!=null){
二叉树后序遍历（递归法和迭代法(非递归法)）——C++
净无邪博客
12-04 1933
一、二叉树后序遍历 后序遍历是先遍历左子节点left，在遍历右子节点right，最后遍历父节点parent，即遍历顺序：1.2 迭代法 由于后续遍历如果按照正常迭代思路去实现将不好理解和实现，仔细观察下面前序和后续遍历顺序，可以发现一个规律： 前序遍历：parent ——> left ——> right 前序遍历： left ——> right ——>parent， 将后续遍历逆序过来遍历，则：parent ——> right ——>left 通过观察1和3可以发现，两者都是先遍历父节点，再遍历左
求二叉树叶子结点的个数（c++类建立）
11-19
根据键盘输入的扩展二叉树的前序遍历序列建立相应的二叉树，并计算该二叉树的叶子结点个数
数据结构实验之二叉树五：层序遍历
makelucky的博客
11-08 159
数据结构实验之二叉树五：层序遍历 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 已知一个按先序输入的字符序列，如abd,,eg,,,cf,,,(其中,表示空结点)。请建立二叉树并求二叉树的层次遍历序列。 Input 输入数据有多行，第一行是一个整
【数据结构】二叉树的层序遍历
ZXC
06-15 453
void traverse_ceng(Tree myTree) { TreeNodePtr a = myTree.head; if (a == NULL) { return; } queue myQueue; init_queue(&amp;myQueue); enQueue(&amp;myQueue, *a); cout &lt;&lt; "层序遍历:"; while (...
数据结构之层序遍历二叉树
wrc_nb的博客
05-17 396
#include &lt;iostream&gt;using namespace std;struct BitNode { char data; BitNode *lchild; BitNode *rchild;};struct LinkNode { BitNode *data; LinkNode *next;};struct LinkQueue{ LinkNode *front; LinkNod...
二叉树部分：二叉树的深度，二叉树的前序遍历、二叉树的中序遍历、二叉树的后序遍历、求叶子结点的个数
wyqwilliam的博客
09-17 571
第一：定义二叉树的结点：  /** * 链式二叉树结点 * @author Administrator * */ public class Node { int value; Node leftChild; Node rightChild; public Node(int value) { this.value = value; } public Node(int...
Java中的二叉树，前中后序遍历的递归和迭代写法。
回水的博客
06-15 1220
文章目录一、树是什么？树的特点二、二叉树1.概念及特点2.读入数据总结 一、树是什么？ 树是一种非线性的数据结构，它是由n(n >= 0)个有限结点组成的一个具有层次关系的集合。(线性数据结构就是：线性表，数组，栈，链表，队列，字符串…元素之间逻辑上一个挨着一个，呈值直线排列)把它叫做树是因为它看起来像一颗倒着的树，意思就是根朝上，叶子朝下。 树的特点 有一个特殊的结点，称为根节点，根节点没有前驱结点。 除根节点外，其余节点被分成M(M > 0) 个互不相交的集合T1、T2、…、Tm,其中
二叉树的四种遍历方式——前序、中序、后序、层序遍历（递归+非递归实现）
weixin_43298704的博客
09-10 1261
如果N代表根节点，L代表根节点的左子树，R代表根节点的右子树，则根据遍历根节点的先后次序有以下遍历方式： 1. NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点--->根的左子树--->根的右子树。（简记为：根左右） 2. LNR：中序遍历(Inorder Traversal)——根的左子树--->根节点--->根的右子树。（简记为：左根右） 3. LRN：后序遍历(Postorder Traversal)——根的左子树--->根的右子树-
二叉树的前序、中序、后序遍历（递归、非递归写法）
m0_62021646的博客
05-13 1914
文章目录一、什么是二叉树？二、二叉树的基本概念三、二叉树的三种遍历方式1.前序遍历（preordertraversal）1.中序遍历（inordertraversal）1.后序遍历（postordertraversal）四、代码实现1.建树过程2.递归写法3.非递归写法4.完整代码 一、什么是二叉树？ 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。
二叉树的先序，中序，后序遍历以及叶子结点数目
11-28
c语言，二叉树的先序，中序，后序遍历以及叶子结点数目
树的前中后序遍历，外加求深度、节点数、叶子节点数
11-12
二叉树作业，树的前中后序遍历，外加求深度、节点数、叶子节点数
二叉树后序遍历的非递归算法
05-05
这是数据结构中二叉树的后序遍历的非递归算法的源代码。
【数据结构】二叉树后序遍历（非递归）
qq_42270373的博客
11-02 412
后序遍历：左-右-根 思路分析：  后序遍历的顺序是：左-右-根，和前、中序遍历的不同之处在于，它在遍历的时候，需要判断它的右子树是否已经被访问过，如果已经访问过的话，就直接取出当前节点，若没有访问过，则就去访问。如果没有这个操作，依旧和前、中序遍历的思想一样，就会在底部递归时，出现死循环。 具体步骤如下： ①先将根节点入栈；  ②若根节点不存在左子树和右子树，或者根节点存在左...
二叉树的层序遍历（非递归）
涛爸的博客
11-09 613
输出二叉树的层序遍历序列 如[2,6,8,null,null,10,12]，输出[[2],[6,8],[10,12]] Binary Tree Level Order Traversal 借助两个队列，一个记录当前层，一个记录下一层 依次插入二维vector/** * Definition for a binary tree node. * struct TreeNode { *
二叉树的非递归层次遍历
doubleintfloat的博客
09-22 1639
#include<iostream> #include<stack> #include<queue> using namespace std;typedef struct Node { char data; Node*lchild; Node*rchild; }Node;//创建一个节点 Node*BuyNode() { Node* p = new(nothrow)N
非递归遍历二叉树
qq_45698793的博客
04-25 246
前序遍历 public List<TreeNode> perOrderTraversal(TreeNode root) { if (root == null) { return null; } TreeNode node = root; List<TreeNode> list = new ArrayList<>(); Stack<TreeNode> stac
二叉树的后序遍历(非递归算法)
flyapy
06-27 1891
可以巧妙的用两个栈来实现后序遍历的非递归算法。注意到后序遍历可以看作是下面遍历的逆过程：即先遍历某个结点，然后遍历其右孩子，然后遍历其左孩子。这个过程逆过来就是后序遍历。算法步骤如下： Push根结点到第一个栈s中。 从第一个栈s中Pop出一个结点，并将其Push到第二个栈output中。然后Push结点的左孩子和右孩子到第一个栈s中。 重复过程2和3直到栈s为空。 完成后
非递归后序遍历详解：二叉树遍历算法
非递归后序遍历是一种用于遍历二叉树的算法，它在计算机科学中用于访问二叉树的节点顺序，通常在需要按照左子树、右子树、根节点的顺序进行操作时使用。以下是该主题的详细讲解： 1. **树与二叉树**： - **树**：...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值