后序遍历

题目： 给定一个二叉树，返回它的 后序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [3,2,1] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 思路：递归迭代法 class Solution { public: vector<int> postorderTraversal(TreeNode* root) { vector<int> res; postorder(root,res); return res; } void postorder(TreeNode* p, vector<int>& res) { if(p!=NULL) { postorder(p->left,res); postorder(p->right,res); res.push_back(p->val); } } }; 思路：非递归迭代法，。。。。待更新 来源： CSDN 作者： 杏壳儿 链接： https://blog.csdn.net/weixin_42077039/article/details/104267720

二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中，前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一点。 前序遍历 递归 void preOrder1(BinTree *root) //递归前序遍历 { if(root!=NULL) { cout<<root->data<<" "; preOrder1(root->lchild); preOrder1(root->rchild); } } 非递归 根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下： 对于任一结点P： 1)访问结点P，并将结点P入栈; 2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P; 3)直到P为NULL并且栈为空，则遍历结束。 void preOrder2

1、二叉树的先序遍历。 节点->左孩子->右孩子 用递归很容易解决，但是会遇到内存溢出情况。用栈可以解决找个问题。 根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下： 　　对于任一结点P： 1)访问结点P，并将结点P入栈; 2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P; 3)直到P为NULL并且栈为空，则遍历结束。 1 public void xianxu(TreeNode root){ 2 Stack<TreeNode> stack = new Stack<>(); 3 TreeNode p = root; 4 while ( !stack.isEmpty() ){ 5 while ( p != null ){ 6 System.out.println(p.val); 7 stack.push(p); 8 p = p.left; 9 } 10 if ( !stack.isEmpty() ){ 11 p = stack.pop(); 12 p = p.right; 13 } 14 } 15

1.先序遍历 根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下： 　　对于任一结点P： 1)访问结点P，并将结点P入栈; 2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P; 3)直到P为NULL并且栈为空，则遍历结束。 vector<int> PreOrder(TreeNode* root){ vector<int>res; if (!root)return res; stack<TreeNode*>ss; TreeNode* cur = root; while (cur || !ss.empty()){ if (cur){ res.push_back(cur->val); ss.push(cur); cur = cur->left; } else{ cur = ss.top(); cur = cur->right; ss.pop(); } } return res; } 2.中序遍历 根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点

为何要迭代？ 二叉树遍历是一个非常常见的操作，无论是中序遍历、先序遍历还是后续遍历，都可以用递归的方法很好地完成，但是相对来说迭代的方法难度就高不少，而且除此之外，迭代地遍历树至少有两个现实意义的优点： 1.比递归节省空间，递归是用栈实现的，因此如果树的高度h很大的话，递归很有可能会造成栈溢出 2.迭代的代码利用循环，而循环可以用循环不变量来证明代码的正确性 我们现在就分别详解这几个迭代地遍历树的方法。 先序遍历 我们先来看看先序遍历，因为在这个里面先序遍历用迭代实现是最简单的。我们先看递归的代码： class Solution: # @param root, a tree node # @return a list of integers def preorder(self,root): ans=[] self.dfs(root, ans) return ans def dfs(self,root,ans): if not root: return ans.append(root.val) self.dfs(root.left, ans) self.dfs(root.right,ans) 先序遍历就是先处理根节点，再处理左右子女节点，因此用迭代实现时，我们只要处理完根节点之后，把左右子女按照先右子女、后左子女的顺序推入栈来保证这个处理顺序就可以了。这个代码也很好理解： class

给定一个二叉树，返回它的 中序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ /* 算法思想： 算法思想： 采用递归的思想，即借助系统栈，效率较低。二叉树的前序遍历规则:1. 遍历左子树； 2. 访问根结点； 3. 遍历右子树 */ /* class Solution { private: void rec(TreeNode* root,vector<int> &ret){ if(root != NULL){ rec(root->left,ret); ret.push_back(root->val); rec(root->right,ret); } } public: vector<int> inorderTraversal(TreeNode* root) { vector<int> ret; rec(root,ret); return ret;

前言 这里同样不介绍二叉树的相关概念，毕竟数据结构的基础已经讲过很多了，这里不再赘述。至于一些平衡二叉树，完全二叉树，红黑树，B+树等相关结构，这个已经有很多博客介绍了，这里只是介绍一下二叉树的一些基础操作。 定义 这个应该见过多次 /** * autor:liman * createtime:2020/2/6 * comment:二叉树节点的实现 */ public class TreeNode { public String value ; public TreeNode left ; public TreeNode right ; public TreeNode ( String value ) { this . value = value ; } } 遍历的非递归实现 递归的实现非常简单，估计很多人都会，这里就介绍非递归的遍历实现 基本的遍历操作如下：这里示意的输出一下表示遍历操作 /** * 做遍历的操作。 * * @param node */ public static void doTraverse ( TreeNode node ) { System . out . print ( node . value + " " ) ; } 先序遍历 /** * 非递归实现的先序遍历,这里用到了栈的操作 * * @param root */ public static

#二叉树结点 class BinaryTreeNode(object): def __init__(self): self.data='#' self.LeftChild=None self.RightChild=None #二叉树类，创建二叉树和遍历二叉树 class BinaryTree(object): def CreateBinaryTree(self,Root): data=input('->') if data=='#': Root=None else: Root.data=data Root.LeftChild=BinaryTreeNode() self.CreateBinaryTree(Root.LeftChild) Root.RightChild=BinaryTreeNode() self.CreateBinaryTree(Root.RightChild) def PreOrder(self,Root): if Root is not None: self.VisitBinaryTreeNode(Root) self.PreOrder(Root.LeftChild) self.PreOrder(Root.RightChild) def InOrder(self,Root): if Root is not None: self.InOrder(Root

#类名称：BinaryTreeNode #类说明：定义一个二叉树的结点 #类释义：分别有左孩子LeftChild，右孩子RightChild和数据data class BinaryTreeNode(object): def __init__(self): self.data='#' self.LeftChild=None self.RightChild=None class TreeState(object): def __init__(self,BinaryTreeNode,VisitedFlag): self.BinaryTreeNode = BinaryTreeNode self.VisitedFlag = VisitedFlag #类说明：定义一个二叉树 class BinaryTreeNonRecursive(BinaryTreeNode): #创建二叉树的函数 def CreateBinaryTree(self,Root): data=input('->') if data=='#': Root=None else: Root.data=data Root.LeftChild=BinaryTreeNode() self.CreateBinaryTree(Root.LeftChild) Root.RightChild=BinaryTreeNode() self

递归遍历： 二叉树的三种递归遍历为先序遍历，中序遍历和后续遍历。它们相似之处在于都是对二叉树的递归遍历且对任何一个结点都经过三次，区别在于哪一次对该结点进行访问，由此分为先，中，后序遍历。所以对于任一结点都有：三次经过，一次访问。 先序遍历： void preorder(btNode* p) { if (p != NULL) { visit(p); preorder(p->lc); preorder(p->rc); } } 中序遍历： void inorder(btNode* p) { if (p != NULL) { inorder(p->lc); visit(p); inorder(p->rc); } } 后序遍历： void postorder(btNode* p) { if (p != NULL) { postorder(p->lc); postorder(p->rc); visit(p); } } 对于下图中的树： 先序遍历结果为：ABDECF 根 左 右 中序遍历结果为：DBEAFC 左 根 右 后序遍历结果为：DEBFCA 左 右 根 中序与先（后）序可唯一确定一颗二叉树。 层序遍历： 二叉树的层序遍历的实现思路：建立一个辅助数据结构队列，将二叉树头节点入队，在出队时将其左右孩子挨个入队，每出队一个结点，将其左右孩子入队，直至队列为空。 void level