精华内容
下载资源
问答
  • 自己编写的实验二叉树的后序遍历非递归算法 包括以递归中序遍历建立二叉树 前序,中序,后序递归以及非递归实现二叉树的遍历 经vc6.0编译通过 自己实验,不足之处应该很多,望指出
  • 数据结构中关于二叉树的遍历非递归算法数上未给出
  • C语言数据结构之二叉树的非递归后序遍历算法 前言: 前序、中序、后序的非递归遍历中,要数后序最为麻烦,如果只在栈中保留指向结点的指针,那是不够的,必须有一些额外的信息存放在栈中。 方法有很多,这里只举一...
  • 二叉树非递归后序遍历算法(C语言)

    千次阅读 2020-07-23 16:17:55
    二叉树非递归后序遍历算法(C语言) 二叉树后序遍历的规律:左右根 后序非递归遍历中,访问根(子根)结点有两种情况 ①:遍历完左子树,需要遍历右子树,需要从栈中访问最顶上的根(子根)结点从而得到右子树的指针。...

    二叉树非递归后序遍历算法(C语言)

    二叉树后序遍历的规律:左右根
    后序非递归遍历中,访问根(子根)结点有两种情况
    ①:遍历完左子树,需要遍历右子树,需要从栈中访问最顶上的根(子根)结点从而得到右子树的指针。
    ②遍历完右子树,需要访问根(子根)结点。
    基于这个特性,我们需要区分,到底这个根结点,是访问完了左子树还是右子树,所以需要添加一个变量帮助辨认。

    void Postorder(BiTree T){
    	Stack S;  //用于记录根和字根结点
    	InitStack(S);//初始化栈
    	BiNode *p=T;//临时变量记录记录当前访问的结点
    	BiNode *r = NULL; //临时变量,记录上一个访问到的结点,因为从右边访问根结点必定是右子树已经遍历完了,此时上一个访问的结点必定是右子树的根结点
    	while(p||!IsEmpty(S){
    		if (p!=NULL){
    			push(S,p);
    			p = p->lchild;
    		}else{
    			GetTop(S,p);//只读取根结点,不对栈内结点进行操作
    			//没有对右子树进行操作过
    			if(p->rchild!=NULL&&p->rchild!=r){
    				p=p->rchild;
    				push(S,p);
    				p=p->lchild;
    			}else{
    				pop(S,p);
    				visit(p);//对p进行访问,可以进行打印等操作
    				r=p;//记录当前访问的是p结点
    				p==NULL;//把p置空,进入下一次循环,直到栈内无元素,且p为空时遍历完成
    			}//else
    		}//else
    	}//while
    }
    

    代码讲解:https://www.bilibili.com/video/BV1it4y1X7xd/

    展开全文
  • 二叉树后序遍历,用C语言写的,大家可以看看!
  • 二叉树先序、中序、后序遍历非递归算法,简述了二叉树的基本算法。
  • 二叉树先序、中序、后序遍历(递归、非递归算法) 其中自己已经开发了栈!
  • 递归算法 1.1 前序遍历 1.2 中序遍历 1.3 后序遍历 2 迭代 2.1 C语言栈的创建 2.2 前序遍历 2.2.1 思想 2.2.2 代码 2.2 中序遍历 2.2.1 思想 2.2.2 代码 2.3 后序遍历 2.3.1 思想 2.3.2 代码 题目链接 力扣 力扣 ...

    目录

    题目链接

    参考

    树的结构的定义

    树的遍历思想

    前序遍历

    中序遍历

    后序遍历

    1.递归算法

    1.1 前序遍历

    1.2 中序遍历

    1.3 后序遍历

    2 迭代

    2.1 C语言栈的创建

    2.2 前序遍历

    2.2.1 思想

    2.2.2 代码

    2.2 中序遍历

    2.2.1 思想

    2.2.2 代码

    2.3 后序遍历

    2.3.1 思想

    2.3.2 代码


    题目链接


    力扣
    力扣
    力扣

    参考


    官方题解 
    +
    力扣

    树的结构的定义

    /**  
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     struct TreeNode *left;
     *     struct TreeNode *right;
     * };
     * 
     */

    树的遍历思想

    给这样一棵树:

    前序遍历

            即从根节点出发,先遍历左子树,再遍历右子树。

            因此该树的前序遍历序列为:A B D E C F

    中序遍历

            从树的根节点出发至最左的结点,然后以左子树->根节点->右子树的顺序遍历。

            因此该树的中序遍历序列为:D B E A F C

            规律:将树压扁至一个平面,(左子树一定在根节点左侧,右子树一定在根节点右侧)则刚好为中序遍历的序列,如果是二叉搜索树,中序遍历序列刚好是一个递增序列。

    后序遍历

            以左子树->右子树->根节点的顺序遍历。

            因此该树的后序遍历序列为:D E B F C A

    可以根据上面的算法引出递归的写法,思想非常简单,代码几乎相同,只不过遍历的顺序略有改变。

    1.递归算法


    1.1 前序遍历

    void preorder(struct TreeNode* root, int* res, int* resSize) {
        if (!root) {
            return;
        }
        res[(*resSize)++] = root->val;
        preorder(root->left, res, resSize);
        preorder(root->right, res, resSize);
    }
    
    int* preorderTraversal(struct TreeNode* root, int* returnSize) {
        int* res = malloc(sizeof(int) * 2000);
        *returnSize = 0;
        preorder(root, res, returnSize);
        return res;
    }

    1.2 中序遍历

    void midorder(struct TreeNode* root, int* res, int* returnSize){
        if(!root)
            return;
        midorder(root->left, res, returnSize);
        res[(*returnSize)++] = root->val;
        midorder(root->right, res, returnSize);
    }
    
    int* inorderTraversal(struct TreeNode* root, int* returnSize) {
        int * res = (int *)malloc(sizeof(int) * 2000);
        *returnSize = 0;
        midorder(root, res, returnSize);
        return res;
    }

    1.3 后序遍历

    void backorder(struct TreeNode* root, int* res, int* returnSize) {
        if (!root) {
            return;
        }
        backorder(root->left, res, returnSize);
        backorder(root->right, res, returnSize);
        res[(*returnSize)++] = root->val;
    }
    
    int* postorderTraversal(struct TreeNode* root, int* returnSize) {
        int* res = malloc(sizeof(int) * 2000);
        *returnSize = 0;
        backorder(root, res, returnSize);
        return res;
    }

    2 迭代

    2.1 C语言栈的创建

            迭代的方法不可避免地需要使用到栈,所以定义一些栈的基础操作,后面方便使用,包括初始化、压栈、弹栈。

    (其实可以不需要完整定义一个栈,对C语言来说,栈只是一个先进后出的思想,简便版可以看力扣官方题解,上面有链接~)

            先把代码放在这里

    typedef struct{
        struct TreeNode* stk[2000];
        int top;
    }Stack;
    //定义一些栈的基础操作,后面方便使用,包括初始化、压栈、弹栈
    Stack* create()
    {
        Stack* S = (Stack*)malloc(sizeof(Stack));
        S->top = -1;
        return S;
    }
    
    void push(Stack* S, struct TreeNode* p)
    {
        S->top++;
        S->stk[S->top] = p;
    }
    
    void pop(Stack* S)
    {
        S->top--;
    }

    2.2 前序遍历

    2.2.1 思想

            首先把根节点入栈。
            当栈不空的时候:
                    1.弹栈顶元素node,并且输出该节点的值;
                    2.如果node的右子树不为空,则压栈;
                    3.如果node的左子树不为空,则压栈。
            压栈时先右后左的理由:
                    前序遍历是根->左->右的顺序,所以左子树是后进先出。

    2.2.2 代码

    int* preorderTraversal(struct TreeNode* root, int* returnSize) 
    {
        *returnSize = 0;
        if(!root)
            return NULL;
        int * res = (int *)malloc(sizeof(int) * 100);   //遍历结果
        Stack* s = create();
        struct TreeNode* p;
        push(s, root); //把根节点入栈
        while(s->top > -1) //栈不空的时候
        {
            p = s->stk[s->top];
            res[(*returnSize)++] = p->val;
            pop(s);
            if(p->right)
            {
                push(s, p->right);
            }
            if(p->left)
            {
                push(s, p->left);
            }
        }
        return res;
    }

    2.2 中序遍历

    2.2.1 思想

        首先将根节点入栈。
        将所有左孩子压栈。
        开始弹栈,每弹出一个栈顶元素node,如果它的右子树不为空,则重复上述操作

    2.2.2 代码

    int* inorderTraversal(struct TreeNode* root, int* returnSize) {
        *returnSize = 0;
        if(!root)
            return NULL;
        int * res = (int *)malloc(sizeof(int) * 100);   //遍历结果
        Stack* s = create();
        struct TreeNode* p = root;
        while (p || s->top > -1)
        {
            while (p) 
            {
                push(s, p);
                p = p->left;
            }
            p = s->stk[s->top];
            res[(*returnSize)++] = p->val;
            pop(s);
            p = p->right;
        }
        return res;
    }
    

    2.3 后序遍历

    2.3.1 思想

        与前序压栈顺序相同,只不过出栈顺序为:左->右->根
        每个节点需要记录是否被访问过
        如果flag = 0,说明未被访问过,改为1
        如果flag = 1,弹栈

    2.3.2 代码

    此处对栈做了一些小修改

    首先是栈的定义

    typedef struct{
        struct TreeNode* stk[2000];
        int flags[2000]; //加入了数组来对每个节点做标记
        int top;
    }Stack;

    在压栈时将flag都初始化为0

    void push(Stack* S, struct TreeNode* p)
    {
        S->top++;
        S->stk[S->top] = p;
        S->flags[S->top] = 0;
    }

    其他栈的操作代码不变

    int *postorderTraversal(struct TreeNode *root, int *returnSize) {
        *returnSize = 0;
        if(!root)
            return NULL;
        int * res = (int *)malloc(sizeof(int) * 100);   //遍历结果
        Stack* s = create();
        struct TreeNode* p;
        push(s, root); //把根节点入栈
        while(s->top > -1) //栈不空的时候
        {
            p = s->stk[s->top];
            int flag = s->flags[s->top];
            if(flag)
            {
                res[(*returnSize)++] = p->val;
                pop(s);
            }
            else
            {
                s->flags[s->top] = 1;
                if(p->right)
                    push(s, p->right);
                if(p->left)
                    push(s, p->left);
            }
        }
        return res;
    }

    展开全文
  • 二叉树后序遍历(非递归)算法实现--C语言

    万次阅读 多人点赞 2018-12-18 16:14:37
      一直说要写二叉树的后序非递归遍历算法,但是前两天各种事情,今天终于有时间好好写一写二叉树的后序遍历算法。   二叉树的后序遍历算法比先序和中序的遍历算法要复杂一些。其出栈条件有两种情况: 栈顶元素...

      一直说要写二叉树的后序非递归遍历算法,但是前两天各种事情,今天终于有时间好好写一写二叉树的后序遍历算法。
      二叉树的后序遍历算法比先序和中序的遍历算法要复杂一些。其出栈条件有两种情况:

    1. 栈顶元素所指向的节点的左子树和右子树均为空;
    2. 栈顶元素所指向的节点的左子树和右子树均被访问过。

      第一种情况比较好判断,但是对于第二种情况就比较麻烦一点。要先判断其左子树和右子树是否分别被访问过。
      对于第二种情况,多加一个指针指向上一次循环访问过的节点(如果栈顶元素指向节点的左子树或右子树的值与该指针的值相等,则说明该栈顶元素可以出栈),并且进栈顺序是先进右子树,再进左子树,这样当右子树被访问过时,其左子树一定已经被访问过了。

    代码如下:

    #include "stdafx.h"
    #include <stdlib.h>
    #include <stdio.h>
    #define STACKINITSIZE 20//栈初始空间大小
    #define INCREASEMENT 10//栈空间大小的增量
    
    typedef struct BiTNode
    {
    	char data;//二叉树节点数据
    	BiTNode *lchild,*rchild;//指向二叉树左子树和右子树的指针
    }BiTNode,*BiTree;//定义二叉树节点结构
    
    typedef struct SqStack
    {
    	BiTNode *base;//栈底指针
    	BiTNode *top;//栈顶指针
    	int stacksize;//顺序栈空间大小
    }SqStack;//定义顺序栈结构
    
    //建立一个空栈,建立成功,返回1,失败,返回0
    int InitStack(SqStack &S)
    {
    	S.base = (BiTNode*)malloc(STACKINITSIZE * sizeof(BiTNode));//20为栈的大小,可以更改
    	if(!S.base)
    		return 0;
    	S.top = S.base;
    	S.stacksize = STACKINITSIZE;
    	return 1;
    }
    
    //进栈操作
    int Push(SqStack &S,BiTNode e)
    {
    	if(S.top - S.base >= S.stacksize)
    	{
    		S.base = (BiTNode*)realloc(S.base,(STACKINITSIZE + INCREASEMENT) * sizeof(BiTNode));
    		if(!S.base)
    			return 0;
    		S.stacksize = 30;
    	}
    	*S.top = e;
    	S.top ++;
    	return 1;
    }
    
    //获取栈顶元素
    int GetTop(SqStack S,BiTNode &e)
    {
    	if(S.base == S.top)
    		return 0;
    	e = *(S.top - 1);
    	return 1;
    }
    
    //出栈操作,若栈为空,则返回0;栈不为空,则返回1
    int Pop(SqStack &S,BiTNode &e)
    {
    	if(S.base == S.top)
    		return 0;
    	S.top --;
    	e = *S.top;
    	return 1;
    }
    
    //判断栈是否为空,若栈为空,则返回true,栈不为空,则返回false
    bool StackEmpty(SqStack S)
    {
    	if(S.base == S.top)
    		return true;
    	else
    		return false;
    }
    
    //建立二叉树
    void CreateBiTree(BiTree &T)
    {
    	char ch;
    	scanf("%c",&ch);
    	if(ch == '#')
    		T = NULL;
    	else
    	{
    		T = (BiTNode *)malloc(sizeof(BiTNode));
    		T->data = ch;
    		CreateBiTree(T->lchild);
    		CreateBiTree(T->rchild);
    	}
    }
    //比较两个节点的值是否相等
    bool Equal(BiTNode *e1,BiTNode *e2)
    {
    	if(NULL == e1 || NULL == e2)
    		return false;
    	if(e1->data == e2->data && e1->lchild == e2->lchild && e1->rchild == e2->rchild)
    		return true;
    	else
    		return false;
    }
    //后序遍历二叉树
    int PostOrderTraverse(BiTree T)
    {
    	if(!T)
    		return 0;
    	SqStack S;
    	int n = InitStack(S);//建立空栈
    	if(!n)
    		return 0;
    	BiTree p = T;
    	BiTree pre = NULL;
    	BiTNode e,cur;//二叉树节点,用于存放从栈中取出的节点
    	Push(S,*p);
    	while(!StackEmpty(S))
    	{
    		GetTop(S,e);//
    		if((NULL == e.lchild && NULL == e.rchild) || (NULL != pre && (Equal(pre,e.lchild) || Equal(pre,e.rchild))))
    		{
    			/*这里之前出现过错误,造成死循环。当时写的是
    			Pop(S,e);
    			printf("%c ",e.data);
    			pre = &e;
    			由于pre = 对e取地址,则当前面GetTop(S,e)时,pre的值也改变了,之前保存的内容没有了,if条件永远不会为真
    			*/
    			Pop(S,cur);
    			printf("%c ",cur.data);
    			pre = &cur;
    		}
    		else
    		{
    			if(NULL != e.rchild)
    			{
    				Push(S,*e.rchild);
    			}
    			if(NULL != e.lchild)
    			{
    				Push(S,*e.lchild);
    			}
    		}
    	}
    	printf("\n");
    	return 1;
    }
    
    int main(int argc, char* argv[])
    {
    	BiTree T = NULL;
    	printf("请输入二叉树-按照先序序列建立二叉树\n");
    	CreateBiTree(T);
    	printf("后序遍历二叉树结果为:\n");
    	PostOrderTraverse(T);
    	return 0;
    }
    
    
    
    

    建立的二叉树的形状为:
    在这里插入图片描述

    测试结果如下图所示:
    在这里插入图片描述

    写完这个后序遍历,我发现自己的坏习惯还真的是很难改正,依然很粗心,这一点代码占用了自己将近一天的时间,就是卡在了中间的那个循环那里,导致出现死循环。总是审题不严,急躁,这一点我会慢慢改正,及时时间不够,但是写出来的要保证是对的,否则还不如不写。

    展开全文
  • 1.输入前序和中序遍历结果,建立二叉树 2.实现二叉树的三种递归遍历算方法 3.实现二叉树的三种非递归遍历算法 4.实现二叉树的旋转90°后的打印,直观树形结构
  • 二叉树的非递归前、中、后序遍历算法详解及代码实现...2. 后序遍历非递归算法思路 后序非递归遍历的C代码 1. 前序遍历和中序遍历非递归算法思路 遍历过程:(如图所示) 图1 前序遍历和中序遍历流程图   ...
    
    

    二叉树的非递归前、中、后序遍历算法详解及代码实现(C语言)

    1. 前序遍历和中序遍历非递归算法思路

    前序和中序非递归遍历的C代码

    2. 后序遍历非递归算法思路

    后序非递归遍历的C代码


    1. 前序遍历和中序遍历非递归算法思路

    遍历过程:(如图所示)

    图1 前序遍历和中序遍历流程图

     

    从当前节点开始遍历:(当入栈时访问节点内容,则为前序遍历;出栈时访问,则为中序遍历)

    1. 若当前节点存在,就存入栈中,并访问左子树;

    2. 直到当前节点不存在,就出栈,并通过栈顶节点访问右子树;

    3. 不断重复12,直到当前节点不存在且栈空。

     

    Tips:我们很容易发现,在理解并写好该非递归遍历代码后,只需要在入栈、出栈的时候,分别进行节点访问输出,即可分别得到前序、中序的非递归遍历代码!!!

     

    便于理解的伪代码:

    
     
    1. void preOrder(TreeNode *T){
    2.     p = T
    3.     while(p不空||栈不空){
    4.         if(p不空){       //两种情况:1.栈不空;2.栈空
    5.             p入栈;
    6.             (前序遍历,访问)
    7.             入p左子节点;
    8.         } else{             //一种情况:当前节点为空,但栈不空
    9.             p=出栈;
    10.             (中序遍历,访问)
    11.             入p右子节点;
    12.         }
    13.     }
    14. }

    前序和中序非递归遍历的C代码

    二叉树节点结构体:

    
     
    1. typedef struct TreeNode{
    2. int data;
    3. struct TreeNode *lChild;
    4. struct TreeNode *rChild;
    5. }TreeNode;

    前序遍历非递归:

    
     
    1. void preOrder(TreeNode *T){
    2. TreeNode * stack[ 15];
    3. int top = -1;
    4. TreeNode *p = T;
    5. while(p!= NULL||top!= -1){
    6. if(p!= NULL){
    7. stack[++ top] = p;
    8. printf( "%d\t",p->data); //入栈时,访问输出
    9. p = p->lChild;
    10. } else{
    11. p = stack[top --];
    12. p = p->rChild;
    13. }
    14. }
    15. }

    中序遍历非递归:

    
     
    1. void inOrder(TreeNode *T){
    2. TreeNode * stack[ 15];
    3. int top = -1;
    4. TreeNode *p = T;
    5. while(p!= NULL||top!= -1){
    6. if(p!= NULL){
    7. stack[++ top] = p;
    8. p = p->lChild;
    9. } else{
    10. p = stack[top --];
    11. printf( "%d\t",p->data); //出栈时,访问输出
    12. p = p->rChild;
    13. }
    14. }
    15. }

    2. 后序遍历非递归算法思路

    后序遍历整体与前中序遍历过程相似。但要注意,这时对于父节点的访问输出,需要在其右子树遍历完成的前提下进行。所以不能像前中序遍历一样,在遍历完左子树后,就直接出栈。我们需要利用这个未出栈的栈顶元素去获取右子树,在遍历完右子树后,就可以出栈,并对此节点进行访问输出。

    这里我们需要使用一个标记,以区分是从左子树取栈还是从右子树出栈:(如图所示)

    图2 后序遍历流程图

     

    从当前节点开始遍历:

    1. 若当前节点存在,就存入栈中,并且置节点flag为1(第一次访问),然后访问其左子树;

    2. 直到当前节点不存在,需要回退,这里有两种情况:

           1)当栈顶节点flag为1时,则表明是从左子树回退,这时需置栈顶节点flag为2(第二次访问),然后通过栈顶节点访问其右子树(取栈顶节点用,但不出栈)

           2)当栈顶节点flag为2时,则表明是从右子树回退,这时需出栈,并取出栈节点做访问输出。(需要注意的是,输出完毕需要置当前节点为空,以便继续回退。具体可参考代码中的p = NULL)

    3. 不断重复12,直到当前节点不存在且栈空。

     

    Tips:我们很容易发现,当理解并写好后序遍历非递归代码后,只需要在入栈、取栈、出栈的时候,分别进行节点访问输出,即可分别得到前序、中序、后序的非递归遍历代码,是不是非常简单!!!

     

    后序非递归遍历的C代码

    节点结构体:

    
     
    1. typedef struct TreeNode{
    2. int data;
    3. struct TreeNode *lChild;
    4. struct TreeNode *rChild;
    5. }TreeNode;

    后序遍历非递归:

    
     
    1. void postOrder(TreeNode *T){
    2. TreeNode * stack[ 15];
    3. int top = -1;
    4. int flagStack[ 15]; //记录每个节点访问次数栈
    5. TreeNode *p = T;
    6. while(p!= NULL||top!= -1){
    7. if(p!= NULL){ //第一次访问,flag置1,入栈
    8. stack[++ top] = p;
    9. flagStack[top] = 1;
    10. p = p->lChild;
    11. } else{ //(p == NULL)
    12. if(flagStack[top] == 1){ //第二次访问,flag置2,取栈顶元素但不出栈
    13. p = stack[top];
    14. flagStack[top] = 2;
    15. p = p->rChild;
    16. } else{ //第三次访问,出栈
    17. p = stack[top --];
    18. printf( "%d\t",p->data); //出栈时,访问输出
    19. p = NULL; //p置空,以便继续退栈
    20. }
    21. }
    22. }
    23. }

     

    展开全文
  • //后续遍历 printf("非递归中序遍历:"); InOrder2(T); printf("非递归先序遍历:"); PreOrder2(T); system("pause"); return 0; } //按照先序遍历初始化二叉树 void InitTree(BiTree &T){ int data ; scanf("%d", &...
  • 首先非常感谢‘hicjiajia’的博文:二叉树后序遍历(非递归) 这篇随笔开启我的博客进程,成为万千程序员中的一员,坚持走到更远! 折磨了我一下午的后序遍历中午得到解决,关键在于标记右子树是否被访问过,考虑过...
  • 后序遍历 后序遍历要求左右子树均完成后才对自身进行访问。入栈时,先将右子树(若存在)入栈再将左子树(若存在)入栈,然后指向左孩子(若存在左孩子,否则指向右孩子)。在对这个部分结点构成的栈进行出栈操作时...
  • 二叉树后序遍历--【非递归C语言栈实现

    千次阅读 多人点赞 2018-05-07 15:56:41
    ---使用非递归实现二、解题思路非递归后序遍历 --- 左右根对于一个节点而言,要实现访问顺序为左儿子-右儿子-根节点,可以利用后进先出的栈,在节点不为空的前提下,依次将根,右,左压栈。故需要按照根-右-左的顺序...
  • 后序遍历中,二叉树的根节点需要其左右子树
  • 注:本文截图来自文都考研洪...补上先序遍历非递归算法(C++): /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) ...
  • 试写出非递归后序遍历算法 分析: 非递归的后续遍历较中序和先序而言,稍微复杂一点,首先我们需要一直从根节点往下寻找左孩子并入栈,之后访问栈顶元素, 并判断是否有右孩子,如果有右孩子入栈,并继续往左...
  • 1.实验目的 熟练掌握二叉树的二叉链表存储结构的C语言实现。...(2)二叉树的前、中、后序遍历的递归算法和非递归算法的实现 (3)求二叉树中叶子结点数目的递归算法。 (4)编写求二叉树深度的递归算法。 ...
  • 二叉树的先序、中序、后序非递归算法C语言实现 一、 链式栈结构源码 1. 头文件:linkedstack.h #ifndef TREE #define TREE #include "bitree.h" #endif // 栈结点类型 struct StackNode { struct BiTNode *data; ...
  • 2. 后序遍历非递归算法思路 后序非递归遍历的C代码 1. 前序遍历和中序遍历非递归算法思路 遍历过程:(如图所示) 图1 前序遍历和中序遍历流程图 从当前节点开始遍历:(当入栈时访问节点内容,则为前序...
  • 后序遍历非递归算法(C 详细) ```c void PostOrder(BiTree T){ InitStack(S); p=T; r=NULL; while(p||!IsEmpty(s)){ if(p){ //走到最左边 push(S,p); p=p->lchild; } else{ //向右 ...
  • 二叉树的非递归前、中、后序遍历算法详解及代码实现(C语言) ...2. 后序遍历非递归算法思路 后序非递归遍历的C代码 1. 前序遍历和中序遍历非递归算法思路 遍历过程:(如图所示) 图1 前...
  • 后序遍历非递归3种算法

    千次阅读 2014-01-28 10:24:56
    //非递归后序遍历: //------------------------------------------------------------------------- //(不会破坏树) // 有左儿子进,无左二子调用右儿子 // 无左右儿子或左右儿子均被访问过了,出栈并输出 //----...
  • //后序遍历(递归方法) void Postorder (BTNode* p) {  if(p != NULL)  {  Inorder(p->lchild);  Inorder(p->rchild);  Visit(p->data);  } } //访问元素 void Visit(ElementType data) {  printf("\s ", data...
  • 二叉树前序、中序、后序三种遍历非递归算法C语言
  • 二叉树的三种遍历非递归版本是数据结构
  • 前序遍历 递归借助的程序的运行时栈,所以改为迭代时,本质上借助stack去模拟运行时栈。 递归 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,611
精华内容 1,044
关键字:

后序遍历的非递归算法c语言

c语言 订阅