前序遍历

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,

根据前序和中序遍历序列构建二叉树 思路： 根据前序序列找到根在中序序列中的位置，从而找到左右子树的中序序列，再根据左右子树的长度，找到它们的前序序列，递归计算。 代码： """ 使用先序遍历和中序遍历的结果重建二叉树 """ 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)

解题思路 不让用递归，那只能自己模拟了。其实很简单，前序遍历的话，只要先把右边的节点push到栈里即可。具体原因可以自己画图分析。 代码 /** * 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 > preorderTraversal ( TreeNode * root ) { vector < int > ans ; if ( root == NULL ) return ans ; stack < TreeNode * > sta ; sta . push ( root ) ; while ( sta . empty ( ) == 0 ) { TreeNode * tmp = sta . top ( ) ; sta . pop ( ) ; ans . push_back ( tmp - > val ) ; if ( tmp - > right ) sta . push ( tmp - > right ) ; if (

数据结构-栈 单调栈解决 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

Case1:满二叉树 题目描述 给出一棵满二叉树的先序遍历，有两种节点：字母节点（A-Z，无重复）和空节点（#）。要求这个树的中序遍历。输出中序遍历时不需要输出#。满二叉树的层数n满足1<=n<=5。 示例1 Sample Input: ABC#D#ESample Output:CBADE Solution： 满二叉树的特征很明显，左右子树结点个数相等，那么以某一个结点为根的子树中，该根节点在先序遍历中排在第一位，其在中序遍历中一定排在最中间的位置上。利用分治的思想，建立一个数组， 　　根节点插入到数组中间位置， 　　左子树根节点插入到数组左边的中间位置， 　　一直这样直至数组左边中间位置已满开始插入到右边数组的中间位置， 　　依次递归 . . . . . . 以示例为例，遍历前序遍历字符串插入到数组中，最后输出数组中字符串，即为中序遍历字符串。 #include <iostream> #include <string.h> using namespace std; int i; // 全局变量，控制字符串的遍历 string s; void insert(char a[], int left, int right){ // 将字符串各个元素插入数组对应位置 int mid = (left + right) / 2; if(left <= right && a[mid] != s

镜面反转 ：是指将所有非叶结点的左右孩子对换。 1.已知先序遍历，中序遍历，求层序遍历 （这道题求层序的镜面反转，所以每一层 从右向左 遍历） #include<iostream> #include<algorithm> #include<queue> using namespace std; const int N = 10110; int pre[N],mid[N]; //前序遍历 中序遍历结果 int n,cnt; queue<int> q; struct Node { int w; int l,r; }node[N]; void bulid(int l,int r,int pos) { if(l>=r) { node[pos].w = -1; return; } int root = pre[cnt++]; node[pos].w = root; node[pos].l = 2*pos;//左子结点 node[pos].r = 2*pos+1;//右子结点 int m = find(mid,mid+r,root)-mid; //algorithm中的find()函数,返回指针 bulid(l,m,2*pos); bulid(m+1,r,2*pos+1); } void LevelPrint() { q.push(1); int pos; while(!q.empty())

二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中，前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一点。 前序遍历 递归 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.中序遍历 根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点