后序遍历

根据一棵树的中序遍历与后序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如，给出 中序遍历 inorder = [9,3,15,20,7] 后序遍历 postorder = [9,15,7,20,3] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 code：先中序中找到根后，可以根据根在中序中的位置划分左右子树的长度，根据中序中划分的左右子树的长度，在后序中划分左右子树，后序序列中：左、右、根。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { private: TreeNode* buildTreeCore(vector<int>& in,int inStart,int inEnd, vector<int>& post,int postStart,int postEnd) { if(inStart>inEnd||postStart>postEnd) return nullptr; TreeNode* root=new

欢迎关注我的公众号“彤哥读源码”，查看更多源码系列文章, 与彤哥一起畅游源码的海洋。 二叉树的遍历 我们知道二叉查找树的遍历有前序遍历、中序遍历、后序遍历。 （1）前序遍历，先遍历我，再遍历我的左子节点，最后遍历我的右子节点； （2）中序遍历，先遍历我的左子节点，再遍历我，最后遍历我的右子节点； （3）后序遍历，先遍历我的左子节点，再遍历我的右子节点，最后遍历我； 这里的前中后都是以“我”的顺序为准的，我在前就是前序遍历，我在中就是中序遍历，我在后就是后序遍历。 下面让我们看看经典的中序遍历是怎么实现的： public class TreeMapTest { public static void main(String[] args) { // 构建一颗10个元素的树 TreeNode<Integer> node = new TreeNode<>(1, null).insert(2) .insert(6).insert(3).insert(5).insert(9) .insert(7).insert(8).insert(4).insert(10); // 中序遍历，打印结果为1到10的顺序 node.root().inOrderTraverse(); } } /** * 树节点，假设不存在重复元素 * @param <T> */ class TreeNode<T extends

class Node ( object ) : def __init__ ( self , item ) : self . item = item self . lchild = None self . rchild = None class Tree ( object ) : """二叉树""" def __init__ ( self ) : self . root = None def add ( self , item ) : node = Node ( item ) if self . root is None : self . root = node return None queue = [ self . root ] while queue : cur = queue . pop ( 0 ) if cur . lchild is None : cur . lchild = node return None else : queue . append ( cur . lchild ) if cur . rchild is None : cur . rchild = node return None else : queue . append ( cur . rchild ) def breadth_travel ( self ) : """广度遍历""" queue =

一、题目描述 Given an n - ary tree , return the postorder traversal of its nodes' values . Nary - Tree input serialization is represented in their level order traversal , each group of children is separated by the null value ( See examples ) . Follow up : Recursive solution is trivial , could you do it iteratively ? Input : root = [ 1 , null , 3 , 2 , 4 , null , 5 , 6 ] Output : [ 5 , 6 , 3 , 2 , 4 , 1 ] 二、题解 方法一：递归 LinkedList < Integer > resList = null ; //先节点后跟 public List < Integer > postorder ( Node root ) { dfs ( root ) ; return resList ; } private void dfs ( Node root ) { if ( root == null )

package com.study; /* * 根据二叉树的前序遍历和中序遍历结果重建二叉树 * 并输出其头节点。假设前序遍历和中序遍历结果中没有重复数字 * 前序遍历序列：{1，2，4，7，3，5，6，8} * 中序遍历序列：{4，7，2，1，5，3，8，6} * **/ class TreeNode { public int data; public TreeNode left; public TreeNode right; public TreeNode() { } } public class suanfa4 { private static int[] arr1 = {1,2,4,7,3,5,6,8}; private static int[] arr2 = {4,7,2,1,5,3,8,6}; public static TreeNode RebuildBinaryTree() { TreeNode head = null; head = ConstructBTree( head ,arr1, 0, 7, arr2, 0, 7); return head; } public static TreeNode ConstructBTree(TreeNode node, int[] pre, int pre_start, int pre_end, int[] inorder,

二叉树的后序遍历相比较前序和中序复杂一些。我们需要一个标记来记忆我们此时节点上一个节点。 具体的java代码如下: // 二叉树的后序遍历 public static void postOrderTraverWithStack(TreeNode node){ Stack<TreeNode> stack = new Stack<>(); TreeNode treeNode = node; // 标记位 TreeNode lastVisit = null; while(treeNode != null || !stack.isEmpty()){ while(treeNode != null){ stack.push(treeNode); treeNode = treeNode.leftChild; } // 栈不为空 if(!stack.isEmpty()){ // 出栈 treeNode = stack.pop(); /*** * 这块就是判断treeNode是否有右孩子， * 如果没有输出treeNode.data, 让lastVisit指向treeNode, 并让treeNode为空 * 如果有右孩子, 将当前节点继续入栈，treeNode指向它的有孩子，继续重复循环 */ // 这里其实是访问到根节点后有两条路径，一个是当没有右孩子或者右孩子被访问过后， // 打印根节点

题目描述 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。 思路 分治法。 不断地确定出左子树区间和右子树区间，并且判断：左子树区间的所有结点值 < 根结点值 < 右子树区间所有结点值。 序列最后一个数是根节点，序列第一个大于根节点的数是潜在的右子树第一个结点。 时间复杂度O(n²)，空间复杂度O(n)。 代码1 public class Solution { private boolean helper(int[] sequence, int start, int root) { if(start >= root) return true; // 代码1为两段局部循环，mid的初始值容易出错，代码2的全局循环不存在这个问题 int mid = root-1; for(int i = start; i < root; i++) { if(sequence[i] > sequence[root]) { mid = i; break; } } for(int j = mid+1; j < root; j++) { if(sequence[j] < sequence[root]) { return false; } } return helper(sequence, start, mid-1) &&

数据结构-栈 单调栈解决 Next Greater Number 一类问题 给一个字符串或一个数组要求对其进行分析 给一个字符串进行分析 给一个数组进行分析 二叉树的遍历 前序遍历 中序遍历 后续遍历 基本的核心思想就是：当解决某个问题的时候，只关心最近一次的操作，并且在操作完成了之后，需要向前查找到更前一次的操作 每次处理只对栈顶元素进行处理 单调栈解决 Next Greater Number 一类问题 这里题目是给定一个数组，找出每一个元素之后比它大的数值或者索引号。最粗暴的方法就是遍历数组，但是这是一个 O ( n 2 ) O(n^2) O ( n 2 ) 复杂度的方法。 思想： 利用排队的思想，比如找第一个元素2的Next Greater Number，那么就是找那个比2要高的，不被2挡住的第一个元素，那就是4，以此类推。 利用栈，从数组的后面开始遍历，逐个入栈，实际出栈顺序却是正序。 vector < int > nextGreaterElement ( vector < int > & nums ) { vector < int > ans ( nums . size ( ) ) ; // 存放答案的数组 stack < int > s ; for ( int i = nums . size ( ) - 1 ; i >= 0 ; i -- ) { // 倒着往栈里放

树 客观世界中许多事物存在层次关系 eg:人类社会家谱 社会组织结构 图书信息管理 分层次组织在管理上具有更高的效率 查找（Searching）：给定某个关键字K，从集合R中找出关键字与K相同的记录 静态查找：集合中记录是固定的 没有插入和删除操作，只有查找 动态查找：集合中记录是动态变化的 除查找，还可能发生查找和删除 静态查找 顺序查找 typedef struct LNode *List; struct LNode{ ElementType Element[MAXSIZE]; int Length; } int SequentialSearch(List Tb1, ElementType K){ int i; Tb1->Element[0]=K;//哨兵！这样可以减少判断 for(i=Tb1->Length;Tb1->Element[i]!=K;i--); return i; } 二分查找 Binary Search O(log(n)) 假设n个数据元素的关键字满足有序 \(k_1<k_2<k_3<...<k_n\) ，并且是连续存放（数组），那么可以进行二分查找。 typedef LNode *List; struct LNode{ ElementType Element[MAXSIZE]; int Length; } int BinarySearch(List PtrL

本文转载自作者：hzhu212 链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/yan-se-biao-ji-fa-yi-chong-tong-yong-qie-jian-ming/ 来源：力扣（LeetCode） 官方题解中介绍了三种方法来完成树的中序遍历，包括： 递归 借助栈的迭代方法 莫里斯遍历 在树的深度优先遍历中（包括前序、中序、后序遍历），递归方法最为直观易懂，但考虑到效率，我们通常不推荐使用递归。 栈迭代方法虽然提高了效率，但其嵌套循环却非常烧脑，不易理解，容易造成“一看就懂，一写就废”的窘况。而且对于不同的遍历顺序（前序、中序、后序），循环结构差异很大，更增加了记忆负担。 因此，我在这里介绍一种“颜色标记法”（瞎起的名字……），兼具栈迭代方法的高效，又像递归方法一样简洁易懂，更重要的是，这种方法对于前序、中序、后序遍历，能够写出完全一致的代码。 其核心思想如下： 使用颜色标记节点的状态，新节点为白色，已访问的节点为灰色。 如果遇到的节点为白色，则将其标记为灰色，然后将其右子节点、自身、左子节点依次入栈。 如果遇到的节点为灰色，则将节点的值输出。 使用这种方法实现的中序遍历如下： class Solution : def inorderTraversal ( self