二叉树的各种遍历

最新推荐文章于 2024-01-28 12:01:16 发布
最新推荐文章于 2024-01-28 12:01:16 发布
阅读量499 收藏 1
点赞数
文章标签： null 算法 测试 delete struct system
 

费了两天时间写的,包括前中后序遍历的递归和非递归算法,还有层序遍历总共2*3 + 1 = 7中遍历二叉树的算法,感觉其中后序遍历的非递归算法比较困难,想了很久最后的实现还是不够优雅,请大家指正~~

总共三个文件,一个头文件,一个对应的cpp文件,还有一个用于测试的文件.

头文件:
/**//********************************************************************
    created:    2006/07/04
    filename:     BinaryTree.h
    author:        李创
 http://www.cppblog.com/converse/
 
   purpose:    演示二叉树的算法
*********************************************************************/

#ifndef BinaryTree_H
#define BinaryTree_H

#include <stdlib.h>
#include <stack>

class BinaryTree
{
private:
    typedef int Item;
    typedef struct TreeNode
    {
        Item        Node;
        TreeNode*   pRight;
        TreeNode*   pLeft;
  
        TreeNode(Item node = 0, TreeNode* pright = NULL, TreeNode* pleft = NULL)
            : Node(node)
            , pRight(pright)
            , pLeft(pleft)
        {
        }
  
    }TreeNode, *PTreeNode;
 
public:
    enum TraverseType
    {
        PREORDER    = 0,        // 前序
   INORDER        = 1,        // 中序
   POSTORDER    = 2,        // 后序
   LEVELORDER    = 3            // 层序
    };
 
    BinaryTree(Item Array[], int nLength);
    ~BinaryTree();
 
    PTreeNode GetRoot()
    {
        return m_pRoot;
    }
 
    // 遍历树的对外接口
    // 指定遍历类型和是否是非递归遍历,默认是递归遍历
    void Traverse(TraverseType traversetype, bool bRec = true);
 
private:
    PTreeNode   CreateTreeImpl(Item Array[], int nLength);
    void        DetroyTreeImpl(PTreeNode pTreenode);
 
    void        PreTraverseImpl(PTreeNode pTreenode);        // 递归前序遍历树
    void        InTraverseImpl(PTreeNode pTreenode);        // 递归中序遍历树
    void        PostTraverseImpl(PTreeNode pTreenode);        // 递归后序遍历树
 
    void        NoRecPreTraverseImpl(PTreeNode pTreenode);    // 非递归前序遍历树
    void        NoRecInTraverseImpl(PTreeNode pTreenode);    // 非递归中序遍历树
    void        NoRecPostTraverseImpl(PTreeNode pTreenode);    // 非递归后序遍历树
 
    void        LevelTraverseImpl(PTreeNode pTreenode);
 
    PTreeNode   m_pRoot;        // 根结点
 
    // 采用STL里面的stack作为模拟保存链表结点的stack容器
    typedef std::stack<BinaryTree::PTreeNode> TreeNodeStack;
};

#endif

实现文件:
/**//********************************************************************
    created:    2006/07/04
    filename:     BinaryTree.cpp
    author:        李创
 http://www.cppblog.com/converse/
 
   purpose:    演示二叉树的算法
*********************************************************************/

#include <iostream>
#include <assert.h>
#include <queue>
#include "BinaryTree.h"

BinaryTree::BinaryTree(Item Array[], int nLength)
: m_pRoot(NULL)
{
    assert(NULL != Array);
    assert(nLength > 0);
 
    m_pRoot = CreateTreeImpl(Array, nLength);
}

BinaryTree::~BinaryTree()
{
    DetroyTreeImpl(m_pRoot);
}

// 按照中序递归创建树
BinaryTree::PTreeNode BinaryTree::CreateTreeImpl(Item Array[], int nLength)
{
    int mid = nLength / 2;
    PTreeNode p = new TreeNode(Array[mid]);
 
    if (nLength > 1)
    {
        p->pLeft    = CreateTreeImpl(Array, nLength / 2);
        p->pRight   = CreateTreeImpl(Array + mid + 1, nLength / 2 - 1);
    }
 
    return p;
}

void BinaryTree::DetroyTreeImpl(PTreeNode pTreenode)
{
    if (NULL != pTreenode->pLeft)
    {
        DetroyTreeImpl(pTreenode->pLeft);
    }
    if (NULL != pTreenode->pRight)
    {
        DetroyTreeImpl(pTreenode->pRight);
    }
 
    delete pTreenode;
    pTreenode = NULL;
}

// 遍历树的对外接口
// 指定遍历类型和是否是非递归遍历,默认是递归遍历
void BinaryTree::Traverse(TraverseType traversetype, bool bRec /**//*= true*/)
{
    switch (traversetype)
    {
    case PREORDER:    // 前序
        {           
            if (true == bRec)
            {
                std::cout << "递归前序遍历树\n";
                PreTraverseImpl(m_pRoot);
            }
            else
            {
                std::cout << "非递归前序遍历树\n";
                NoRecPreTraverseImpl(m_pRoot);
            }
        }
        break;
  
    case INORDER:    // 中序
        {           
            if (true == bRec)
            {
                std::cout << "递归中序遍历树\n";
                InTraverseImpl(m_pRoot);
            }
            else
            {
                std::cout << "非递归中序遍历树\n";
                NoRecInTraverseImpl(m_pRoot);
            }
        }
        break;
  
    case POSTORDER:    // 后序
        {           
            if (true == bRec)
            {
                std::cout << "递归后序遍历树\n";
                PostTraverseImpl(m_pRoot);
            }
            else
            {
                std::cout << "非递归后序遍历树\n";
                NoRecPostTraverseImpl(m_pRoot);
            }
        }
        break;
  
    case LEVELORDER:    // 层序
        {
            std::cout << "层序遍历树\n";
            LevelTraverseImpl(m_pRoot);
        }
    }
 
    std::cout << std::endl;
}

// 递归前序遍历树
void BinaryTree::PreTraverseImpl(PTreeNode pTreenode)
{
    if (NULL == pTreenode)
        return;
 
    std::cout << "Item = " << pTreenode->Node << std::endl;
 
    PreTraverseImpl(pTreenode->pLeft);
 
    PreTraverseImpl(pTreenode->pRight);
}

// 非递归前序遍历树
void BinaryTree::NoRecPreTraverseImpl(PTreeNode pTreenode)
{
    if (NULL == pTreenode)
        return;
 
    TreeNodeStack NodeStack;
    PTreeNode pNode;
    NodeStack.push(pTreenode);
 
    while (!NodeStack.empty())
    {
        while (NULL != (pNode = NodeStack.top()))    // 向左走到尽头
        {
            std::cout << "Item = " << pNode->Node << std::endl;    // 访问当前结点
            NodeStack.push(pNode->pLeft);                    // 左子树根结点入栈
        }
        NodeStack.pop();                                    // 左子树根结点退栈
        if (!NodeStack.empty())
        {
            pNode = NodeStack.top();
            NodeStack.pop();                                // 当前结点退栈
            NodeStack.push(pNode->pRight);                // 当前结点的右子树根结点入栈
        }
    }
}

// 中序遍历树
// 中序遍历输出的结果应该和用来初始化树的数组的排列顺序一致
void BinaryTree::InTraverseImpl(PTreeNode pTreenode)
{
    if (NULL == pTreenode)
        return;
 
    if (NULL != pTreenode->pLeft)
    {
        InTraverseImpl(pTreenode->pLeft);
    }
 
    std::cout << "Item = " << pTreenode->Node << std::endl;
 
    if (NULL != pTreenode->pRight)
    {
        InTraverseImpl(pTreenode->pRight);
    }
}

// 非递归中序遍历树
void BinaryTree::NoRecInTraverseImpl(PTreeNode pTreenode)
{
    if (NULL == pTreenode)
        return;
 
    TreeNodeStack NodeStack;
    PTreeNode pNode;
    NodeStack.push(pTreenode);
 
    while (!NodeStack.empty())
    {
        while (NULL != (pNode = NodeStack.top()))    // 向左走到尽头
        {
            NodeStack.push(pNode->pLeft);
        }
  
        NodeStack.pop();
  
        if (!NodeStack.empty() && NULL != (pNode = NodeStack.top()))
        {
            std::cout << "Item = " << pNode->Node << std::endl;
            NodeStack.pop();
            NodeStack.push(pNode->pRight);
        }
    }
}

// 后序遍历树
void BinaryTree::PostTraverseImpl(PTreeNode pTreenode)
{
    if (NULL == pTreenode)
        return;
 
    if (NULL != pTreenode->pLeft)
    {
        PostTraverseImpl(pTreenode->pLeft);
    }
 
    if (NULL != pTreenode->pRight)
    {
        PostTraverseImpl(pTreenode->pRight);
    }
 
    std::cout << "Item = " << pTreenode->Node << std::endl;
}

// 非递归后序遍历树
void BinaryTree::NoRecPostTraverseImpl(PTreeNode pTreenode)
{
    if (NULL == pTreenode)
        return;
 
    TreeNodeStack NodeStack;
    PTreeNode pNode1, pNode2;
    NodeStack.push(pTreenode);
    pNode1 = pTreenode->pLeft;
   
    bool bVisitRoot = false;            // 标志位,是否访问过根结点
    while (!NodeStack.empty())
    {
        while (NULL != pNode1)            // 向左走到尽头
        {
            NodeStack.push(pNode1);
            pNode1 = pNode1->pLeft;
        }
  
        pNode1 = NodeStack.top();
        NodeStack.pop();
  
        if (NULL == pNode1->pRight)            // 如果没有右子树就是叶子结点
        {
            std::cout << "Item = " << pNode1->Node << std::endl;
            pNode2 = pNode1;
            pNode1 = NodeStack.top();
   
            if (pNode2 == pNode1->pRight)    // 如果这个叶子结点是右子树
            {
                std::cout << "Item = " << pNode1->Node << std::endl;
                NodeStack.pop();
                pNode1 = NULL;
            }
            else                            // 否则访问右子树
            {
                pNode1 = pNode1->pRight;
            }
        }
        else                                // 访问右子树
        {
            if (pNode1 == pTreenode && true == bVisitRoot)    // 如果已经访问过右子树那么就退出
            {
                std::cout << "Item = " << pNode1->Node << std::endl;
                return;
            }
            else
            {
                if (pNode1 == pTreenode)
                {
                    bVisitRoot = true;
                }
    
                NodeStack.push(pNode1);
                pNode1 = pNode1->pRight;
            }
        }
    }
}

// 按照树的层次从左到右访问树的结点
void BinaryTree::LevelTraverseImpl(PTreeNode pTreenode)
{
    if (NULL == pTreenode)
        return;
 
    // 层序遍历用于保存结点的容器是队列
    std::queue<PTreeNode> NodeQueue;
    PTreeNode pNode;
    NodeQueue.push(pTreenode);
 
    while (!NodeQueue.empty())
    {
        pNode = NodeQueue.front();
        NodeQueue.pop();
        std::cout << "Item = " << pNode->Node << std::endl;
  
        if (NULL != pNode->pLeft)
        {
            NodeQueue.push(pNode->pLeft);   
        }
        if (NULL != pNode->pRight)
        {
            NodeQueue.push(pNode->pRight);
        }   
    }
}
测试文件:
/**//********************************************************************
    created:    2006/07/04
    filename:     main.cpp
    author:        李创
 http://www.cppblog.com/converse/
 
   purpose:    测试二叉树的算法
*********************************************************************/

#include "BinaryTree.h"

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>

void DisplayArray(int array[], int length)
{
    int i;
 
    for (i = 0; i < length; i++)
    {
        printf("array[%d] = %d\n", i, array[i]);
    }
}

void CreateNewArray(int array[], int length)
{
    for (int i = 0; i < length; i++)
    {
        array[i] = rand() % 256 + i;
    }
}

int main()
{
    int array[10];
    srand(time(NULL));
 
    // 创建数组
    CreateNewArray(array, 10);
    DisplayArray(array, 10);
 
    BinaryTree *pTree = new BinaryTree(array, 10);
 
    // 测试前序遍历
    pTree->Traverse(BinaryTree::PREORDER);
    std::cout << "root = " << pTree->GetRoot()->Node << std::endl;
    std::cout << "root->left = " << pTree->GetRoot()->pLeft->Node << std::endl;
    std::cout << "root->right = " << pTree->GetRoot()->pRight->Node << std::endl;
    pTree->Traverse(BinaryTree::PREORDER, false);
   
    // 测试中序遍历
    pTree->Traverse(BinaryTree::INORDER);
    std::cout << "root = " << pTree->GetRoot()->Node << std::endl;
    std::cout << "root->left = " << pTree->GetRoot()->pLeft->Node << std::endl;
    std::cout << "root->right = " << pTree->GetRoot()->pRight->Node << std::endl;
    pTree->Traverse(BinaryTree::INORDER, false);
    // 测试后序遍历
    pTree->Traverse(BinaryTree::POSTORDER);
    std::cout << "root = " << pTree->GetRoot()->Node << std::endl;
    std::cout << "root->left = " << pTree->GetRoot()->pLeft->Node << std::endl;
    std::cout << "root->right = " << pTree->GetRoot()->pRight->Node << std::endl;
    pTree->Traverse(BinaryTree::POSTORDER, false);
    // 测试层序遍历
    pTree->Traverse(BinaryTree::LEVELORDER);
 
    system("pause");
   
    delete pTree;
 
    return 0;
}

 

rtyytr
关注
树的遍历算法
medouyoulo的博客
07-12 3867
树的遍历算法Python实现
二叉树各种遍历算法的C++实现
05-19
二叉树是计算机科学中一种重要的数据结构，它由节点（或称为顶点）组成，每个节点最多有两个子节点，通常分为左子节点和右子节点。...在C++中，利用递归和栈的特性，我们可以轻松地实现这些遍历方法，以满足各种需求。
【数据结构】【树的遍历算法】【python】树的各种遍历算法
FQY__的博客
01-28 1516
先将根节点入队，再对队列进行循环操作：如果队列未空，则将队头元素弹出，对队头元素操作，并将其子节点放入对内。如果遇到节点不存在的情况，返回值为0，代表深度为0，否则就返回的是左子树和右子树中深度的最大值。，即以当前节点为例，先遍历左子节点，再是当前节点，再是右子节点。的信息，然后再判断是否有右子节点，并再次递归调用，将函数压入栈。的信息，第三个递归函数执行完成，退栈。
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历.txt
05-20
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历
二叉树的遍历实验报告.pdf
11-11
1. 二叉树遍历的概念与目的： 遍历二叉树是为了访问树中的所有节点，按照特定的顺序执行操作，如查找、插入或删除节点。在二叉树的应用中，遍历常用于解决问题，如查找特定属性的节点，或者对所有节点进行统一处理。...
数据结构课程设计报告-二叉树的遍历.docx
03-07
本报告基于二叉树的遍历方法，旨在通过递归和非递归两种方法创建一棵二叉树，并对其进行先序遍历、中序遍历、后序遍历及层次遍历，并求出该二叉树的深度和叶子结点数。同时，报告还实现了查找功能，能够输入一个结点...
什么是二叉树的遍历以及学习二叉树的遍历的意义
最新发布
05-20
### 二叉树遍历的重要性及其意义 #### 一、二叉树的遍历概念 在探讨二叉树遍历的重要性和意义之前，首先需要明确什么是二叉树的遍历。简单来说，二叉树的遍历就是按照某种确定的顺序访问二叉树中的所有节点的过程...
树的遍历，有递归和非递归两种算法
05-14
树的三种遍历，每种分为递归和非递归，我自己写的， 基本没有错误，
二叉树的实现各种遍历算法
09-29
二叉树的实现各种遍历算法，插入删除成员函数非常全。二叉树的实现各种遍历算法，插入删除成员函数非常全
算法：树的遍历
hefrankeleyn的博客
10-17 114
算法：树的遍历 文章目录算法：树的遍历一、[94. 二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)1.1 解法一：递归求解1.2 解法二：自己维护一个栈二、[144. 二叉树的前序遍历](https://leetcode-cn.com/problems/binary-tree-preorder-traversal/)2.1 解法一：递归求解2.2 解法二：自己维护一个栈三、[590. N 叉树的后序遍历](
树的三种遍历算法
zwz2011303359的博客
03-16 959
#include using namespace std; struct TreeNode; typedef TreeNode *Node; typedef int EleType; struct TreeNode//定义树结构 {  Node Lchild;  Node  Rchil;  EleType date; }; void PreOrderTree(Node nod
算法之树的遍历
撒忆雨
09-21 170
节点定义 class Node { public int val; public List<Node> children; public Node() {} public Node(int _val,List<Node> _children) { val = _val; children = _children; } }; public class TreeNode { int val = 0;
树的通用遍历算法
奋斗吧，少年！
09-11 667
通用树的遍历算法，适合所有的树 /*树的遍历，通用算法*/ #include typedef struct E_node{ char data; struct E_node *child[M];//M为树的度 }E_NODE; void pre_print(E_NODE *T)//前序遍历M次树 { int i; if(T!=NULL) { pr
【树】遍历算法应用
weixin_45765128的博客
03-25 384
输出二叉树中的结点 【算法思想】 输出二叉树中的结点并无次序要求，因此可用三种遍历算法中的任何一种完成，只需将访问操作具体变为输出操作即可。下面给出采用先序遍历实现的算法。 【算法描述】 void PreOrder(BiTree root) /* 先序遍历输出二叉树结点, root 为指向二叉树根结点的指针 */ { if (root != NULL) { prin...
基本算法之树的遍历
Yanyu_123的博客
12-28 103
二叉树的前、中、后序遍历 前言 二叉树是数据结构学习中绕不开的话题。在二叉树的众多题目中，使用dfs（深度优先搜索）和bfs（广度优先搜索）是最常用的，那么学会如何搜索二叉树是必不可少的。 二叉树的搜索分为前，中，后序遍历，又分别对应有递归版本和迭代版本。 前序遍历遵循的原则是：根节点—>左子节点—>右子节点。 中序遍历遵循的原则是：左子节点—>根节点—>右子节点。 后续遍历遵循的原则是：左子节点—>右子节点—>根节点。 代码 #include <bits/stdc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值