二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)

最新推荐文章于 2024-08-15 17:11:26 发布
最新推荐文章于 2024-08-15 17:11:26 发布
阅读量1.3k 收藏 2
点赞数
文章标签： 算法 null reference 测试 数据结构 编译器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snlying/article/details/4724338
版权

费了两天时间写的,包括前中后序遍历的递归和非递归算法,还有层序遍历总共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;
}

posted on 2006-07-08 15:21 那谁 阅读(4338) 评论(8)  编辑 收藏 引用 所属分类: 算法与数据结构

<script type="text/javascript"></script>

# re: 二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)  回复  更多评论   

你好,我是新手,在用VC调试时发现错误
f:/hwh/二叉树/binarytree.h(64) : error C2027: use of undefined type 'BinaryTree'
f:/hwh/二叉树/binarytree.h(8) : see declaration of 'BinaryTree'
main.cpp
f:/hwh/二叉树/binarytree.h(64) : error C2027: use of undefined type 'BinaryTree'
f:/hwh/二叉树/binarytree.h(8) : see declaration of 'BinaryTree'
执行 cl.exe 时出错.

二叉树.exe - 1 error(s), 0 warning(s)
为什么呢?
2007-12-25 11:37 | tomy

# re: 二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)  回复  更多评论   

@tomy
你用的什么编译器?我用的VS2003,其次,你的工程里面有几个文件?这里一共有三个文件:binarytree.h,binarytree.cpp,main.cpp
2007-12-26 11:18 | 创系

# re: 二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)[未登录]  回复  更多评论   

我用DEV C++编译后报以下信息,请指教:

C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/cceIaaaa.o(.text+0x52d):main.cpp: undefined reference to `BinaryTree::Traverse(BinaryTree::TraverseType, bool)'
C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/cceIaaaa.o(.text+0x62f):main.cpp: more undefined references to `BinaryTree::Traverse(BinaryTree::TraverseType, bool)' follow
C:/DOCUME~1/ADMINI~1/LOCALS~1/Temp/cceIaaaa.o(.text+0x676):main.cpp: undefined reference to `BinaryTree::~BinaryTree()'
collect2: ld returned 1 exit status
2008-01-06 01:10 | ben

# re: 二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)  回复  更多评论   

楼上的错误是DEV C++的工程文件/配置文件的问题吧?
2008-01-06 01:23 | <a href=http://minidx.com>minidxer</a>

# re: 二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)[未登录]  回复  更多评论   

已经解决了,谢谢指点!
2008-01-06 15:19 | ben

# re: 二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)  回复  更多评论   

请问，为什么我的窗口上什么都米有？只有一个“请按任意键继续”，用的是VC++ 2008
2008-07-09 07:03 | liuyu

# re: 二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)  回复  更多评论   

其实如果不用 Stack 而改用 List 的话，三种非递归遍历将变得更加简单一致，一个 While 就够了

typedef std::list<BinaryTree::PTreeNode> TreeNodeList;

typedef struct TreeNode
{
Item Node;
TreeNode* pRight;
TreeNode* pLeft;
bool bVisited; // 关键

TreeNode(Item node = 0, TreeNode* pright = NULL, TreeNode* pleft = NULL)
: Node(node)
, pRight(pright)
, pLeft(pleft)
, bVisited(false)
{
}

}TreeNode, *PTreeNode;




// 非递归前序遍历树
void BinaryTree::NoRecPreTraverseImpl(PTreeNode pTreenode)
{
if (NULL == pTreenode)
return;

TreeNodeList NodeList;
PTreeNode pNode;
NodeList.push_front(pTreenode);

while (!NodeList.empty())
{
pNode = NodeList.front();
NodeList.pop_front();

std::cout << "Item = " << pNode->Node << std::endl;

if(pNode->pRight != NULL) NodeList.push_front(pNode->pRight);
if(pNode->pLeft != NULL) NodeList.push_front(pNode->pLeft);
}
}


// 非递归中序遍历树
void BinaryTree::NoRecInTraverseImpl(PTreeNode pTreenode)
{
if (NULL == pTreenode)
return;

TreeNodeList NodeList;
PTreeNode pNode;
NodeList.push_front(pTreenode);

while (!NodeList.empty())
{
pNode = NodeList.front();

if(pNode->bVisited)
{
NodeList.pop_front();
pNode->bVisited = false; // 为下一次遍历做准备

std::cout << "Item = " << pNode->Node << std::endl;

if(pNode->pRight != NULL) NodeList.push_front(pNode->pRight);
}
else
{
if(pNode->pLeft != NULL) NodeList.push_front(pNode->pLeft);
pNode->bVisited = true;
}

}
}

// 非递归后序遍历树
void BinaryTree::NoRecPostTraverseImpl(PTreeNode pTreenode)
{
if (NULL == pTreenode)
return;

TreeNodeList NodeList;
PTreeNode pNode;
NodeList.push_front(pTreenode);

while (!NodeList.empty())
{
pNode = NodeList.front();

if(pNode->bVisited)
{
NodeList.pop_front();
pNode->bVisited = false; // 为下一次遍历做准备

std::cout << "Item = " << pNode->Node << std::endl;
}
else
{
if(pNode->pRight != NULL) NodeList.push_front(pNode->pRight);
if(pNode->pLeft != NULL) NodeList.push_front(pNode->pLeft);
pNode->bVisited = true;
}

}
}
#  re: 二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)   回复   更多评论   

snlying
关注
二叉树前序、中序、后遍历的递归和非递归的实现
weixin_44118591的博客
01-05 467
二叉树前序、中序、后遍历的递归和非递归的实现 1.二叉树的先序遍历 ①递归方式 ②非递归方式 (1)思路 首先准备一个栈， 遍历一开始，先把根节点放到栈里面去，然后就是固定流程： 每次从栈中弹出一个节点，记为cur； 打印cur(或者说处理cur)； 先把cur右孩子压到栈里面去，再把cur左孩子压到栈里面去，如果有的话； 周而复始前三步。 当栈为空时，整个遍历过程结束。 (2)图解过程 初始时，根节点1进栈； 节点1出栈，并打印，同时节点1的右孩子先进栈，然后其左孩子再进栈；
二叉树先序遍历、中序遍历和后序遍历非递归算法 C++源码
08-25
用C++写的二叉树先序遍历、中序遍历和后序遍历非递归算法
二叉树的基本操作，包括前序、中序、后序遍历的递归和非递归算法
10-21
二叉树的基本操作，包括前序、中序、后序遍历的递归和非递归算法，不得不下的资源
【数据结构】二叉树(前、中、后）序遍历的递归与非递归算法
weixin_33711647的博客
04-22 160
对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对 于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中，前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一 点。二叉树前序：访问根节点->左子树->右子树（1）递归写法：依次访问根节点...
【数据结构】二叉树（二）遍历
最新发布
m0_73107796的博客
08-15 1613
讲解二叉树的前序遍历、中序遍历、后序遍历及层序遍历的递归与非递归遍历方法。
二叉树的先中后序遍历的递归和非递归实现
dressrosa
03-15 737
二叉树的遍历真的很有意思，而且递归和非递归的实现的思想都很精妙。真心觉得创造出这种数据结构的人是多么炫酷。 二叉树的遍历就是把所有节点都走一遍，通常有三种遍历方式，先序遍历：中左右；中序遍历：左中右；后序遍历：左右中 这些原理当然没啥深究的，记住就行。 #include #include #include //二叉树 typedef struct ErNode { int data
先序遍历非递归算法_二叉树的前序、中序、后序遍历的递归和非递归实现
weixin_39641231的博客
11-24 88
package
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
12-20
这些遍历方法在数据结构和算法领域中有着广泛的应用，例如在编译器、文件系统和搜索算法中。 1. **前序遍历**： 前序遍历的顺序是：根节点 -> 左子树 -> 右子树。在非递归实现中，可以利用栈（先进后出）的特点来...
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
本文将深入探讨Python中的二叉树及其遍历方法，包括前序遍历、中序遍历、后序遍历以及层序遍历。通过具体的代码示例，我们将更好地理解这些遍历方法的工作原理和应用场景。 #### 二、二叉树基础知识回顾 二叉树是由...
二叉树的非递归后序遍历算法实例详解
01-19
前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。方法有很多，这里只举一种，先定义栈结点的数据结构 代码如下:typedef struct{...
非递归前序,中序,后序遍历二叉树(优化算法).rar_nooneyh_二叉树 非递归_前序 中序 后序_树遍历算法_遍历二叉树
09-14
对于二叉树的非递归遍历算法，除了优化栈空间使用之外，还有助于理解和实现其他数据结构，如线索二叉树，以及在实际问题中的应用，如序列化和反序列化二叉树。这些算法在面试中也经常被问到，是每个程序员应该掌握的...
c语言实现二叉树的前中后序遍历 递归和非递归 数据结构
03-23
1.输入前序和中序遍历结果，建立二叉树 2.实现二叉树的三种递归遍历算方法 3.实现二叉树的三种非递归遍历算法 4.实现二叉树的旋转90°后的打印，直观树形结构
二叉树的前中后序遍历的递归与迭代算法
qq_45043381的博客
09-06 629
一，递归算法 二叉树的前、中、后序遍历的思路和程序都非常简单。 前中后序遍历的算法结构相同，只需要调整打印的位置。 前序遍历：打印根-访问左子树-访问右子树 中序遍历：访问左子树-打印根-访问右子树 后序遍历：访问左子树-访问右子树-打印根 ????遍历二叉树的算法中的基本操作是访问结点，所以不论是按照哪一种依次进行遍历，对有n个结点的二叉树，其时间复杂度为O(n). ????由于是该算法是递归调用，所需辅助空间是遍历过程中栈的最大容量，即树的深度；一般情况下为O(logn)；最坏情况下树的深度为n，则此时
二叉树的前序遍历、中序遍历和后序遍历的递归和非递归算法
bbewx的专栏
05-25 1070
本文对二叉树的前序遍历、中序遍历、后
二叉树的前中后序遍历：递归法+迭代法
尚墨1111的博客
09-27 466
文章目录前言一、二叉树的代码二、递归法1.二叉树的前、中、后序的递归遍历三、迭代法1.前序遍历2.后序遍历2.中序遍历总结扩展：判断单值二叉树 前言 本文总结自LeetCode的题库，其中代码参考题解，题解中还有许多其他的方法，本文代码以简洁易理解为基本要求。这里也不对二叉树的基本知识进行讲解，只对实现的代码进行解释介绍 提示：以下是本篇文章正文内容，下面案例可供参考 一、二叉树的代码 二叉树节点的最简单结构 class TreeNode { int val; TreeNode le.
二叉树前序遍历、中序遍历、后序遍历递归以及非递归算法详解以及代码整合
朱子恒的博客
12-08 1764
引文 对二叉树的前中后序递归以及非递归算法以及层序遍历思想做了整合 因为某些书籍上对这类算法，写的非常笼统，所以，这里将从树的链式存储开始，结合整个 链表、栈、队列等结构来完成对树的学习，当然，这里也将会完美的列出所用的栈、队列等结构，直接复制代码即可运行。 说明：下面代码 在定义的时候可能不会遵循一般的编程规范，比如这些愚蠢的结构体的名字(因为这就是为了考试用的)。请已经工作了的童鞋理解(虽然我自己都非常想吐槽)
二叉树的前中后序的非递归遍历算法。
ProfeSir的博客
07-30 476
今天把二叉树的非递归遍历算法复习了下，在这总结下。 三个算法都使用了栈，中序和前序遍历算法大致相同，而后序遍历稍微复杂一点。 先写中序遍历。 //S是 栈，存储结点，t是树的根结点 Inorder(t) //创建栈，将跟结点赋给临时结点p Create(S),p = t; //如果根为空，返回 IF t = null THEN　RETURN WHILE p!= n
层序遍历
柴柴柴宝宝宝的博客
03-07 524
先序非递归遍历算法遍历二叉树 ​中序非递归遍历算法遍历二叉树 ​后序非递归遍历算法遍历二叉树 ​层序遍历二叉树
05-09
好的，我可以给您介绍一下二叉树的四种非递归遍历算法以及层序遍历。 先序非递归遍历算法： 1. 新建一个栈，将根节点入栈。 2. 当栈不为空时，取出栈顶元素并访问它。 3. 将当前节点的右子节点（如果存在）入栈，再...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值