二叉树前序、中序、后序遍历非递归写法

最新推荐文章于 2023-01-31 22:58:28 发布
最新推荐文章于 2023-01-31 22:58:28 发布
阅读量600 收藏
点赞数
分类专栏： java 文章标签： 二叉树
转自：http://blog.csdn.net/zhangxiangdavaid/article/details/37115355

前言

在前两篇文章二叉树和二叉搜索树中已经涉及到了二叉树的三种遍历。递归写法，只要理解思想，几行代码。可是非递归写法却很不容易。这里特地总结下，透彻解析它们的非递归写法。其中，中序遍历的非递归写法最简单，后序遍历最难。我们的讨论基础是这样的：    

[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. //Binary Tree Node  
  2. typedef struct node  
  3. {  
  4.     int data;  
  5.     struct node* lchild;  //左孩子  
  6.     struct node* rchild;  //右孩子  
  7. }BTNode;  
//Binary Tree Node
typedef struct node
{
    int data;
    struct node* lchild;  //左孩子
    struct node* rchild;  //右孩子
}BTNode;

首先，有一点是明确的：非递归写法一定会用到栈，这个应该不用太多的解释。我们先看中序遍历：

中序遍历

分析

中序遍历的递归定义：先左子树，后根节点，再右子树。如何写非递归代码呢？一句话：让代码跟着思维走。我们的思维是什么？思维就是中序遍历的路径。假设，你面前有一棵二叉树，现要求你写出它的中序遍历序列。如果你对中序遍历理解透彻的话，你肯定先找到左子树的最下边的节点。那么下面的代码就是理所当然的：

中序代码段(i)    
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. BTNode* p = root;  //p指向树根  
  2. stack<BTNode*> s;  //STL中的栈  
  3. //一直遍历到左子树最下边，边遍历边保存根节点到栈中  
  4. while (p)  
  5. {  
  6.     s.push(p);  
  7.     p = p->lchild;  
  8. }  
BTNode* p = root;  //p指向树根
stack<BTNode*> s;  //STL中的栈
//一直遍历到左子树最下边，边遍历边保存根节点到栈中
while (p)
{
    s.push(p);
    p = p->lchild;
}

保存一路走过的根节点的理由是：中序遍历的需要，遍历完左子树后，需要借助根节点进入右子树。代码走到这里，指针p为空，此时无非两种情况：


说明：

  1. 上图中只给出了必要的节点和边，其它的边和节点与讨论无关，不必画出。
  2. 你可能认为图a中最近保存节点算不得是根节点。如果你看过树、二叉树基础，使用扩充二叉树的概念，就可以解释。总之，不用纠结这个没有意义问题。
  3. 整个二叉树只有一个根节点的情况可以划到图a。
仔细想想，二叉树的左子树，最下边是不是上图两种情况？不管怎样，此时都要出栈，并访问该节点。这个节点就是中序序列的第一个节点。根据我们的思维，代码应该是这样：   
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. p = s.top();  
  2. s.pop();  
  3. cout << p->data;  
p = s.top();
s.pop();
cout << p->data;

我们的思维接着走，两图情形不同得区别对待：
1.图a中访问的是一个左孩子，按中序遍历顺序，接下来应访问它的根节点。也就是图a中的另一个节点，高兴的是它已被保存在栈中。我们只需这样的代码和上一步一样的代码：
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. p = s.top();  
  2. s.pop();  
  3. cout << p->data;  
p = s.top();
s.pop();
cout << p->data;
  
左孩子和根都访问完了，接着就是右孩子了，对吧。接下来只需一句代码：p=p->rchild;在右子树中，又会新一轮的代码段(i)、代码段(ii)……直到栈空且p空。

2.再看图b，由于没有左孩子，根节点就是中序序列中第一个，然后直接是进入右子树：p=p->rchild;在右子树中，又会新一轮的代码段(i)、代码段(ii)……直到栈空且p空。
思维到这里，似乎很不清晰，真的要区分吗？根据图a接下来的代码段(ii)这样的：
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. p = s.top();  
  2. s.pop();  
  3. cout << p->data;  
  4. p = s.top();  
  5. s.pop();  
  6. cout << p->data;  
  7. p = p->rchild;  
p = s.top();
s.pop();
cout << p->data;
p = s.top();
s.pop();
cout << p->data;
p = p->rchild;

根据图b，代码段(ii)又是这样的：
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. p = s.top();  
  2. s.pop();  
  3. cout << p->data;  
  4. p = p->rchild;  
p = s.top();
s.pop();
cout << p->data;
p = p->rchild;

我们可小结下：遍历过程是个循环，并且按代码段(i)、代码段(ii)构成一次循环体，循环直到栈空且p空为止。   
不同的处理方法很让人抓狂，可统一处理吗？真的是可以的！回顾扩充二叉树，是不是每个节点都可以看成是根节点呢？那么，代码只需统一写成图b的这种形式。也就是说代码段(ii)统一是这样的：
中序代码段(ii)   
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. p = s.top();  
  2. s.pop();  
  3. cout << p->data;  
  4. p = p->rchild;  
p = s.top();
s.pop();
cout << p->data;
p = p->rchild;

口说无凭，得经的过理论检验。
图a的代码段(ii)也可写成图b的理由是：由于是叶子节点，p=-=p->rchild;之后p肯定为空。为空，还需经过新一轮的代码段(i)吗？显然不需。(因为不满足循环条件)那就直接进入代码段(ii)。看！最后还是一样的吧。还是连续出栈两次。看到这里，要仔细想想哦！相信你一定会明白的。

这时写出遍历循环体就不难了：     
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. BTNode* p = root;  
  2. stack<BTNode*> s;  
  3. while (!s.empty() || p)  
  4. {  
  5.     //代码段(i)一直遍历到左子树最下边，边遍历边保存根节点到栈中  
  6.     while (p)  
  7.     {  
  8.         s.push(p);  
  9.         p = p->lchild;  
  10.     }  
  11.     //代码段(ii)当p为空时，说明已经到达左子树最下边，这时需要出栈了  
  12.     if (!s.empty())  
  13.     {  
  14.         p = s.top();  
  15.         s.pop();  
  16.         cout << setw(4) << p->data;  
  17.         //进入右子树，开始新的一轮左子树遍历(这是递归的自我实现)  
  18.         p = p->rchild;  
  19.     }  
  20. }  
BTNode* p = root;
stack<BTNode*> s;
while (!s.empty() || p)
{
    //代码段(i)一直遍历到左子树最下边，边遍历边保存根节点到栈中
    while (p)
    {
        s.push(p);
        p = p->lchild;
    }
    //代码段(ii)当p为空时，说明已经到达左子树最下边，这时需要出栈了
    if (!s.empty())
    {
        p = s.top();
        s.pop();
        cout << setw(4) << p->data;
        //进入右子树，开始新的一轮左子树遍历(这是递归的自我实现)
        p = p->rchild;
    }
}

仔细想想，上述代码是不是根据我们的思维走向而写出来的呢？再加上边界条件的检测，中序遍历非递归形式的完整代码是这样的：
中序遍历代码一          
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. //中序遍历  
  2. void InOrderWithoutRecursion1(BTNode* root)  
  3. {  
  4.     //空树  
  5.     if (root == NULL)  
  6.         return;  
  7.     //树非空  
  8.     BTNode* p = root;  
  9.     stack<BTNode*> s;  
  10.     while (!s.empty() || p)  
  11.     {  
  12.         //一直遍历到左子树最下边，边遍历边保存根节点到栈中  
  13.         while (p)  
  14.         {  
  15.             s.push(p);  
  16.             p = p->lchild;  
  17.         }  
  18.         //当p为空时，说明已经到达左子树最下边，这时需要出栈了  
  19.         if (!s.empty())  
  20.         {  
  21.             p = s.top();  
  22.             s.pop();  
  23.             cout << setw(4) << p->data;  
  24.             //进入右子树，开始新的一轮左子树遍历(这是递归的自我实现)  
  25.             p = p->rchild;  
  26.         }  
  27.     }  
  28. }  
//中序遍历
void InOrderWithoutRecursion1(BTNode* root)
{
    //空树
    if (root == NULL)
        return;
    //树非空
    BTNode* p = root;
    stack<BTNode*> s;
    while (!s.empty() || p)
    {
        //一直遍历到左子树最下边，边遍历边保存根节点到栈中
        while (p)
        {
            s.push(p);
            p = p->lchild;
        }
        //当p为空时，说明已经到达左子树最下边，这时需要出栈了
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            cout << setw(4) << p->data;
            //进入右子树，开始新的一轮左子树遍历(这是递归的自我实现)
            p = p->rchild;
        }
    }
}

恭喜你，你已经完成了中序遍历非递归形式的代码了。回顾一下难吗？
接下来的这份代码，本质上是一样的，相信不用我解释，你也能看懂的。
中序遍历代码二   
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. //中序遍历  
  2. void InOrderWithoutRecursion2(BTNode* root)  
  3. {  
  4.     //空树  
  5.     if (root == NULL)  
  6.         return;  
  7.     //树非空  
  8.     BTNode* p = root;  
  9.     stack<BTNode*> s;  
  10.     while (!s.empty() || p)  
  11.     {  
  12.         if (p)  
  13.         {  
  14.             s.push(p);  
  15.             p = p->lchild;  
  16.         }  
  17.         else  
  18.         {  
  19.             p = s.top();  
  20.             s.pop();  
  21.             cout << setw(4) << p->data;  
  22.             p = p->rchild;  
  23.         }  
  24.     }  
  25. }  
//中序遍历
void InOrderWithoutRecursion2(BTNode* root)
{
    //空树
    if (root == NULL)
        return;
    //树非空
    BTNode* p = root;
    stack<BTNode*> s;
    while (!s.empty() || p)
    {
        if (p)
        {
            s.push(p);
            p = p->lchild;
        }
        else
        {
            p = s.top();
            s.pop();
            cout << setw(4) << p->data;
            p = p->rchild;
        }
    }
}

前序遍历

分析
前序遍历的递归定义：先根节点，后左子树，再右子树。有了中序遍历的基础，不用我再像中序遍历那样引导了吧。
首先，我们遍历左子树，边遍历边打印，并把根节点存入栈中，以后需借助这些节点进入右子树开启新一轮的循环。还得重复一句：所有的节点都可看做是根节点。根据思维走向，写出代码段(i):
前序代码段(i)
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. //边遍历边打印，并存入栈中，以后需要借助这些根节点(不要怀疑这种说法哦)进入右子树  
  2. while (p)  
  3. {  
  4.     cout << setw(4) << p->data;  
  5.     s.push(p);  
  6.     p = p->lchild;  
  7. }  
//边遍历边打印，并存入栈中，以后需要借助这些根节点(不要怀疑这种说法哦)进入右子树
while (p)
{
    cout << setw(4) << p->data;
    s.push(p);
    p = p->lchild;
}

接下来就是：出栈，根据栈顶节点进入右子树。
前序代码段(ii)   
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. //当p为空时，说明根和左子树都遍历完了，该进入右子树了  
  2. if (!s.empty())  
  3. {  
  4.     p = s.top();  
  5.     s.pop();  
  6.     p = p->rchild;  
  7. }  
//当p为空时，说明根和左子树都遍历完了，该进入右子树了
if (!s.empty())
{
    p = s.top();
    s.pop();
    p = p->rchild;
}

同样地，代码段(i)(ii)构成了一次完整的循环体。至此，不难写出完整的前序遍历的非递归写法。
前序遍历代码一   
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. void PreOrderWithoutRecursion1(BTNode* root)  
  2. {  
  3.     if (root == NULL)  
  4.         return;  
  5.     BTNode* p = root;  
  6.     stack<BTNode*> s;  
  7.     while (!s.empty() || p)  
  8.     {  
  9.         //边遍历边打印，并存入栈中，以后需要借助这些根节点(不要怀疑这种说法哦)进入右子树  
  10.         while (p)  
  11.         {  
  12.             cout << setw(4) << p->data;  
  13.             s.push(p);  
  14.             p = p->lchild;  
  15.         }  
  16.         //当p为空时，说明根和左子树都遍历完了，该进入右子树了  
  17.         if (!s.empty())  
  18.         {  
  19.             p = s.top();  
  20.             s.pop();  
  21.             p = p->rchild;  
  22.         }  
  23.     }  
  24.     cout << endl;  
  25. }  
void PreOrderWithoutRecursion1(BTNode* root)
{
    if (root == NULL)
        return;
    BTNode* p = root;
    stack<BTNode*> s;
    while (!s.empty() || p)
    {
        //边遍历边打印，并存入栈中，以后需要借助这些根节点(不要怀疑这种说法哦)进入右子树
        while (p)
        {
            cout << setw(4) << p->data;
            s.push(p);
            p = p->lchild;
        }
        //当p为空时，说明根和左子树都遍历完了，该进入右子树了
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
    cout << endl;
}

下面给出，本质是一样的另一段代码：
前序遍历代码二    
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. //前序遍历  
  2. void PreOrderWithoutRecursion2(BTNode* root)  
  3. {  
  4.     if (root == NULL)  
  5.         return;  
  6.     BTNode* p = root;  
  7.     stack<BTNode*> s;  
  8.     while (!s.empty() || p)  
  9.     {  
  10.         if (p)  
  11.         {  
  12.             cout << setw(4) << p->data;  
  13.             s.push(p);  
  14.             p = p->lchild;  
  15.         }  
  16.         else  
  17.         {  
  18.             p = s.top();  
  19.             s.pop();  
  20.             p = p->rchild;  
  21.         }  
  22.     }  
  23.     cout << endl;  
  24. }  
//前序遍历
void PreOrderWithoutRecursion2(BTNode* root)
{
    if (root == NULL)
        return;
    BTNode* p = root;
    stack<BTNode*> s;
    while (!s.empty() || p)
    {
        if (p)
        {
            cout << setw(4) << p->data;
            s.push(p);
            p = p->lchild;
        }
        else
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
    cout << endl;
}

在二叉树中使用的是这样的写法，略有差别，本质上也是一样的：

前序遍历代码三 

[cpp] view plain copy
print ?
  1. void PreOrderWithoutRecursion3(BTNode* root)  
  2. {  
  3.     if (root == NULL)  
  4.         return;  
  5.     stack<BTNode*> s;  
  6.     BTNode* p = root;  
  7.     s.push(root);  
  8.     while (!s.empty())  //循环结束条件与前两种不一样  
  9.     {  
  10.         //这句表明p在循环中总是非空的  
  11.         cout << setw(4) << p->data;  
  12.         /* 
  13.         栈的特点：先进后出 
  14.         先被访问的根节点的右子树后被访问 
  15.         */  
  16.         if (p->rchild)  
  17.             s.push(p->rchild);  
  18.         if (p->lchild)  
  19.             p = p->lchild;  
  20.         else  
  21.         {//左子树访问完了，访问右子树  
  22.             p = s.top();  
  23.             s.pop();  
  24.         }  
  25.     }  
  26.     cout << endl;  
  27. }  
void PreOrderWithoutRecursion3(BTNode* root)
{
    if (root == NULL)
        return;
    stack<BTNode*> s;
    BTNode* p = root;
    s.push(root);
    while (!s.empty())  //循环结束条件与前两种不一样
    {
        //这句表明p在循环中总是非空的
        cout << setw(4) << p->data;
        /*
        栈的特点：先进后出
        先被访问的根节点的右子树后被访问
        */
        if (p->rchild)
            s.push(p->rchild);
        if (p->lchild)
            p = p->lchild;
        else
        {//左子树访问完了，访问右子树
            p = s.top();
            s.pop();
        }
    }
    cout << endl;
}

最后进入最难的后序遍历：

后序遍历

分析
后序遍历递归定义：先左子树，后右子树，再根节点。后序遍历的难点在于：需要判断上次访问的节点是位于左子树，还是右子树。若是位于左子树，则需跳过根节点，先进入右子树，再回头访问根节点；若是位于右子树，则直接访问根节点。直接看代码，代码中有详细的注释。
后序遍历代码一   
[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. //后序遍历  
  2. void PostOrderWithoutRecursion(BTNode* root)  
  3. {  
  4.     if (root == NULL)  
  5.         return;  
  6.     stack<BTNode*> s;  
  7.     //pCur:当前访问节点，pLastVisit:上次访问节点  
  8.     BTNode* pCur, *pLastVisit;  
  9.     //pCur = root;  
  10.     pCur = root;  
  11.     pLastVisit = NULL;  
  12.     //先把pCur移动到左子树最下边  
  13.     while (pCur)  
  14.     {  
  15.         s.push(pCur);  
  16.         pCur = pCur->lchild;  
  17.     }  
  18.     while (!s.empty())  
  19.     {  
  20.         //走到这里，pCur都是空，并已经遍历到左子树底端(看成扩充二叉树，则空，亦是某棵树的左孩子)  
  21.         pCur = s.top();  
  22.         s.pop();  
  23.         //一个根节点被访问的前提是：无右子树或右子树已被访问过  
  24.         if (pCur->rchild == NULL || pCur->rchild == pLastVisit)  
  25.         {  
  26.             cout << setw(4) << pCur->data;  
  27.             //修改最近被访问的节点  
  28.             pLastVisit = pCur;  
  29.         }  
  30.         /*这里的else语句可换成带条件的else if: 
  31.         else if (pCur->lchild == pLastVisit)//若左子树刚被访问过，则需先进入右子树(根节点需再次入栈) 
  32.         因为：上面的条件没通过就一定是下面的条件满足。仔细想想！ 
  33.         */  
  34.         else  
  35.         {  
  36.             //根节点再次入栈  
  37.             s.push(pCur);  
  38.             //进入右子树，且可肯定右子树一定不为空  
  39.             pCur = pCur->rchild;  
  40.             while (pCur)  
  41.             {  
  42.                 s.push(pCur);  
  43.                 pCur = pCur->lchild;  
  44.             }  
  45.         }  
  46.     }  
  47.     cout << endl;  
  48. }  
//后序遍历
void PostOrderWithoutRecursion(BTNode* root)
{
    if (root == NULL)
        return;
    stack<BTNode*> s;
    //pCur:当前访问节点，pLastVisit:上次访问节点
    BTNode* pCur, *pLastVisit;
    //pCur = root;
    pCur = root;
    pLastVisit = NULL;
    //先把pCur移动到左子树最下边
    while (pCur)
    {
        s.push(pCur);
        pCur = pCur->lchild;
    }
    while (!s.empty())
    {
        //走到这里，pCur都是空，并已经遍历到左子树底端(看成扩充二叉树，则空，亦是某棵树的左孩子)
        pCur = s.top();
        s.pop();
        //一个根节点被访问的前提是：无右子树或右子树已被访问过
        if (pCur->rchild == NULL || pCur->rchild == pLastVisit)
        {
            cout << setw(4) << pCur->data;
            //修改最近被访问的节点
            pLastVisit = pCur;
        }
        /*这里的else语句可换成带条件的else if:
        else if (pCur->lchild == pLastVisit)//若左子树刚被访问过，则需先进入右子树(根节点需再次入栈)
        因为：上面的条件没通过就一定是下面的条件满足。仔细想想！
        */
        else
        {
            //根节点再次入栈
            s.push(pCur);
            //进入右子树，且可肯定右子树一定不为空
            pCur = pCur->rchild;
            while (pCur)
            {
                s.push(pCur);
                pCur = pCur->lchild;
            }
        }
    }
    cout << endl;
}

下面给出另一种思路下的代码。它的想法是：给每个节点附加一个标记(left,right)。如果该节点的左子树已被访问过则置标记为left；若右子树被访问过，则置标记为right。显然，只有当节点的标记位是right时，才可访问该节点；否则，必须先进入它的右子树。详细细节看代码中的注释。
后序遍历代码二
[cpp] view plain copy
print ?
  1. //定义枚举类型：Tag  
  2. enum Tag{left,right};  
  3. //自定义新的类型，把二叉树节点和标记封装在一起  
  4. typedef struct  
  5. {  
  6.     BTNode* node;  
  7.     Tag tag;  
  8. }TagNode;      
  9. //后序遍历    
  10. void PostOrderWithoutRecursion2(BTNode* root)  
  11. {  
  12.     if (root == NULL)  
  13.         return;  
  14.     stack<TagNode> s;  
  15.     TagNode tagnode;  
  16.     BTNode* p = root;  
  17.     while (!s.empty() || p)  
  18.     {  
  19.         while (p)  
  20.         {  
  21.             tagnode.node = p;  
  22.             //该节点的左子树被访问过  
  23.             tagnode.tag = Tag::left;  
  24.             s.push(tagnode);  
  25.             p = p->lchild;  
  26.         }  
  27.         tagnode = s.top();  
  28.         s.pop();  
  29.         //左子树被访问过，则还需进入右子树  
  30.         if (tagnode.tag == Tag::left)  
  31.         {  
  32.             //置换标记  
  33.             tagnode.tag = Tag::right;  
  34.             //再次入栈  
  35.             s.push(tagnode);  
  36.             p = tagnode.node;  
  37.             //进入右子树  
  38.             p = p->rchild;  
  39.         }  
  40.         else//右子树已被访问过，则可访问当前节点  
  41.         {  
  42.             cout << setw(4) << (tagnode.node)->data;  
  43.             //置空，再次出栈(这一步是理解的难点)  
  44.             p = NULL;  
  45.         }  
  46.     }  
  47.     cout << endl;  
  48. }<span style=”font-family: ‘Courier New’; ”>  </span>  
//定义枚举类型：Tag
enum Tag{left,right};
//自定义新的类型，把二叉树节点和标记封装在一起
typedef struct
{
    BTNode* node;
    Tag tag;
}TagNode;    
//后序遍历  
void PostOrderWithoutRecursion2(BTNode* root)
{
    if (root == NULL)
        return;
    stack<TagNode> s;
    TagNode tagnode;
    BTNode* p = root;
    while (!s.empty() || p)
    {
        while (p)
        {
            tagnode.node = p;
            //该节点的左子树被访问过
            tagnode.tag = Tag::left;
            s.push(tagnode);
            p = p->lchild;
        }
        tagnode = s.top();
        s.pop();
        //左子树被访问过，则还需进入右子树
        if (tagnode.tag == Tag::left)
        {
            //置换标记
            tagnode.tag = Tag::right;
            //再次入栈
            s.push(tagnode);
            p = tagnode.node;
            //进入右子树
            p = p->rchild;
        }
        else//右子树已被访问过，则可访问当前节点
        {
            cout << setw(4) << (tagnode.node)->data;
            //置空，再次出栈(这一步是理解的难点)
            p = NULL;
        }
    }
    cout << endl;
}<span style="font-family: 'Courier New'; ">  </span>

总结

思维和代码之间总是有巨大的鸿沟。通常是思维正确，清楚，但却不易写出正确的代码。要想越过这鸿沟，只有多尝试、多借鉴，别无它法。
以下几点是理解上述代码的关键：
  1. 所有的节点都可看做是父节点(叶子节点可看做是两个孩子为空的父节点)。
  2. 把同一算法的代码对比着看。在差异中往往可看到算法的本质。
  3. 根据自己的理解，尝试修改代码。写出自己理解下的代码。写成了，那就是真的掌握了。

Devil_Satan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树前序、中序、后序遍历非递归写法的透彻解析
CCPP Blog
07-06 13万+
前言 在前两篇文章二叉树和二叉搜索树中已经涉及到了二叉树的三种遍历。递归写法，只要理解思想，几行代码。可是非递归写法却很不容易。这里特地总结下，透彻解析它们的非递归写法。其中，中序遍历的非递归写法最简单，后序遍历最难。我们的讨论基础是这样的：
二叉树的非递归建立，前序、中序、后序遍历
07-17
关于数据结构实验的二叉树问题
二叉树的遍历(非递归)
m0_61433144的博客
01-09 5454
遍历二叉树, 是指按一定的规则和顺序访问二叉树的所有结点, 使每一个结点都被访问一次, 而且只被访问一次.也可以是NRL, 因为这两种遍历方法都是先访问根结点, 所以没有区别, 掌握其中一种, 另一种也随之掌握.BFS: 是指沿着二叉树的宽度优先遍历二叉树的结点, 即从上到下从左到右逐层遍历二叉树的结点.由于二叉树是非线性结构, 因此, 二叉树的遍历实质上是将二叉树的各个结点排列成一个线性序列.层序遍历就是根据二叉树的结构从上到下从左到右逐层遍历二叉树的结点.给你一棵二叉树的根节点。
二叉树遍历之后序遍历（非递归、递归）入门详解
热门推荐
sunnyoldboy博客
07-28 2万+
二叉树后序遍历不如先序遍历简单，是相对最复杂的一种遍历方法。访问结点的次序是：“左—>右—>根”，也就是首先访问左子树，之后访问右子树，最后访问树根。对于左、右子树而言，其访问的次序依然是“左—>右—>根”。也就是说，对于每一棵子树，都是最后访问树根。...
二叉树的非递归遍历
qq_43169752的博客
09-27 1万+
二叉树的非递归遍历 二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中，前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一点。 ​ 三种遍历方式访问节点的顺序是一致的，不同之处在于，有的遍历流程把访问到的节点暂存起来，达成某种条件后再将节点输出。
非递归中序遍历
tannanxi的博客
04-21 4490
非递归中序遍历 中序遍历的顺序为：左-中-右，通过栈这个数据结构来记录遍历的历史，每个节点按照右-中-左的顺序压栈，整棵树按照右子树-根-左子树的顺序压栈。最后全部pop出来。代码如下： 递归实现： void middleOrder(Node* node) { if (node == nullptr) { return; } middleOrder(nod...
数据结构试验报告用先序中序建立二叉树后序遍历非递归.pdf
09-27
数据结构试验报告用先序中序建立二叉树后序遍历非递归.pdf
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
主要介绍了Python二叉树的遍历操作,结合实例形式分析了Python针对二叉树的前序遍历,中序遍历,后序遍历,层序遍历等相关操作实现技巧,需要的朋友可以参考下
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
12-20
本文实例讲述了PHP基于非递归算法实现先序、中序及后序遍历二叉树操作。分享给大家供大家参考，具体如下： 概述： 二叉树遍历原理如下： 针对上图所示二叉树遍历： 1. 前序遍历：先遍历根结点，然后遍历左子树，...
链表先序建立二叉树，得到中序后序输出，递归和非递归实现(C++代码加设计报告)
07-15
采用二叉链表存储先序建立二叉树，非递归中序遍历二叉树算法实现
【数据结构】题解：二叉树的非递归遍历
qq_66725576的博客
01-31 479
二叉树的非递归实现
【二叉树】（非递归）四种遍历
在校计算机学生，知识分享与学习笔记总结，欢迎指点
06-22 1834
树的概念与结构 二叉树 概念与结构 性质 存储结构 二叉树的遍历 二叉树的定义 前序遍历 中序遍历 后序遍历 层序遍历 二叉搜索树 AVL树 红黑树
数据结构与算法：二叉树的后序非递归遍历详解
weixin_50690285的博客
06-28 1158
数据结构与算法：二叉树的后序非递归遍历详解
非递归实现中序遍历
linminx的博客
04-03 3136
非递归实现中序遍历
二叉树的4种非递归遍历
！
05-01 1562
二叉树的4种非递归遍历，你知道吗？
数据结构--二叉树的非递归遍历
m0_62476845的博客
11-04 989
对于同一个二叉树来说，其先序、中序、后序遍历都是从根节点开始的，且在遍历过程中经过节点的路线也是一样的，只是访问的时机不同而已。无论是递归还是非递归遍历二叉树，由于每个节点仅被访问一次，则无论按哪一种次序进行遍历，对含n个节点的二叉树，其时间复杂性均为O（n）。所需辅助空间为遍历过程中栈的最大容量，即树的深度，最坏情况下为n，即空间复杂度也为O（n）。
详解二叉树非递归三种遍历
weixin_36101480的博客
03-31 273
二叉树遍历有递归，也有非递归。其实他们之前本质是一样的，非递归只是将递归的步骤一步步写出来，所以看了非递归代码之后回想递归代码也更好理解。 一.前序遍历 现在有一棵二叉树，如图（画的不是很好，好像有点歪） 如果是递归代码：就是输出，然后左递归，右递归就结束了。 其实递归就是栈的应用，在这里要引入栈。 假如根结点地址为T，思路就是遍历左孩子入栈，并输出。当左孩子输出完，取栈顶，找右孩子。再遍历右孩...
二叉树遍历的一些非递归算法
m0_66120913的博客
04-30 1万+
非递归的二叉树遍历等算法C语言
二叉树遍历的非递归算法
m0_63223213的博客
08-05 1万+
非递归的算法主要采用的是循环出栈入栈来实现对二叉树的遍历，下面是过程分析
二叉树 前序遍历 中序遍历 后序遍历
最新发布
12-27
二叉树的前序遍历、中序遍历和后序遍历是常见的遍历方式，它们分别按照不同的顺序访问二叉树的节点。下面是它们的介绍和示例： 1. 前序遍历（Preorder Traversal）：先访问根节点，然后递归地前序遍历左子树，最后递归地前序遍历右子树。 示例代码： ```python def preorder_traversal(root): if root is None: return print(root.val) # 访问根节点 preorder_traversal(root.left) # 前序遍历左子树 preorder_traversal(root.right) # 前序遍历右子树 ``` 2. 中序遍历（Inorder Traversal）：先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。 示例代码： ```python def inorder_traversal(root): if root is None: return inorder_traversal(root.left) # 中序遍历左子树 print(root.val) # 访问根节点 inorder_traversal(root.right) # 中序遍历右子树 ``` 3. 后序遍历（Postorder Traversal）：先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问根节点。 示例代码： ```python def postorder_traversal(root): if root is None: return postorder_traversal(root.left) # 后序遍历左子树 postorder_traversal(root.right) # 后序遍历右子树 print(root.val) # 访问根节点 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值