树的遍历算法

最新推荐文章于 2020-12-28 10:54:59 发布
最新推荐文章于 2020-12-28 10:54:59 发布
阅读量3.4k 收藏 2
点赞数
分类专栏： 数据结构算法 文章标签： 算法 null 测试 delete struct system

 

 

/********************************************************************
        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;
}

msnlxl
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IterativeTreeTraversal:树遍历算法的迭代实现
07-02
本文将详细探讨“IterativeTreeTraversal”——即树遍历算法的迭代实现。 1. **前序遍历**：在前序遍历中，我们首先访问根节点，然后遍历左子树，最后遍历右子树。在迭代实现时，我们可以使用栈来辅助完成。首先将...
算法：树的遍历
hefrankeleyn的博客
10-17 94
算法：树的遍历 文章目录算法：树的遍历一、[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 叉树的后序遍历](
基于Python的多叉树遍历算法.zip
10-16
本资料包"基于Python的多叉树遍历算法.zip"主要探讨如何在Python中实现多叉树的遍历算法。下面我们将详细讨论多叉树的概念、遍历方法以及如何用Python来实现这些算法。 一、多叉树的基本概念 多叉树是由节点和边...
数据结构 树 哈夫曼树 遍历算法
04-27
建立一棵二叉链表树，分别输出此先根、中根和后根遍历序列 将上题编程，实现哈夫曼树的构建和哈夫曼编码的设计
MATLAB 遍历算法
01-29
在MATLAB中，遍历算法是一种常用的数据处理和分析技术，尤其在图形遍历、数据结构操作和网络分析中有着广泛的应用。本示例主要关注的是深度优先遍历（Depth First Search, DFS）算法，这是一种在图或树结构中探索...
非递归前序,中序,后序遍历二叉树(优化算法).rar_nooneyh_二叉树 非递归_前序 中序 后序_树遍历算法_遍历二叉树
最新发布
09-14
因此，非递归的遍历算法成为优化的选择。 非递归前序遍历（Preorder Traversal）： 前序遍历的顺序是根节点 -> 左子树 -> 右子树。非递归实现通常采用栈来辅助。首先将根节点压入栈中，然后进入一个循环，每次循环...
树的遍历，有递归和非递归两种算法
05-14
树的三种遍历，每种分为递归和非递归，我自己写的， 基本没有错误，
二叉树的实现各种遍历算法
09-29
二叉树的实现各种遍历算法，插入删除成员函数非常全。二叉树的实现各种遍历算法，插入删除成员函数非常全
树的三种遍历算法
zwz2011303359的博客
03-16 941
#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 153
节点定义 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 656
通用树的遍历算法，适合所有的树 /*树的遍历，通用算法*/ #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 362
输出二叉树中的结点 【算法思想】 输出二叉树中的结点并无次序要求，因此可用三种遍历算法中的任何一种完成，只需将访问操作具体变为输出操作即可。下面给出采用先序遍历实现的算法。 【算法描述】 void PreOrder(BiTree root) /* 先序遍历输出二叉树结点, root 为指向二叉树根结点的指针 */ { if (root != NULL) { prin...
基本算法之树的遍历
Yanyu_123的博客
12-28 77
二叉树的前、中、后序遍历 前言 二叉树是数据结构学习中绕不开的话题。在二叉树的众多题目中，使用dfs（深度优先搜索）和bfs（广度优先搜索）是最常用的，那么学会如何搜索二叉树是必不可少的。 二叉树的搜索分为前，中，后序遍历，又分别对应有递归版本和迭代版本。 前序遍历遵循的原则是：根节点—>左子节点—>右子节点。 中序遍历遵循的原则是：左子节点—>根节点—>右子节点。 后续遍历遵循的原则是：左子节点—>右子节点—>根节点。 代码 #include <bits/stdc
遍历树算法 - Traverse A Tree
weixin_33995481的博客
04-18 290
树的遍历 Tree Traversals let root = { val: 1, left:{ val: 2, left: { val: 3, left: { val: 5 ...
python进阶之数据结构与算法--入门-树的遍历算法精讲
weixin_43520503的博客
05-25 257
前序：     对上一节内容进行补充和说明：     一般树的链式存储结构：         由于一般树不像二叉树那样结构具有很明显的特点（一个节点至多有两个子节点，若有两个节点后者没有节点的称之为完全二叉树，否则称之为不完全二叉树），所以在一个节点处子节点的个数实质上是不确定的，所以，可以在节点中设置列表L专门用来存储其子节点的引用。如图： &n
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值