二叉树的遍历(非递归)

1. 先序遍历

public void preorder(TreeNode root) {
        if(root == null) return;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(true) {
            if(root == null) {
                if(stack.isEmpty())
                    break;
                root = stack.pop();
            } else {
                System.out.println(root.val);
                if(root.right != null)
                    stack.push(root.right);
                root = root.left;
            }
        }
    }

2. 中序遍历

public void inorder(TreeNode root) {
        if(root == null) return;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(true) {
            if(root == null) {
                if(stack.isEmpty())
                    break;
                root = stack.pop();
                System.out.println(root.val);
                root = root.right;
            } else if(root.left != null) {
                stack.push(root);
                root = root.left;
            } else {
                System.out.println(root.val);
                root = root.right;
            }
        }
    }

3. 后序遍历, 需要两个栈,其中一个栈用来记录对应节点是否已经访问了它的右节点

public void postorder(TreeNode root) {
        if(root == null) return;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<Boolean> flags = new Stack<Boolean>();
        while(true) {
            if(root == null) {
                if(stack.isEmpty()) {
                    break;
                } if(flags.peek()) {
                    System.out.println(stack.pop().val);
                    flags.pop();
                } else {
                    flags.pop();
                    flags.push(true);
                    root = stack.peek().right;
                }
            } else if(root.left != null) {
                stack.push(root);
                flags.push(false);
                root = root.left;
            } else if(root.right != null) {
                stack.push(root);
                flags.push(true);
                root = root.right;
            } else {
                System.out.println(root.val);
                root = null;
            }
        }
    }
时间: 2024-10-14 06:26:03

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

二叉树的遍历(非递归)

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) {

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

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

二叉树先序、中序、后续遍历非递归

1 ** 2 * 二叉树先序遍历非递归 3 * @param root 4 */ 5 public void preOrder_no_recursive(TreeNode root){ 6 if(root == null) return; 7 8 Stack<TreeNode> stack = new Stack<>(); 9 stack.add(root); 10 while(!stack.isEmpty()){ 11 TreeNode tn = stack.pop(); 12

二叉树的遍历(递归、非递归)

1 public class BinTree { 2 private char date; 3 private BinTree lchild; 4 private BinTree rchild; 5 6 public BinTree(char c) { 7 date = c; 8 } 9 10 // 先序遍历递归 11 public static void preOrder(BinTree t) { 12 if (t == null) { 13 return; 14 } 15 System.ou

二叉树的中序、先序、后序遍历非递归遍历算法(使用堆栈,用循环实现)

1 typedef struct TreeNode *BinTree; 2 typedef BinTree Position; 3 struct TreeNode{ 4 ElementType Data; 5 BinTree Left; 6 BinTree Right; 7 }; 8 BinTree BT; 9 void InOrderTraversal(BinTree BT)//中序遍历非递归遍历算法(使用堆栈,用循环实现) 10 { 11 BinTree T=BT; 12 Stack S=C

二叉树的遍历,递归和非递归

import java.util.ArrayDeque; import java.util.Stack; class TreeNode { public int val; public TreeNode left; public TreeNode right; public TreeNode(int val) { this.val = val; } } public class BinaryTree { //先序遍历递归 public static void preOrder(TreeNode

前序中序后序遍历非递归实现

#include<iostream> #include<vector> #include<stack> #include<string> #include<algorithm> #include<numeric> using namespace std; class node{ public: int val; node* left; node* right; node():val(0),left(NULL),right(NULL){