Algorithm 二叉树从顺序和水平顺序遍历？
我们能证明一个人能从它的顺序和顺序遍历中明确地构造一棵二叉树吗 我在想一个归纳法的证明 基本情况：具有1或2个级别的树。这些情况很清楚 假设这适用于具有l级别的树。也就是说：可以从其顺序和级别顺序遍历中明确地构造具有l个级别的二叉树Algorithm 二叉树从顺序和水平顺序遍历？,algorithm,binary-tree,Algorithm,Binary Tree,我们能证明一个人能从它的顺序和顺序遍历中明确地构造一棵二叉树吗 我在想一个归纳法的证明 基本情况：具有1或2个级别的树。这些情况很清楚 假设这适用于具有l级别的树。也就是说：可以从其顺序和级别顺序遍历中明确地构造具有l个级别的二叉树 归纳案例：证明这适用于具有l+1水平的树。不清楚在这种情况下如何进行。任何帮助都将不胜感激。不确定是否有证据，但这样做的alg将遵循以下原则： f(inorder, levelorder): if length(levelorder) == 0:
归纳案例：证明这适用于具有l+1水平的树。不清楚在这种情况下如何进行。任何帮助都将不胜感激。不确定是否有证据，但这样做的alg将遵循以下原则：
f(inorder, levelorder):
if length(levelorder) == 0:
return None
root = levelorder[0]#set root to first element in levelorder
subIn1, subIn2 = partition(inorder, levelorder[0]) #partition inorder based on root
subLevel1 = extract(levelOrder, subIn1)#remove elements in level order not in subIn1
subLevel2 = extract(levelOrder, subIn2)#remove elements in level order not in subIn2
root->left = f(subIn1, subLevel1)
root->right = f(subIn2, subLevel2)
return root
哦，是的，你可能必须证明一个级别顺序遍历中的第一个元素是树的根，但这应该来自于定义。我在我的博客上给出了这个教程a）-inoder遍历 -后序遍历 或 b） -有序遍历 -前序遍历 我们通常会遇到这样的问题：- 从以下树遍历创建二进制树 (一) 在这里，最重要的一点是要永远记住：- 在前序中，第一个元素是树的根 在后序中最后一个元素是树的根 我希望你得到它：p i、 e.审议（1）问题 1） 顺序：E A C K F H D B G 前序：F A E K C D H G B F是根 eACk将转到根的左子树 hdbg将转到根的右子树
Step 1)
F
/ \
( E A C K) (H D B G)
Step 2)
F
/ \
A (H D B G)
/ \
E (C K)
Step 3)
F
/ \
A (H D B G)
/ \
E K
/
C
Inorder C K
Preorder K C
F
/ \
A (H D B G)
/ \
E (C K)
Step 3)
F
/ \
A (H D B G)
/ \
E K
/
C
彩色完整版本，或者可以在这里看到：p我认为下面的代码应该可以工作-
/*
//construct a bst using inorder & levelorder traversals.
//inorder - 5, 10, 20, 50, 51, 55, 60, 65, 70, 80
//levelorder - 50, 10, 60, 5, 20, 55, 70, 51, 65, 80
50
/ \
10 60
/ \ / \
5 20 55 70
/ / \
51 65 80
*/
struct node *construct_bst3(int inorder[], int levelorder[], int in_start, int in_end)
{
static int levelindex = 0;
struct node *nnode = create_node(levelorder[levelindex++]);
if (in_start == in_end)
return nnode;
//else find the index of this node in inorder array. left of it is left subtree, right of this index is right.
int in_index = search_arr(inorder, in_start, in_end, nnode->data);
//using in_index from inorder array, constructing left & right subtrees.
nnode->left = construct_bst3(inorder, levelorder, in_start, in_index-1);
nnode->right = construct_bst3(inorder, levelorder, in_index+1, in_end);
return nnode;
}
此代码运行良好，没有任何运行时错误。很抱歉使用Bruteforce方法。 printPretty（）的代码可在
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
结构二叉树{
二叉树*左，*右；
字符数据；
二进制树（int-val）：左（NULL）、右（NULL）、数据（val）{}
~BinaryTree（）{this->left=NULL；this->right=NULL；}
};
BinaryTree*createNode（字符d）
{
返回新的二进制树（d）；
}
#定义最大值256
int indexOf[MAX]；
void索引索引（字符*IN，整数n）
{
int i=0；
对于（i=0；i左=根->右=空；
对于（i=lev_st+1；i idx）和&（indexOf[（int）level[i]]=in_st））
如果（左水平idx==-1）
左水平idx=i；
}
如果（左水平idx！=-1）
root->left=INLEVEL（in，level，in_st，idx-1，left_lev_idx，lev_end）；
如果（右水平idx！=-1）
root->right=INLEVEL（in，level，idx+1，in\u end，right\u lev\u idx，lev\u end）；
返回根；
}
int main（）
{
[100]中的字符=“DBFEAGCLJHK”
，级别[100]=“ABCDEGHFJKL”；
BinaryTree*根=（BinaryTree*）NULL；
索引索引（IN，strlen（IN））；
root=INLEVEL（IN，LEVEL，0，strlen（IN）-1,0，strlen（IN）-1）；
//printPretty（根，2，0，cout）；
返回0；
}
静态树maketreefrominorder和levelorder（int[]inorder，int[]lorder，int s，int n，int cnt1）{
如果（s>n | | s>=inorder.length | | n>=inorder.length | | cnt1>=inorder.length）{
返回null；
}
int mIndex=搜索（领主[cnt1]，顺序，s，n）；
树t=新树（主[cnt1]）；
cnt1=2*cnt1+1；
t、 左=maketreefrominorder和levelorder（inorder、lorder、s、mIndex-1、cnt1）；
//边界情况
如果（cnt1Java解决方案：
import java.util.HashMap;
import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;
public class InorderLevelorder {
private static int[] levelArray;
public static void main(String[] args) {
//in order traversal of binary tree
int[] in = {4,10,3,1,7,11,8,2};
//level order traversal of binary tree
int[] lev = {7,10,2,4,3,8,1,11};
//Builds a Binary Tree and returns the root node
buildTree(in, lev);
}
private static BinaryTreeNode buildTree(int[] in, int[] lev){
//Hash the values of both the arrays for O(1) time search
HashMap<Integer, Integer> inMap = new HashMap<Integer, Integer>();
HashMap<Integer, Integer> levMap = new HashMap<Integer, Integer>();
levelArray = lev;
for(int i=0;i<in.length;i++)
inMap.put(in[i], i);
for(int j=0;j<lev.length;j++)
levMap.put(lev[j], j);
return buildTree(in, lev, 0, in.length - 1, inMap, levMap);
}
//recursive method that constructs the binary tree
private static BinaryTreeNode buildTree(int[] in, int[] lev, int inStart, int inEnd, HashMap<Integer, Integer> inMap, HashMap<Integer, Integer> levMap){
if(inStart > inEnd)
return null;
int nodeVal = lev[0];
BinaryTreeNode node = new BinaryTreeNode();
node.setData(nodeVal);
if(inStart == inEnd)
return node;
int inIndex = inMap.get(nodeVal);
int[] leftSubTree = subArray(in, levelArray, inStart, inIndex-1, inMap, levMap);
int[] rightSubTree = subArray(in, levelArray, inIndex+1, inEnd, inMap, levMap);
node.setLeftNode(buildTree(in, leftSubTree, inStart, inIndex-1, inMap, levMap));
node.setRightNode(buildTree(in, rightSubTree, inIndex+1, inEnd, inMap, levMap));
return node;
}
private static int[] subArray(int[] in, int[] lev, int inStart, int inEnd, HashMap<Integer, Integer> inMap, HashMap<Integer, Integer> levMap){
int[] newSubArray = new int[inEnd - inStart + 1];
SortedSet<Integer> set = new TreeSet<Integer>();
for(int i=inStart;i<=inEnd;i++){
int levIndex = levMap.get(in[i]);
set.add(levIndex);
}
int j=0;
Iterator<Integer> iter = set.iterator();
while(iter.hasNext()){
int levIndex = iter.next();
int levValue = lev[levIndex];
newSubArray[j] = levValue;
j++;
}
return newSubArray;
}
}
class BinaryTreeNode {
private int data;
private BinaryTreeNode leftNode;
private BinaryTreeNode rightNode;
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public BinaryTreeNode getLeftNode() {
return leftNode;
}
public void setLeftNode(BinaryTreeNode leftNode) {
this.leftNode = leftNode;
}
public BinaryTreeNode getRightNode() {
return rightNode;
}
public void setRightNode(BinaryTreeNode rightNode) {
this.rightNode = rightNode;
}
}
import java.util.HashMap；
导入java.util.Iterator；
导入java.util.SortedSet；
导入java.util.TreeSet；
公共类有序{
私有静态int[]levelArray；
公共静态void main（字符串[]args）{
//二叉树的有序遍历
int[]in={4,10,3,1,7,11,8,2}；
//二叉树的级序遍历
int[]lev={7,10,2,4,3,8,1,11}；
//构建二叉树并返回根节点
buildTree（in，lev）；
}
私有静态二进制树节点构建树（int[]in，int[]lev）{
//散列两个数组的值以进行O（1）时间搜索
HashMap inMap=新的HashMap（）；
HashMap levMap=新的HashMap（）；
levelArray=lev；
对于（inti=0；iHuh…只是好奇，这是家庭作业吗？：）很抱歉，我之前提到过。不，这不是一个家庭作业。我正在尝试解决这个问题，我相信，如果我们有证据证明这一点，它是可以解决的。你能解释一下extract
函数做什么吗？extract函数需要返回levelOrder和subIn的交集，以levelOrder维护顺序。
static tree MakeTreeFromInorderAndLevelOrder(int[] inorder,int[] lorder,int s,int n,int cnt1) {
if(s>n || s>=inorder.length || n>=inorder.length || cnt1>=inorder.length) {
return null;
}
int mIndex = Search(lorder[cnt1],inorder,s,n);
tree t = new tree(lorder[cnt1]);
cnt1 = 2*cnt1 + 1;
t.left = MakeTreeFromInorderAndLevelOrder(inorder,lorder,s,mIndex-1,cnt1);
//Boundary case
if(cnt1<inorder.length && t.left==null) {
t.right = MakeTreeFromInorderAndLevelOrder(inorder,lorder,mIndex+1,n,cnt1);
}
else {
cnt1 -=1;
cnt1 /=2;
cnt1 = 2*cnt1 + 2;
t.right = MakeTreeFromInorderAndLevelOrder(inorder,lorder,mIndex+1,n,cnt1);
//Boundary case
if(t.right ==null && cnt1<inorder.length) {
t.left = MakeTreeFromInorderAndLevelOrder(inorder,lorder,s,mIndex-1,cnt1);
}
}
return t;
}
import java.util.HashMap;
import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;
public class InorderLevelorder {
private static int[] levelArray;
public static void main(String[] args) {
//in order traversal of binary tree
int[] in = {4,10,3,1,7,11,8,2};
//level order traversal of binary tree
int[] lev = {7,10,2,4,3,8,1,11};
//Builds a Binary Tree and returns the root node
buildTree(in, lev);
}
private static BinaryTreeNode buildTree(int[] in, int[] lev){
//Hash the values of both the arrays for O(1) time search
HashMap<Integer, Integer> inMap = new HashMap<Integer, Integer>();
HashMap<Integer, Integer> levMap = new HashMap<Integer, Integer>();
levelArray = lev;
for(int i=0;i<in.length;i++)
inMap.put(in[i], i);
for(int j=0;j<lev.length;j++)
levMap.put(lev[j], j);
return buildTree(in, lev, 0, in.length - 1, inMap, levMap);
}
//recursive method that constructs the binary tree
private static BinaryTreeNode buildTree(int[] in, int[] lev, int inStart, int inEnd, HashMap<Integer, Integer> inMap, HashMap<Integer, Integer> levMap){
if(inStart > inEnd)
return null;
int nodeVal = lev[0];
BinaryTreeNode node = new BinaryTreeNode();
node.setData(nodeVal);
if(inStart == inEnd)
return node;
int inIndex = inMap.get(nodeVal);
int[] leftSubTree = subArray(in, levelArray, inStart, inIndex-1, inMap, levMap);
int[] rightSubTree = subArray(in, levelArray, inIndex+1, inEnd, inMap, levMap);
node.setLeftNode(buildTree(in, leftSubTree, inStart, inIndex-1, inMap, levMap));
node.setRightNode(buildTree(in, rightSubTree, inIndex+1, inEnd, inMap, levMap));
return node;
}
private static int[] subArray(int[] in, int[] lev, int inStart, int inEnd, HashMap<Integer, Integer> inMap, HashMap<Integer, Integer> levMap){
int[] newSubArray = new int[inEnd - inStart + 1];
SortedSet<Integer> set = new TreeSet<Integer>();
for(int i=inStart;i<=inEnd;i++){
int levIndex = levMap.get(in[i]);
set.add(levIndex);
}
int j=0;
Iterator<Integer> iter = set.iterator();
while(iter.hasNext()){
int levIndex = iter.next();
int levValue = lev[levIndex];
newSubArray[j] = levValue;
j++;
}
return newSubArray;
}
}
class BinaryTreeNode {
private int data;
private BinaryTreeNode leftNode;
private BinaryTreeNode rightNode;
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public BinaryTreeNode getLeftNode() {
return leftNode;
}
public void setLeftNode(BinaryTreeNode leftNode) {
this.leftNode = leftNode;
}
public BinaryTreeNode getRightNode() {
return rightNode;
}
public void setRightNode(BinaryTreeNode rightNode) {
this.rightNode = rightNode;
}
}