中序遍历

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 =

题目链接 ： http://codeup.cn/problem.php?cid=100000611&pid=3 题目描述 编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 输入 输入包括1行字符串，长度不超过100。 输出 可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。 样例输入 a#b#cdef##### a## 样例输出 a b f e d c a 代码 # include <cstdio> char pre [ 110 ] ; int i ; struct node { char data ; node * lchild ; node * rchild ; } ; node * create ( ) { if ( pre [ i ] == '#' ) { i ++ ; return NULL ; } node * root = new node ; root -> data = pre [ i ] ; i ++ ; root -> lchild = create ( ) ; root ->

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,

给定一个二叉树，返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 注意迭代算法的实现，仔细思考迭代算法是怎么处理以下两种情况的： 1) 1 / 2 / 3 2) 1 / 2 / 3 \ 4 /** * 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 { public: vector<int> inorderTraversal(TreeNode* root) { vector<int> vec; inorder(&vec,root); return vec; } void inorder(vector<int> *vec,TreeNode* root){ if(root==NULL) return; inorder(vec,root->left); vec->push_back(root->val); inorder(vec,root->right); } };

题目链接: https://leetcode-cn.com/problems/binary-tree-inorder-traversal/ 迭代解决 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ class Solution { public List<Integer> inorderTraversal(TreeNode root) { Stack<TreeNode> stack=new Stack<>(); List<Integer> list=new ArrayList<>(); TreeNode temp=root; while(temp!=null||!stack.isEmpty()){ while(temp!=null){ stack.push(temp); temp=temp.left; } TreeNode node=stack.pop(); list.add(node.val); temp=node.right; } return list; } } 来源： CSDN 作者： phoenix_xqq 链接：

题目: 思路: 利用栈做迭代: 先遍历所有节点,直到找到最左节点,将这个节点的父节点抛出,加入栈,再遍历右子树. 代码: class Solution: def inorderTraversal(self, root: TreeNode) -> List[int]: ans,res=[],[] while ans or root: if root: ans.append(root) root=root.left else: root=ans.pop() res.append(root.val) root=root.right return res 来源： CSDN 作者： 海边的一只猿 链接： https://blog.csdn.net/qq_29760277/article/details/104400213

根据前序和中序遍历序列构建二叉树 思路： 根据前序序列找到根在中序序列中的位置，从而找到左右子树的中序序列，再根据左右子树的长度，找到它们的前序序列，递归计算。 代码： """ 使用先序遍历和中序遍历的结果重建二叉树 """ from collections import deque class TreeNode(object): """ 二叉树结点定义 """ def __init__(self, x): self.val = x self.left = None self.right = None class Tree(object): """ 二叉树 """ def __init__(self): self.root = None def bfs(self): ret = [] queue = deque([self.root]) while queue: node = queue.popleft() if node: ret.append(node.val) queue.append(node.left) queue.append(node.right) return ret def pre_traversal(self): ret = [] def traversal(head): if not head: return ret.append(head.val)

数据结构-栈 单调栈解决 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 -- ) { // 倒着往栈里放

重建二叉树 题目描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 思路分析 前序遍历的确定根节点，可以根据此点分别找到左子树跟右子树的前序遍历序列和中序遍历序列，通过递归再分别构建子树的左子树和右子树。代码如下: public TreeNode reConstructBinaryTree ( int [ ] pre , int [ ] in ) { return reConstructBinaryTree ( pre , 0 , pre . length - 1 , in , 0 , in . length - 1 ) ; } public TreeNode reConstructBinaryTree ( int [ ] pre , int preStart , int preEnd , int [ ] in , int inStart , int inEnd ) { if ( preStart > preEnd || inStart > inEnd ) return null ; TreeNode root = new TreeNode ( pre [ preStart ] ) ; for

树 客观世界中许多事物存在层次关系 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