二叉树的遍历(非递归方式)

前序非递归遍历(借用栈结构):

①将根节点入栈;

②判栈空,获取栈顶元素输出;

③判断右子树是否为空,再判断左子树是否为空,在回至②执行。

void PreOrder(BinTree bt)
{
    stack<BinTree> astack;
    BinTreeNode * p;
    astack.push(bt);
    while(!astack.empty())
    {
        p=astack.top();
        astack.pop();
        cout<<p->data<<" ";
        if(p->rightchild!=NULL)
        {
            astack.push(p->rightchild);
        }
        if(p->leftchild!=NULL)
        {
            astack.push(p->leftchild);
        }
    }
}

中序非递归遍历(借用栈结构):

先将根节点入栈

①首先保存当前结点所有的左树结点;

②当左树为空时,获取栈顶元素(最左子树)输出val;

③再访问栈顶元素的右子树(p=p->right),再回退到①。

void InOrder(BinTree bt)
{
    stack<BinTree> astack;
    BinTree p;
    p=bt;
    if(p==NULL)
    {
        return;
    }
    astack.push(bt);
    p=p->leftchild;
    while(p||!astack.empty())
    {
        while(p!=NULL)//沿着左支深入直至NULL
        {
            astack.push(p);
            p=p->leftchild;
        }

        p=astack.top();//逐个弹出,访问
        astack.pop();
        cout<<p->data<<" ";
        p=p->rightchild;//进入右支,下次的大循环,就在右支中向左深入
    }
}

后序非递归遍历(借用栈结构):

①判断当前结点不为空,并且栈不空,然后将根节点左子树所有节点压栈。

②获取栈顶元素并pop(),判断一下此时的栈顶元素的左子树,是否是上一次pop出的元素(即“/”型,表示当前栈顶元素的右子树还未遍历,故又以当前栈顶元素的右子树作为根节点),继续执行①;若不满足,则将其至NULL。

void PostOrder(BinTree bt)
{
    BinTree p=bt;
    stack<BinTree> astack;
    if(bt==NULL)
    {
        return ;
    }

    while(p!=NULL||!astack.empty())
    {
        while(p!=NULL)
        {
            astack.push(p);
            p=p->leftchild?p->leftchild:p->rightchild;//如果左孩子非空,移向左孩子,否则移向右孩子
        }
        //此处已到达最底层
        p=astack.top();
        astack.pop();
        cout<<p->data<<" ";

        if(!astack.empty()&&(astack.top()->leftchild==p))//如果栈非空,并且刚刚访问的节点是左孩子
        {
            p=astack.top()->rightchild;//移向右孩子,下次大循环就开始寻找这个节点最底层
        }
        else//如果是右孩子,说明左孩子在上次就被处理
        {
            p=NULL;//p赋为空,这样下次大循环中的第一个循环被掠过,相当于返回了上一层
        }
    }
}

原文地址:https://www.cnblogs.com/single-dont/p/11545226.html

时间: 2024-10-26 16:22:49

二叉树的遍历(非递归方式)的相关文章

二叉树的遍历(非递归)

1 //二叉树的先序遍历(非递归) 2 public void PreOrderTraverse() 3 { 4 BiTNode p = this.root; 5 Stack stack = new Stack(10000); 6 7 while(!stack.isEmpty || p != null) 8 if(p != null) 9 { 10 if(p.rchild != null) 11 stack.push(p.rchild); 12 System.out.print(p.data +

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

前序遍历非递归依靠栈实现,相对来说比较简单,先来用手写模拟一下基本就能知道怎么写了 据此可得如下代码 void preOrder_stack(BiTree T){ printf("\n非递归先序遍历结果:\n"); initStack(&sqStack); BiTree p=T; push(&sqStack,p); while(!stackEmpty(sqStack)){ pop(&sqStack,&p); printf("%d ",

二叉树的遍历--非递归实现

leetcode中有这么一道题,非递归来实现二叉树的遍历. 二叉树的后序遍历顺序为,root->left, root->right, root,因此需要保存根节点的状态.显然使用栈来模拟递归的过程,但是难点是怎么从root->right转换到root. 方法1: 对于节点p可以分情况讨论 1. p如果是叶子节点,直接输出 2. p如果有孩子,且孩子没有被访问过,则按照右孩子,左孩子的顺序依次入栈 3. p如果有孩子,而且孩子都已经访问过,则访问p节点 如何来表示出p的孩是否都已经访问过了

最容易理解的二叉树后续遍历非递归java实现

后续遍历要保证根结点在左孩子和右孩子访问之后才能访问,因此对于任一结点P,先将其入栈.如果P不存在左孩子和右孩子,则可以直接访问它:或者P存在左孩子或者右孩子,但是其左孩子和右孩子都已被访问过了,则同样可以直接访问该结点.若非上述两种情况,则将P的右孩子和左孩子依次入栈,这样就保证了每次取栈顶元素的时候,左孩子在右孩子前面被访问,左孩子和右孩子都在根结点前面被访问. java private static void postOrderNonRecursiveEasily(Node root) {

二叉树(3)----后序遍历,递归和非递归方式

1.二叉树定义 typedef struct BTreeNodeElement_t_ { void *data; } BTreeNodeElement_t; typedef struct BTreeNode_t_ { BTreeNodeElement_t *m_pElemt; struct BTreeNode_t_ *m_pLeft; struct BTreeNode_t_ *m_pRight; } BTreeNode_t; 2.后序遍历 定义: 给定根节点,首先遍历左子树,然后遍历右子树,最后

非递归方式遍历二叉树

/** * 非递归方式的先根序 * @param root */ public static void preOrder(Node root){ Stack<Node> stack = new Stack<Node>(); while (!stack.isEmpty() || root != null) { while (root != null) { System.out.println(root.data); stack.push(root); root = root.left

数据结构 递归和非递归方式实现二叉树先序、中序和后序遍历

二叉树的先序遍历顺序是根.左.右:中序遍历顺序是左.根.右:后序遍历顺序是左.右.根. 递归方式实现如下: 1 public class TreeNode { 2 private int value; 3 private TreeNode left, right; 4 5 public TreeNode(int data) { 6 value = data; 7 } 8 9 // 递归方式实现先序遍历 10 public void preorder(TreeNode treeNode) { 11

二叉树(11)----求二叉树的镜像,递归和非递归方式

1.二叉树定义: typedef struct BTreeNodeElement_t_ { void *data; } BTreeNodeElement_t; typedef struct BTreeNode_t_ { BTreeNodeElement_t *m_pElemt; struct BTreeNode_t_ *m_pLeft; struct BTreeNode_t_ *m_pRight; } BTreeNode_t; 2.求二叉树镜像 比如: A                    

二叉树基本操作:前序、中序、后序遍历(递归方式)

二叉树是最常见最重要的数据结构之一,它的定义如下: 二叉树(binary tree)是有限多个节点的集合,这个结合或者是空集,或者由一个根节点和两颗互不相交的.分别称为左子树和右子树的二叉树组成. 二叉树最基本的操作是遍历:一般约定遍历时左节点优先于右节点,这样根据根节点的遍历顺序可分为三种遍历操作:前序-先遍历根节点,再处理左右节点:中序-先遍历左节点,然后处理根节点,最后处理右节点:后序-先遍历左右节点,然后处理根节点. 从上边二叉树定义可以看出:二叉树使用了递归的概念描述.所以,二叉树的很

二叉树前序、中序、后序遍历非递归写法的透彻解析

前言 在前两篇文章二叉树和二叉搜索树中已经涉及到了二叉树的三种遍历.递归写法,只要理解思想,几行代码.可是非递归写法却很不容易.这里特地总结下,透彻解析它们的非递归写法.其中,中序遍历的非递归写法最简单,后序遍历最难.我们的讨论基础是这样的: //Binary Tree Node typedef struct node { int data; struct node* lchild; //左孩子 struct node* rchild; //右孩子 }BTNode; 首先,有一点是明确的:非递归