精华内容
下载资源
问答
  • 在前面先后介绍了二叉树先序遍历的非递归算法和中序遍历的非递归算法,这里则来介绍二叉树后序遍历非递归算法二叉树后序非递归遍历真的非常之 重要,因为它具有独特的特性(文章结尾会阐述),所以,在很多与二叉树...

      在前面先后介绍了二叉树先序遍历的非递归算法中序遍历的非递归算法,这里则来介绍二叉树后序遍历非递归算法,二叉树后序非递归遍历真的非常之

    重要,因为它具有独特的特性(文章结尾会阐述),所以,在很多与二叉树相关的复杂算法中,经常要用到二叉树后序遍历的非递归算法。并且在互联网面试笔

    试也经常考察该算法,所以,我们应该对二叉树后序遍历非递归算法乱熟于心。

      和二叉树先序遍历、中序遍历非递归算法一样,后序遍历非递归算法同样是使用栈来实现:从根结点开始,将所有最左结点全部压栈,每当一个结点出栈时,

    都先扫描该结点的右子树,只有当一个结点的左孩子和右孩子结点均被访问过了,才能访问结点自身。

      二叉树后序遍历非递归算法实现如下:

      

    #include <stdlib.h>
    #include <stdio.h>
    #define MAXSIZE 100
    // 定义结点类型
    typedef struct node
    {
        int data;
        struct node* lchild;
        struct node* rchild;
    } BTnode;
    
    void Postorder(BTnode* t)
    {
        BTnode* Seqstack[MAXSIZE];
        int top = -1;
        int falg = 1;
        BTnode* p;
        if(t != NULL)
        {
            do
            {
                while(t != NULL)                    // 循环,将所有最左结点压栈
                {
                    top ++;
                    Seqstack[top] = t;
                    t = t->lchild;
                }
                flag = 1;                           // 辅助变量flag为1表示当前结点的左孩子为空或者已被访问
                p = NULL;                           // 指针变量p指向当前结点的前驱结点
                while(top > -1&& falg == 1)
                {
                    t = Seqstack[top];              // 注意:这里只是获取栈顶元素,而并没有出栈
                    if(t->rchild == p)              // 如果当前结点右孩子为空,或者已经被访问过,则访问当前结点
                    {
                        top --;                     // 当前结点出栈
                        printf("%d ", p->data);
                        p = t;                      // 指针变量指向当前结点
                    }
                    else                            // 如果当前结点右孩子不为空,则先去处理右孩子
                    {
                        t = t->rchild;              // 处理右孩子
                        flag = 0;                   // *t的左孩子未被访问,flag置为0
                    }
                }
            }while(top > -1)
        }
        
    }

      上面代码实现了二叉树后序遍历非递归算法(重点看懂注释),接下来就说一说前面提到的该算法的一个特性了:就是当访问某个结点时,栈中所保存的元素

    正好是这个结点的所有祖先。那么知道了这个特性,我们就很容易解决下面如下问题:

    (1).当给定一个叶子结点,要求输出该叶子结点的所有祖先

    (2).输出根结点到所有叶子结点的路径

    (3).如果二叉树结点的值是数值,那么求每条路径上值之和,也可以利用二叉树后序遍历的非递归算法这个特性

    转载于:https://www.cnblogs.com/greedyco/p/7187408.html

    展开全文
  • 二叉树中序遍历的非递归算法同样可以使用栈来实现,从根结点开始,将根结点的最左结点全部... 二叉树中序遍历非递归算法实现如下: #include <stdlib.h> #include <stdio.h> #define MAXSIZE 1...

      二叉树中序遍历的非递归算法同样可以使用栈来实现,从根结点开始,将根结点的最左结点全部压栈,当结点p不再有最左结点时,说明结点p没有左孩子,将该结点

    出栈,访问结点p,然后对其右孩子做同样的处理。

      二叉树中序遍历非递归算法实现如下:

    #include <stdlib.h>
    #include <stdio.h>
    #define MAXSIZE 100
    // 定义结点类型
    typedef struct node
    {
        int data;
        struct node* lchild;
        struct node* rchild;
    } BTnode;
    
    void Inorder(BTnode* t)
    {
        BTnode* Seqstack[MAXSIZE];
        int top = -1;
        BTnode* p;
        if(t != NULL)
        {
            p = t;
            while(top > -1 || p != NULL)               
            {
                while(p != NULL)                        // while循环将根结点的最左结点全部压栈
                {
                    top ++;
                    Seqstack[top] = p;
                    p = p->lchild;
                }
                if(top > -1)                            // 当结点p没有最左结点时出栈
                {
                    p = Seqstack[top];
                    printf("%d ", p->data);             // 访问结点p
                    top --;
                    p = p->rchild;                      // 转向处理右孩子结点
                }
            }
        }
    }

     

    转载于:https://www.cnblogs.com/greedyco/p/7182768.html

    展开全文
  • 二叉树遍历非递归算法

    千次阅读 2005-12-12 16:10:00
    给大家一个效率较高的后序遍历非递归算法(c语言编写,本算法不需要改变二叉树的结点结构):typedef struct node { /*二叉树的结点存储类型为链式*/ char data; struct node *lchild,*rchild;}node,*btree;void ...

    给大家一个效率较高的后序遍历非递归算法(c语言编写,本算法不需要改变二叉树的结点结构):

    typedef struct node  { /*二叉树的结点存储类型为链式*/
        char data;
        struct node *lchild,*rchild;
    }node,*btree;

    void backordertraverse(btree t)  {  /*用栈标记法(本人喜欢这样叫)*/
        btree* stack[max_size];
        int tag[max_size],top=0;
        do  {
            while(t)  {  /*由于非地址调用,所以不会改变数根t*/
                top++;
                stack[top]=t;
                tag[top]=0;
                t=t->lchild;
            }
            if(top>0)  {  /*栈不空,为了简洁下面采用了逗号表达式*/
                if(tag[top]==1)  printf("%c ",stack[top].data),top--;
                else  t=stack[top],t=t->rchild,tag[top]=1;
               
             }
        }while(top>0); /*栈不空*/
    }
    =====================================================================
    本贴给出二叉树先序、中序、后序三种遍历的非递归算法,此三个算法可视为标准算法。
    1.先序遍历非递归算法
    #define maxsize 100
    typedef struct
    {
        Bitree Elem[maxsize];
        int top;
    }SqStack;

    void PreOrderUnrec(Bitree t)
    {
        SqStack s;
        StackInit(s);
        p=t;
       
        while (p!=null || !StackEmpty(s))
        {
            while (p!=null)             //遍历左子树
            {
                visite(p->data);
                push(s,p);
                p=p->lchild;      
            }//endwhile
           
            if (!StackEmpty(s))         //通过下一次循环中的内嵌while实现右子树遍历
            {
                p=pop(s);
                p=p->rchild;       
            }//endif
                   
        }//endwhile
       
    }//PreOrderUnrec

    2.中序遍历非递归算法
    #define maxsize 100
    typedef struct
    {
        Bitree Elem[maxsize];
        int top;
    }SqStack;

    void InOrderUnrec(Bitree t)
    {
        SqStack s;
        StackInit(s);
        p=t;
        while (p!=null || !StackEmpty(s))
        {
            while (p!=null)             //遍历左子树
            {
                push(s,p);
                p=p->lchild;
            }//endwhile
           
            if (!StackEmpty(s))
            {
                p=pop(s);
                visite(p->data);        //访问根结点
                p=p->rchild;            //通过下一次循环实现右子树遍历
            }//endif  
       
        }//endwhile

    }//InOrderUnrec


    3.后序遍历非递归算法
    #define maxsize 100
    typedef enum{L,R} tagtype;
    typedef struct
    {
        Bitree ptr;
        tagtype tag;
    }stacknode;

    typedef struct
    {
        stacknode Elem[maxsize];
        int top;
    }SqStack;

    void PostOrderUnrec(Bitree t)
    {
        SqStack s;
        stacknode x;
        StackInit(s);
        p=t;
       
        do
        {
            while (p!=null)        //遍历左子树
            {
                x.ptr = p;
                x.tag = L;         //标记为左子树
                push(s,x);
                p=p->lchild;
            }
       
            while (!StackEmpty(s) && s.Elem[s.top].tag==R) 
            {
                x = pop(s);
                p = x.ptr;
                visite(p->data);   //tag为R,表示右子树访问完毕,故访问根结点      
            }
           
            if (!StackEmpty(s))
            {
                s.Elem[s.top].tag =R;     //遍历右子树
                p=s.Elem[s.top].ptr->rchild;       
            }   
        }while (!StackEmpty(s));
    }//PostOrderUnrec


    ==================================================================================

    一个完整的前序遍历非递归
    *sy32.c*/
    #include <stdio.h>
    #include <stdlib.h>
    typedef char DataType;
    typedef struct node{
    DataType data;
    struct node *lchild,*rchild;
    }BinTNode;
    typedef BinTNode *BinTree;
    int count;
    void CreateBinTree(BinTree *T);
    void PreorderN(BinTree T);
    #define StackSize 10 /*假定预分配的栈空间最多为10*/
    typedef BinTree SDataType; /*栈的元素类型设为整型*/
    #define Error printf
    typedef struct{
    SDataType data[StackSize];
    int top;
    }SeqStack;
    void InitStack(SeqStack *S) /*初始栈*/
    { S->top=-1;
    }
    int StackEmpty(SeqStack *S) /*判栈空*/
    {return S->top==-1;
    }
    int StackFull(SeqStack *S) /*判栈满*/
    {return S->top==StackSize-1;
    }
    void Push(SeqStack *S, SDataType x) /*进栈*/
    {if(StackFull(S))
    Error("栈已满/n"); /*上溢退出*/
    else S->data[++S->top]=x; /*栈顶指针加1后将x进栈*/
    }
    SDataType Pop(SeqStack *S) /*出栈*/
    {if (StackEmpty(S))
    Error("Stack underflow"); /*下溢退出*/
    else return S->data[S->top--]; /*栈顶指针返回后将栈顶指针减1*/
    }
    SDataType StackTop(SeqStack *S) /*取栈顶元素*/
    {if (StackEmpty(S))
    Error("栈已空/n");
    return S->data[S->top];
    }
    main()
    {BinTree T;
    char ch1,ch2;
    printf("/n欢迎进入二叉树操作测试程序,请选择:/n");
    ch1='y';
    while(ch1=='y' || ch1=='Y')
    {printf("/nA-------------------------二叉树建立");
    printf("/nB-------------------------先序遍历(非递归)");
    printf("/nC-------------------------退出/n");
    scanf("/n%c",&ch2);
    switch(ch2)
    {case 'A':
    case 'a':printf("按二叉树带空指针的先序次序输入结点:/n");
    CreateBinTree(&T);
    printf("二叉树建立成功/n");break;
    case 'B':
    case 'b':printf("遍历的结果为:/n");
    PreorderN(T);break;
    case 'C':
    case 'c':ch1='n';break;
    default:ch1='n';
    }
    }
    }
    void CreateBinTree(BinTree *T)
    {char ch;
    scanf("/n%c",&ch);
    if (ch=='0') *T=NULL;
    else {*T=(BinTNode*)malloc(sizeof(BinTNode));
    (*T)->data=ch;
    CreateBinTree(&(*T)->lchild);
    CreateBinTree(&(*T)->rchild);
    }
    }
    void PreorderN(BinTree T)
    {/*先序遍历二叉树T的非递归算法*/
    SeqStack *S;
    BinTree p;
    InitStack(S);Push(S,T); /*根指针进栈*/
    while(!StackEmpty(S))
    {while(p=StackTop(S))
    { printf("%3c",p->data); /*访问入栈结点的数据域*/
    Push(S,p->lchild); /*向左走到尽头*/
    }
    p=Pop(S); /*空指针退栈*/
    if (!StackEmpty(S)) /*输出结点,向右一步*/
    {p=Pop(S);
    /* printf("%3c",p->data); */
    Push(S,p->rchild);
    }
    }
    }/*PreorderN */

    展开全文
  • 二叉树是一种很重要的数据结构,在互联网面试笔试中,二叉树都是考察...二叉树遍历算法可以采用递归来实现,也可以采用非递归 的方式来实现。由于采用递归的方式实现二叉树的遍历太简单,因此在这里直接略过,着...

      二叉树是一种很重要的数据结构,在互联网面试笔试中,二叉树都是考察的重点和难点。很多关于二叉树的问题都涉及到了二叉树的遍历,根据二叉树根结点被访问

    的顺序,可以将二叉树的遍历分为:先序遍历(根、左、右),中序遍历(左、根、右),后序遍历(左、右、根)。二叉树遍历的算法可以采用递归来实现,也可以采用非递归

    的方式来实现。由于采用递归的方式实现二叉树的遍历太简单,因此在这里直接略过,着重掌握二叉树遍历的非递归算法。

      先序遍历二叉树的时候,首先访问根结点,再访问左孩子,最后访问右孩子。在二叉树先序遍历非递归算法中,先将根结点压栈,在栈不为空的时候执行循环:

    让栈顶元素p出栈,访问栈顶元素p,如果p的右孩子不为空,则让其右孩子先进栈,如果p的左孩子不为空,则再让其左孩子进栈(注意:进栈顺序一定是先右

    孩子,再左孩子)

      二叉树先序遍历的非递归算法实现如下:

      

    #include <stdlib.h>
    #include <stdio.h>
    #define MAXSIZE 100
    // 定义结点类型
    typedef struct node
    {
        int data;
        struct node* lchild;
        struct node* rchild;
    } BTnode;
    
    void Preorder(BTnode* t)
    {
        BTnode* Seqstack[MAXSIZE];         
        int top = -1;
        BTnode* p;
        
        if(t != NULL)
        {
            top++;
            Seqstack[top] = t;                      // 先将根结点压栈
            while(top > -1)                         // 栈不为空时循环
            {
                p = Seqstack[top];                  // 栈顶元素出栈
                top --;
                printf("%d ", p->data);             // 访问栈顶元素
                if(p->rchild != NULL)               // 如果右孩子不为空,则进栈
                {
                    top ++;
                    Seqstack[top] = p->rchild;
                }
                if(p->lchild != NULL)               // 如果左孩子不为空,则进栈
                {
                    top ++;
                    Seqstack[top] = p->lchild;
                }
            }
        }
    }

     

    转载于:https://www.cnblogs.com/greedyco/p/7182555.html

    展开全文
  • 转载于:https://www.cnblogs.com/sushuiheng/p/6811747.html
  • 栈的基本操作算法的实现 基本数据结构 typedef struct BiNode {  char data;  struct BiNode *lchild,*rchild; }BiNode,*BiTree;   //栈的数据结构 //栈元素类型 typedef struct {...
  • 二叉树的遍历算法有多种,典型的...而且这些遍历的递归算法较为简单,代码很少,容易实现,本文就是汇总二叉树遍历的递归算法,非递归算法将在下一篇文章中进行总结。本文中用到的二叉树实例如下: 3 /
  • 二叉树的中序遍历非递归算法 目标遍历的二叉树: 1 / \ 2 4 / \ 3 5 待输出结果为3,2,5,1,4 1.首先得用上面定义的结构体把这颗树表示出来 2.表示出这颗树后在调用二叉树的中序遍历非递归算法 */...
  • 二叉树后序遍历非递归详解 1. 首先给出一颗二叉树,如下图所示: 图1 一颗简单的二叉树 根据二叉树的后序遍历的特性,该二叉树后序遍历顺序为: D G E B H I F C A 2. 一般遍历一颗二叉树,先序中序或者后序...
  • 在三种遍历中,前序和中序遍历非递归算法都很容易实现,非递归后序遍历实现起来相对来说要难一点。 一.前序遍历 前序遍历按照“根结点-左孩子-右孩子”的顺序进行访问。 1.递归实现 代码如下:void preOrder1...
  • 文章目录递归算法非递归算法 递归算法 非递归算法
  • 概要:本文整理了先序,中序,后续遍历算法的递归实现与非递归实现,同时会涉及到实现的原理,编程语言使用的是Java。 二叉树遍历的递归实现 节点结构如下: public static class Node { public int value; ...
  • 二叉树前序遍历非递归算法的关键是:在前序遍历过某结点的整个左子树后,如何找到该结点的右子树的根指针,对于图一二叉树 工作栈S和当前根指针bt的变化情况以及树中各结点的访问次序。 分析二叉树 ...
  • 本文是数据结构基础系列(6):树和二叉树中第11课时二叉树遍历非递归算法的例程。【二叉树遍历的非递归算法】 实现二叉树的先序、中序、后序遍历的非递归算法,并对用”A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”创建...
  • 二叉树先序遍历、中序遍历、后序遍历的递归以及非递归算法(Java实现)
  • C语言实现二叉树遍历的递归和非递归算法

    万次阅读 多人点赞 2019-04-06 21:27:42
    二叉树递归定义可知,遍历一棵二叉树便要决定对根结点NNN、**左子树LLL和右子树RRR**的访问顺序。按照先遍历左子树再遍历右子树的原则,常见的遍历次序有: 前序遍历:(N L R) 中序遍历:(L N R) 后序遍历...
  • C语言二叉树遍历前序非递归算法,简单易懂,正确无误
  • 1、由于顺序存储对空间利用率较低,因此一般二叉树都采用链式存储结构。 typedef struct node { ElemType data; //数据域 struct node *lchild; //左孩子指针 ...2、二叉树遍历递归算法: 先序
  • 二叉树遍历——递归与非递归实现描述分析递归版本的二叉树遍历设计代码非递归版本的二叉树遍历非递归先序遍历设计步骤代码非递归后序遍历设计步骤代码非递归中序遍历设计步骤代码非递归遍历二叉树完整代码及测试 ...
  • * 二叉树中序遍历非递归算法。 * 主要思路: * 用一个栈维护所有有左孩子的节点。 * 1、当一个节点有左孩子时,就把这个节点进栈。 * 2、然后检查这个节点的左孩子节点是不是有左孩子,如果有,则这个左...
  • 用C++写的二叉树先序遍历、中序遍历和后序遍历非递归算法
  • 利用栈的基本操作实现二叉树的中序遍历非递归算法
  • 在前一篇文章二叉树遍历递归算法对二叉树遍历的递归算法做了总结,这篇文章就来对二叉树遍历非递归算法做个汇总。还是与上一篇文章一样的顺序,一一汇总先序、中序、后序以及层序遍历的非递归算法。 1、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,254
精华内容 16,101
关键字:

二叉树遍历非递归算法