二叉树的递归和非递归

最新推荐文章于 2023-07-30 12:28:05 发布
最新推荐文章于 2023-07-30 12:28:05 发布
阅读量680 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 二叉树 递归 非递归-几种遍历算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/f2016913/article/details/63683526
版权

二叉树的几种遍历算法

1.二叉树的前序遍历
2.二叉树的中序遍历
3.二叉树的后序遍历
4 .二叉树的后序遍历

一. 二叉树的前序遍历
前序遍历算法是判断节点是否为空，如果不为空，先访问根节点，再访问左子树，最后访问右子树；
前序的递归： 根->左子树（为空）->右子树。对于每一个子树又可以用同样的访问顺序来遍历。

void PrevOrder()
    {
        _PrevOrder(_root);
        cout << endl;
    }

具体实现：

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

前序的非递归算法
对于任意节点cur:
1:判断根节点是否为空，空则返回
2：根节点不为空，输出节点，将根节点入栈，再看cur的左子树是否为空。
3：若cur的左子树不为空，将cur左子树置为当前节点，重复3操作。
4：若cur的左子树为空，将栈顶节点出栈，但不输出，将右子树的节点置为当前节点，看右子树是否为空。
5：不为空重复3操作
6：为空重复4操作
7：直到当前节点为NULL，且栈为空，则遍历结束。
前序

void PrevOrder_NotR()
    {
        cout << "前序非递归" << endl;
        return _PrevOrder_NotR(_root);
        cout << endl;
    }
`void _PrevOrder_NotR(Node *root)
{
if (root == NULL)//空树
{
return;
}
Node*cur = root;
stack<Node*> s;
while ( !s.empty()||cur!= NULL)
{
//边遍历边将节点压栈
while(cur)
{
cout << cur->_data << " ";
s.push(cur);//根节点入栈
cur = cur->_left;
}
//说明此时左子树已经遍历完了，要遍历要遍历右子树
if (!s.empty())
{
cur = s.top();//取栈顶元素
s.pop();//出栈
cur = cur->_right;
}
}
cout << endl;
}

二：二叉树的中序遍历****
二叉树的中序遍历算法：先访问左子树，再访问根节点，最后访问右子树。
中序：

void InOrder()
{
_InOrder(_root);
cout << endl;
}

实现：

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

中序的非递归算法：
对于任意节点cur:
1:cur是否为空若为空返回。
2：cur不为空，判断cur的左子树是否为空，若不为空，将cur入栈，将cur的左子树置为当前节点。并对当前节点进行相同操作。
3：cur的左子树为空，输出cur，并将cur的右子树当前节点，看是否为空。
4：不为空重复2和3操作。
5：为空，则执行出栈操作，输出栈顶结点，并将右孩子置为当前节点，看是否为空重复3和4操作。
6：直到当前节点P为NULL并且栈为空，则遍历结束
非递归的实现：

void _InOrder_NotR(Node*root)
    {
        Node*cur = root;
        if (cur == NULL)
        {
            return;
        }
        stack<Node *> s;
        while (cur!= NULL||!s.empty())
        {
            //一直遍历到左子树的最下面
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }
            //说明左子树已经遍历完了；这时需要出栈
            if (!s.empty())
            {
                cur = s.top();
                s.pop();
                cout << cur->_data << " ";
                //遍历右子树
                cur = cur->_right;
            }
        }
        cout << endl;
    }

三：二叉树的后序遍历：
后序遍历算法：根节点->右子树->左子树
后序的递归：

void PosOrder()
    {
        _PosOrder(_root);
        cout << endl;
    }

实现：

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

后序的非递归算法：
对于任意节点cur:
1:cur是否为空若为空返回。
2：cur不为空，判断cur的右子树是否为空，若不为空，将cur入栈，将cur的右子树置为当前节点。并对当前节点进行相同操作。
3：cur的右子树为空，输出cur，并将cur的左子树当前节点，看是否为空。
4：不为空重复2和3操作。
5：为空，则执行出栈操作，输出栈顶结点，并将左孩子置为当前节点，看是否为空重复3和4操作。
6：直到当前节点P为NULL并且栈为空，则遍历结束
非递归的实现：

//后序非递归
    void _PosOrder_NotR(Node*root)
    {
        Node*cur = root;
        if (cur == NULL)//空树
        {
            return;
        }
        stack<Node*>s;
        while (!s.empty() || cur!=NULL)
        {
            //一直遍历右子树的最下面，边遍历边将节点压栈
            while (cur)
            {
                s.push(cur);
                cur=cur->_right;
            }
            if (!s.empty())
            {
                //右子树已经遍历完了，
                cur = s.top();
                s.pop();
                cout << cur->_data << " ";
                //遍历左子树
                cur = cur->_left;
            }
        }
        cout << endl;
    }

四：二叉树的层序遍历：
我们可以利用队的先进先出的性质，具体实现是，先遍历当前层，入队，然后遍历下一层。置到结束：
实现：

void _LevelOeder(Node *root)
    {
        queue<Node *> q;
        if (root == NULL)
        {
            return;
        }
        if (root)
        {
            q.push(root);//把根节点入队
        }
        while (!q.empty())
        {
            Node*front = q.front();
            cout << front->_data << " ";
            q.pop();

            if (front->_left)
                q.push(front->_left);//左子树入队
            if (front->_right)
                q.push(front->_right);//右子树入队
        }
        cout << endl;
    }

五：实现及其测试函数：
.h文件

#pragma once
#include<queue>
#include<stack>
#include<assert.h>
using namespace std;
template<class T>
struct BinaryTreeNode
{
    T _data;//数据
    BinaryTreeNode<T>* _left;//左节点
    BinaryTreeNode<T>* _right;//右节点

    BinaryTreeNode(const T&x =T())
        :_data(x)
        , _left(NULL)
        , _right(NULL)
    {}
};
template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T>  Node;
public:
    BinaryTree()
        :_root(NULL)
    {}
    BinaryTree(const BinaryTree<T> &t)
    {
        _root = _copy(t._root);
    }
    BinaryTree<T>&operator = (BinaryTree<T> &t)
    {
        //BinaryTree<T> tmp(t._root);
        swap(_root, t._root);
        return *this;
    }
    ~BinaryTree()
    {
        _Destroy(_root);
    }
    BinaryTree(const T*a, size_t n, const T&invalued = T())
    {
        size_t indes = 0;
        _root = _CreatTree(a, n, indes, invalued);//创建一个二叉树
    }
    //数节点的个数
    size_t Size()
    {
        return _Size(_root);
    }
    //深度
    size_t Depth()
    {
        return _Depth(_root);
    }
    //叶子节点的个数
    size_t LeftSize()
    {
        return _LeftSize(_root);
    }
    //获取k的节点
    int GetkLevel(Node *root, int k)
    {
        if (root == NULL||k<1)
        {
            return 0;
        }
        if (k == 1)
        {
            return 1;
        }
        int leftGetkLevel = GetkLevel(root->_left, k - 1);
        int rightGetkLevel = GetkLevel(root->_right, k - 1);
        return (leftGetkLevel + rightGetkLevel);
    }
    //前序
    void PrevOrder()
    {
        _PrevOrder(_root);
        cout << endl;
    }
    //前序非递归
    void PrevOrder_NotR()
    {
        cout << "前序非递归" << endl;
        return _PrevOrder_NotR(_root);
        cout << endl;
    }
    //中序
    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }
    //中序非递归
    void InOrder_NotR()
    {
        cout << "中序非递归" << endl;
        return _InOrder_NotR(_root);
        cout << endl;
    }
    //后序
    void PosOrder()
    {
        _PosOrder(_root);
        cout << endl;
    }
    //后序非递归
    void PosOrder_NotR()
    {
        cout << "后序非递归" << endl;
        return _PosOrder_NotR(_root);
        cout << endl;
    }
    //层序
    void LevelOrder()
    {
        _LevelOeder(_root);
        cout << endl;
    }

protected:
    Node*_CreatTree(const T*a, size_t n, size_t &indes, const T&invalued)
     {
        assert(a);
        Node* root = NULL;

        if (indes<n && a[indes] != invalued)
        {
            root = new Node(a[indes]);//创建根节点
            root->_left = _CreatTree(a, n,++indes,invalued);
            root->_right= _CreatTree(a, n,++indes,invalued);
        }
        return root;
    }
    //拷贝
    Node *_copy(Node *node)
    {
        Node*cur = node;
        Node root = NULL;//
        if (cur)
        {
            root = new Node(cur->_data);//创建新节点
            root->_left = _copy(cur->_left);//递归调用
            root->_right = _copy(cur->_right);//递归调用
        }
        return root;
    }
    //删除
    void _Destroy(Node *node)
    {
        Node* del = node;
        if (del)
        {
            _Destroy(del->_left);
            _Destroy(del->_right);
            delete del;
            del = NULL;
        }
    }
    //树节点的个数
    size_t _Size(Node *root)
    {
        if (root == NULL)
        {
            return 0;
        }
        return _Size(root->_left) + _Size(root->_right) + 1;
    }
    //深度
    size_t _Depth(Node *root)
    {
        Node *cur = root;
        if (cur == NULL)
        {
            return 0;
        }
        //比较左子树和右子树的大小
        return 1 + (_Depth(cur->_left) > _Depth(cur->_right) 
            ? _Depth(cur->_left) : _Depth(cur->_right));
    }
    //叶子节点的个数
    size_t _LeftSize(Node *root)
    {
        Node*cur = root;
        if (NULL == cur)//空树
        {
            return 0;
        }
        if (cur->_left == NULL&&cur->_right == NULL)//只有根节点
        {
            return 1;
        }
        return _LeftSize(cur->_left)+_LeftSize(cur->_right);//左子树与右子树的和
    }
    //前序
    void _PrevOrder(Node *root)
    {
        Node *cur = root;
        if (cur == NULL)
        {
            return ;
        }
        cout << cur->_data << " ";
        _PrevOrder(cur->_left);
        _PrevOrder(cur->_right);
    }
    //前序非递归
    void _PrevOrder_NotR(Node *root)
    {
        if (root == NULL)//空树
        {
            return;
        }
        Node*cur = root;
        stack<Node*> s;
        while ( !s.empty()||cur!= NULL)
        {
            //边遍历边将节点压栈
            while(cur)
            {
                cout << cur->_data << " ";
                s.push(cur);//根节点入栈
                cur = cur->_left;
            }
            //说明此时左子树已经遍历完了，要遍历要遍历右子树
            if (!s.empty())
            {
                cur = s.top();//取栈顶元素
                s.pop();//出栈
                cur = cur->_right;
            }
        }
        cout << endl;
    }
    //中序
    void _InOrder(Node *root)
    {
        Node *cur = root;
        if (cur == NULL)
        {
            return;
        }
        _InOrder(cur->_left);
        cout << cur->_data << " ";
        _InOrder(cur->_right);
    }
    //中序非递归
    void _InOrder_NotR(Node*root)
    {
        Node*cur = root;
        if (cur == NULL)
        {
            return;
        }
        stack<Node *> s;
        while (cur!= NULL||!s.empty())
        {
            //一直遍历到左子树的最下面
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }
            //说明左子树已经遍历完了；这时需要出栈
            if (!s.empty())
            {
                cur = s.top();
                s.pop();
                cout << cur->_data << " ";
                //遍历右子树
                cur = cur->_right;
            }
        }
        cout << endl;
    }
    //后序
    void _PosOrder(Node *root)
    {
        Node *cur = root;
        if (cur == NULL)
        {
            return;
        }
        _PosOrder(cur->_right);
        cout << cur->_data << " ";
        _PosOrder(cur->_left);
    }
    //后序非递归
    void _PosOrder_NotR(Node*root)
    {
        Node*cur = root;
        if (cur == NULL)//空树
        {
            return;
        }
        stack<Node*>s;
        while (!s.empty() || cur!=NULL)
        {
            //一直遍历右子树的最下面，边遍历边将节点压栈
            while (cur)
            {
                s.push(cur);
                cur=cur->_right;
            }
            if (!s.empty())
            {
                //右子树已经遍历完了，
                cur = s.top();
                s.pop();
                cout << cur->_data << " ";
                //遍历左子树
                cur = cur->_left;
            }
        }
        cout << endl;
    }
    //层序
    void _LevelOeder(Node *root)
    {
        queue<Node *> q;
        if (root == NULL)
        {
            return;
        }
        if (root)
        {
            q.push(root);//把根节点入队
        }
        while (!q.empty())
        {
            Node*front = q.front();
            cout << front->_data << " ";
            q.pop();

            if (front->_left)
                q.push(front->_left);//左子树入队
            if (front->_right)
                q.push(front->_right);//右子树入队
        }
        cout << endl;
    }
protected:
    Node  *_root;
};

void TestBinaryTree()
{
    int a1[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
    size_t sz = sizeof(a1) / sizeof(a1[0]);
    BinaryTree<int> t(a1, sz, '#');
    BinaryTree<int> t1;
    t1 = t;//调赋值运算符的重载
    cout << t1.Size() << endl;
    cout << t1.Depth() << endl;
    cout << t1.LeftSize() << endl;
    cout << t1.LeftSize() << endl;
    t1.PrevOrder();
    t1.InOrder();
    t1.PosOrder();
    t1.LevelOrder();
    t1.PrevOrder_NotR();
    t1.InOrder_NotR();
    t1.PosOrder_NotR();
}

.cpp文件

#include<iostream>
#include"BinaryTree.h"
using namespace std;

int main()
{
    TestBinaryTree();
    system("pause");
    return 0;
}

测试结果

f2016913
关注
专栏目录
二叉树的操作--递归与非递归
每天学习一点点，成长一小步
05-29 568
由于此前已对二叉树介绍过，在此便不多做解释；全是递归操作，先左后右；创建一个变量： BinaryTreeNode<T>* _pRoot;以下是操作是创建树 void _CreateTree(Node*& pRoot, const T array[], size_t size, size_t& index, const T& invalid) //创建一个树 { if(index<size&&
二叉树的遍历——递归和非递归
weixin_34293246的博客
10-31 213
                 二 叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是 递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中， 前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对...
二叉树的递归遍历与非递归算法实现
a50777265的博客
12-05 127
通过递归算法与非递归算法的比较，更好地理解各自的特点。非递归其实就是调用栈的基本操作，进栈，出栈等。 这里面也正好复习了下栈的基本算法的实现。 栈和队列的实现在我的前一篇博文里。 基本数据结构 typedefstructBiNode { chardata; //此处，二叉树中节点值类型为字符型 struct...
二叉树的递归与非递归实现
fangfang_666的博客
09-25 748
本文实现了二叉树的创建及其成员函数的实现 成员函数包括： 1)构造函数 2)拷贝构造函数 3)赋值运算符重载 4)先序遍历（先根遍历）（递归与非递归） 5)中序遍历（递归与非递归） 6)后序遍历（后根遍历）（递归与非递归） 7)层序遍历 8)节点个数 9)叶子节点个数 10)二叉树深度 11)查找二叉树节点 12)第k层节点的个数（两种方法） 二叉树的实现：
二叉树的遍历方式——递归与非递归
最新发布
m0_73771309的博客
07-30 719
定义了一个结构体类型BiNode，包含节点的值、左子树和右子树三个成员变量；同时，定义了指向结构体类型BiNode的指针类型BiTree。代码如下：下面结构体里面的value不一定非要是int类型，可以是任意类型。int value;对于二叉树的遍历问题，递归方式通常更简洁，可读性更好，更容易去理解；非递归方式则具有更小的空间开销和更高的效率。具体使用哪种方式可以根据实际需求、问题规模和性能要求来选择。以后也会持续更新！！！成功不是将来才有的，而是从决定去做的那一刻起，持续累积而成。
二叉树递归和非递归遍历以及层次构建节点数为n的二叉树
12-17
二种非递归实现 二叉树中序遍历： 递归实现 非递归实现 二叉树后序遍历： 递归实现 非递归实现 二叉树层次遍历 二叉树层次创建，创建方法遵循卡特兰数 http://write.blog.csdn.net/postedit/17380455
二叉树递归与非递归遍历
11-03
这三种遍历方式都分为递归和非递归两种实现方式。 **递归遍历** 1. **前序遍历**： - 访问根节点。 - 递归遍历左子树。 - 递归遍历右子树。 2. **中序遍历**： - 递归遍历左子树。 - 访问根节点。 - 递归...
C++基于递归和非递归算法求二叉树镜像的方法
08-30
基于递归和非递归算法求二叉树镜像的方法 本文主要介绍了C++语言中基于递归和非递归算法求二叉树镜像的方法。二叉树镜像是指将二叉树的左右子树交换，使其成为镜像的过程。本文将详细讲述递归和非递归算法的实现与...
二叉树递归和非递归遍历时需要注意的事项及解决方案，1500字
05-24
递归和非递归遍历都是二叉树遍历的常见方式。本文将介绍在进行二叉树递归和非递归遍历时需要注意的事项及解决方案。 一、二叉树递归遍历需要注意的事项及解决方案 1.堆栈溢出问题 在进行二叉树递归遍历时，由于每...
二叉树的深度(递归和非递归)
liu_12345_liu的博客
11-24 604
一共两种实现方法， 第一种使用递归进行遍历，取左右子树最大的深度加一。 第二种实现方式，使用队列进行广度优先遍历。每遍历一层给深度加一 // 树的节点 public class TreeNode { int mValue; TreeNode mLeftNode; TreeNode mRightNode; public TreeNode(int val) { ...
二叉树的遍历(递归+非递归 Java版)
11-05
结构清晰地介绍了二叉树的遍历方法 前序 中序 后序 都有，附带详细的注释，希望像能对和我一样入门级的朋友们有所帮助
非递归中序遍历二叉树
10-22
非递归中序遍历二叉树
二叉树的各种递归和非递归遍历
qq_21227987的博客
04-29 170
package com.tree;import java.util.LinkedList; import java.util.Scanner; import java.util.Stack;class BiTree { BiTree lchild; BiTree rchild; String data; }public class BiTreeTest { stati
（算法整理）二叉树的递归与非递归遍历算法
Little_Fire的博客
06-17 368
树形结构的考察在数据结构预算法中一直占有很重要的地位，二叉树的遍历一直是最基本的算法，众所周知，二叉树的遍历主要分为前序、中序、后序这三种，且三种遍历方式都存在递归与非递归两种形式，这里做一下整理与总结。这里先定义一下二叉树结点的数据结构：struct TreeNode { int val; struct TreeNode* left = NULL; struct TreeNode* rig...
二叉树的三种遍历，递归和非递归
编程_随笔点滴
07-14 769
递归转非递归，用到了栈的前进后出的特点，使得保存当前函数的状态 前序遍历，每次的操作：从根节点向左遍历，每次使用栈进行存储，直到空指针，则指向该结点的有孩子 中序遍历，每次的操作：从根节点向左遍历，每次使用栈进行存储，直到空指针，则指向该结点的有孩子 后序遍历，每次的操作：从根节点向左遍历，每次使用栈进行存储，直到空指针，输出的时候判断该节点如果没有右孩子或者右子树被访问过了，则可以输出该...
二叉排序树递归非递归算法性能对比
qq_40192867的博客
01-17 691
#include#includeusing namespace std; typedef long ElemType;typedef class BinarySearchTree_Node{   public:       ElemTypedata;   BinarySearchTree_Node *left, *right;}BinarySearchTree_T, *BinarySearchTr
二叉树的递归遍历与非递归遍历
Joy_Dang的博客
07-27 1820
二叉树的遍历有递归与非递归两种方式，但思想大致相同 前序：先打印然后遍历完他的左子树，左子树为空时开始返回，并且开始以栈中元素为根遍历右子树 中序：先遍历左子树然后左子树入栈，左子树为空再打印，再遍历右子树 后序：先遍历完左子树，左子树入栈保存，再遍历右子树，遍历完打印，否则继续入栈 递归遍历 //递归遍历 //遍历树 //前序 void PreOder1(Tree *root) { ...
二叉树各种遍历方式（递归与非递归）
醉如泥的博客
09-16 584
二叉树简述 1、第i层至多有2的i-1次方个结点； 2、深度为k的二叉树至多有2^(k)-1个结点； 3、叶子结点个数为n，双结点个数为m，则 n= m+1 4、递归遍历方式代码简单，效率低；非递归遍历方式代码较复杂，效率高 5、层序遍历需要借助（queue）实现，前、中、后序遍历需借助栈（stack）实现。 节点定义 typedef struct N...
面试题--给40亿个不重复的，没有排过序，给一个无符号整数，如何判断这个数在这40亿个数中
f2016913的博客
04-23 3590
如果常规的想法是给这40亿数，放到一个很大的数组中，快速排序，然后采用二分查找，来判断这个数是否存在； 但是计算机的内存就是4G，大小差不多刚好是2^32大约为42亿左右，一个整形4个字节，40亿数大约需要16G个字节，在现实基本不可能实现，那么该如何存储呢？ 方法：位存储 一个整形32个位，16G个字节只需要500M就可以，然后设置比特位1表示这个数存在，0表示这个数不存在。#include
C语言实现二叉树递归与非递归遍历
"这篇资源包含了C语言实现的二叉树三种遍历方法——前序遍历、中序遍历和后序遍历的递归和非递归版本。" 二叉树是计算机科学中一种重要的数据结构，它由节点构成，每个节点包含一个数据元素以及两个指向其他节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值