4
/**
*1.利用层次遍历和中序遍历还原数组，我采用的是递归的方式，同时在递归的过程中判断记录叶子节点
*2.先序遍历
*3.后序遍历
*说明：中序遍历的根节点左边是左子树，右边是右子树，在层次遍历中根节点是第一个，然后把左子树的层次遍历和右子树的此次遍历提取出来进行递归
*/ import java.util.*;
public class Main {
public static StringBuffer sb1=new StringBuffer();
public static StringBuffer sb2=new StringBuffer();
public static StringBuffer sb3=new StringBuffer();
public static void main(String[] args){
Scanner scan=new Scanner(System.in);
String str1=scan.nextLine();
String str2=scan.nextLine();
String[] s1=str1.split(" ");
TreeNode root=xun(s1,str2);
preOrder(root);
postOrder(root);
System.out.println(sb1.toString().trim());
System.out.println(sb2.toString().trim());
System.out.println(sb3.toString().trim());
}
public static TreeNode xun(String[] a,String b){
if(b.length()==0) return null;
int index=0;
String[] s2=b.split(" ");
int len=s2.length;
TreeNode temp=new TreeNode(a[0]);
for(;index
if(a[0].equals(s2[index])) break;
}
ArrayList list1=new ArrayList(Arrays.asList(a));
ArrayList list2=new ArrayList(Arrays.asList(a));
for(int i=0;i<=index;i++)
list1.remove(s2[i]);
for(int i=index;i
list2.remove(s2[i]);
temp.left=xun(list2.toArray(new String[list1.size()]),b.substring(0,b.indexOf(s2[index])));
if(index==len-1)
temp.right=null;
else
temp.right=xun(list1.toArray(new String[list2.size()]),b.substring(b.indexOf(s2[index+1])));
if(temp.left==null&&temp.right==null) sb1.append(temp.val+" ");
return temp;
}
public static void preOrder(TreeNode root){
if(root!=null){
sb2.append(root.val+" ");
preOrder(root.left);
preOrder(root.right);
}
}
public static void postOrder(TreeNode root){
if(root!=null){
postOrder(root.left);
postOrder(root.right);
sb3.append(root.val+" ");
}
}
}
class TreeNode{
public String val;
public TreeNode left;
public TreeNode right;
public TreeNode(String val){
this.val=val;
this.left=null;
this.right=null;
}
}
编辑于 2019-05-10 20:15:31
回复(6)
5
class TreeNode(object):
def __init__(self, x):
self.left = None
self.right = None
self.val = x
class Solution(object):
def __init__(self):
self.leaf = []
def creatTree(self, bfsorder, inorder):
"""
从中序遍历找出左右子树，然后再从序列层次遍历中找出左右子树序列，重建二叉树
:param bfsorder:
:param inorder:
:return:
"""
if len(bfsorder) < 1:
return
if len(bfsorder) == 1 and bfsorder[0] not in self.leaf:
self.leaf.append(bfsorder[0])
# print(self.leaf)
root = TreeNode(bfsorder[0])
root_index = inorder.index(root.val) # 根节点在中序遍历的索引
left_in = inorder[:root_index] # 中序遍历的左子树
right_in = inorder[root_index + 1:] # 中序遍历的左子树
left_bsf = [x for x in bfsorder if x in left_in] # 层次遍历的左子树、
right_bfs = [x for x in bfsorder if x in right_in]
root.left = self.creatTree(left_bsf, left_in)
root.right = self.creatTree(right_bfs, right_in)
return root
def preorder(self, root):
if not root:
return []
return [root.val] + self.preorder(root.left) + self.preorder(root.right)
def postorder(self, root):
if not root:
return []
return self.postorder(root.left) + self.postorder(root.right) + [root.val]
s = Solution()
bfsorder = [int(x) for x in input().split()]
inorder = [int(x) for x in input().split()]
root = s.creatTree(bfsorder, inorder)
pre = s.preorder(root)
post = s.postorder(root)
print(' '.join(list(map(str,s.leaf))))
print(' '.join(list(map(str,pre))))
print(' '.join(list(map(str,post))))
发表于 2019-05-20 15:27:10
回复(1)
2
import java.util.*;
class TreeNode {
public String val;
public TreeNode left;
public TreeNode right;
public TreeNode(String val) {
this.val = val;
this.left = null;
this.right = null;
}
}
public class Main {
public static StringBuilder sb1 = new StringBuilder();
public static StringBuilder sb2 = new StringBuilder();
public static StringBuilder sb3 = new StringBuilder();
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String[] levelTranversal = scan.nextLine().split(" ");
String[] inOrderTranversal = scan.nextLine().split(" ");
scan.close();
//
TreeNode root = getBinaryTree(levelTranversal, inOrderTranversal);
preOrder(root);
lastOrder(root);
//
System.out.println(sb1.toString().trim());
System.out.println(sb2.toString().trim());
System.out.println(sb3.toString().trim());
}
public static TreeNode getBinaryTree(String[] levelTranversal, String[] inOrderTranversal) {
if (inOrderTranversal.length == 0)
return null;
//
int index = 0;
int inOrderTranversalLength = inOrderTranversal.length;
TreeNode temp = new TreeNode(levelTranversal[0]);
// 1. 找到这一轮的根节点
while (!levelTranversal[0].equals(inOrderTranversal[index])) {
index++;
}
// 2. 两数组存放中序序列划分出来的左边和右边，其分别包含了原二叉树的左子树和右子树
String[] inOrderTranversalLeft = new String[index];
String[] inOrderTranversalRight = new String[inOrderTranversalLength - index - 1];
// 复制填充数据
System.arraycopy(inOrderTranversal, 0, inOrderTranversalLeft, 0, inOrderTranversalLeft.length);
for (int i = 0; i
inOrderTranversalRight[i] = inOrderTranversal[index + i + 1];
}
// 3. 存放原二叉树左子树的层级序列，即中序序列划分出来的左边对应的层级序列。右边同理。
String[] levelTranversalLeft = new String[inOrderTranversalLeft.length];
String[] levelTranversalRight = new String[inOrderTranversalRight.length];
// 填充数据
int leftIndex = 0, rightIndex = 0;
for (int i = 1; i
// 是左的放左，否则就是右的，放右
if (contains(inOrderTranversalLeft, levelTranversal[i])) {
levelTranversalLeft[leftIndex++] = levelTranversal[i];
}else {
levelTranversalRight[rightIndex++] = levelTranversal[i];
}
}
// 4. 递归处理左节点和右节点
temp.left = getBinaryTree(levelTranversalLeft, inOrderTranversalLeft);
temp.right = getBinaryTree(levelTranversalRight, inOrderTranversalRight);
// 5. 存放叶子节点
if (temp.left == null && temp.right == null) {
sb1.append(temp.val).append(" ");
}
return temp;
}
private static boolean contains(String[] arr, String key) {
for (String element : arr) {
if (element.equals(key)) return true;
}
return false;
}
public static void preOrder(TreeNode root) {
if (root != null) {
sb2.append(root.val).append(" ");
preOrder(root.left);
preOrder(root.right);
}
}
public static void lastOrder(TreeNode root) {
if (root != null) {
lastOrder(root.left);
lastOrder(root.right);
sb3.append(root.val).append(" ");
}
}
}
发表于 2019-10-06 10:36:26
回复(2)
2
#include
#include
#include
#include
#include
using namespace std;
struct TreeNode
{
int val;
TreeNode *left,*right;
TreeNode(int v):val(v),left(nullptr),right(nullptr){}
};
TreeNode* createTree(vectorinorder,vectorseq,int begin,int end)
{
if(seq.size()<=0) return nullptr;
TreeNode *root=new TreeNode(seq[0]);
vectorleft;
vectorright;
int k;
for(k=begin;k<=end;++k)
if(inorder[k]==seq[0])
break;
bool isleft;
for(int i=1;i
{
isleft=false;
for(int j=begin;j
{
if(seq[i]==inorder[j])
{
isleft=true;
break;
}
}
if(isleft)
left.push_back(seq[i]);
else right.push_back(seq[i]);
}
root->left=createTree(inorder,left,begin,k-1);
root->right=createTree(inorder,right,k+1,end);
return root;
}
void preorder(TreeNode *ptr,vector&pre)
{
if(ptr!=nullptr)
{
pre.push_back(ptr->val);
preorder(ptr->left,pre);
preorder(ptr->right,pre);
}
}
void postorder(TreeNode *ptr,vector&post)
{
if(ptr!=nullptr)
{
postorder(ptr->left,post);
postorder(ptr->right,post);
post.push_back(ptr->val);
}
}
void getleafNode(TreeNode *ptr,vector&leaf)
{
if(ptr==nullptr) return ;
if(ptr!=nullptr&&ptr->left==nullptr&&ptr->right==nullptr)
{
leaf.push_back(ptr->val);
return ;
}
getleafNode(ptr->left,leaf);
getleafNode(ptr->right,leaf);
return ;
}
int main()
{
int n;
char *str=new char[100];
vectorinorder;
vectorseq;
cin.getline(str,100);
char *temp;
temp=strtok(str," ");
while(temp)
{
sscanf(temp,"%d",&n);
seq.push_back(n);
temp=strtok(NULL," ");
}
cin.getline(str,100);
temp=strtok(str," ");
while(temp)
{
sscanf(temp,"%d",&n);
inorder.push_back(n);
temp=strtok(NULL," ");
}
TreeNode *root=createTree(inorder,seq,0,inorder.size()-1);
vectorpre,post,leaf;
preorder(root,pre);
postorder(root,post);
getleafNode(root,leaf);
for(int i=0;i
cout<
cout<
for(int i=0;i
cout<
cout<
for(int i=0;i
cout<
cout<
return 0;
}
发表于 2019-05-17 10:50:24
回复(0)
1
没有重建出来整棵树，但是也是通过递归来类似的遍历重建树的过程，并在过程中通过存入一个链表来维护。
import java.util.*;
import static java.util.Arrays.asList;
import static java.util.Arrays.copyOfRange;
public class Main{
static List treefinal = new ArrayList();
public static void main(String []args){
Scanner in = new Scanner(System.in);
String []str1 = in.nextLine().split(" ");
String []str2 = in.nextLine().split(" ");
List pre = Main.findpre(str1,str2);
List back = Main.findback2(str1,str2);
System.out.print(treefinal.get(0));
for(int i = 1; i
System.out.print(" ");
System.out.print(treefinal.get(i));
}
System.out.println();
System.out.print(pre.get(0));
for(int i = 1; i
System.out.print(" ");
System.out.print(pre.get(i));
}
System.out.println();
System.out.print(back.get(0));
for(int i = 1; i
System.out.print(" ");
System.out.print(back.get(i));
}
}
public static List findpre(String[] str1, String[] str2){
if(str1.length==0){
return new ArrayList();
}
List curstr = new ArrayList(asList(str1[0]));
for(int i = 0; i
if(str2[i].equals(str1[0])){
List curpre1 = new ArrayList();
List curpre2 = new ArrayList();
List curin1 = asList(copyOfRange(str2,0,i));
List curin2 = asList(copyOfRange(str2,i+1,str2.length));
for(int j = 1; j
if(curin1.contains(str1[j])){
curpre1.add(str1[j]);
}else{
curpre2.add(str1[j]);
}
}
String[] test1= curpre1.toArray(new String[curpre1.size()]);
String[] test2= curin1.toArray(new String[curin1.size()]);
String[] test3= curpre2.toArray(new String[curpre2.size()]);
String[] test4= curin2.toArray(new String[curin2.size()]);
curstr.addAll(findpre(test1, test2));
if(test1.length==1){
treefinal.add(test1[0]);
}
curstr.addAll(findpre(test3, test4));
if(test3.length==1){
treefinal.add(test3[0]);
}
break;
}
}return curstr;
}
public static List findback2(String[] str1, String[] str2){
if(str1.length==0){
return new ArrayList();
}
List curstr = new ArrayList();
for(int i = 0; i
if(str2[i].equals(str1[0])){
List curpre1 = new ArrayList();
List curpre2 = new ArrayList();
List curin1 = asList(copyOfRange(str2,0,i));
List curin2 = asList(copyOfRange(str2,i+1,str2.length));
for(int j = 1; j
if(curin1.contains(str1[j])){
curpre1.add(str1[j]);
}else{
curpre2.add(str1[j]);
}
}
String[] test1= curpre1.toArray(new String[curpre1.size()]);
String[] test2= curin1.toArray(new String[curin1.size()]);
curstr.addAll(findback2(test1, test2));
curstr.addAll(findback2(curpre2.toArray(new String[curpre2.size()]),curin2.toArray(new String[curin2.size()])));
curstr.add(str1[0]);
break;
}
}return curstr;
}
}
发表于 2020-05-07 16:25:11
回复(0)
1
//关键是重建一颗二叉树
#include
using namespace std;
struct treeNode{
int val;
treeNode*left;
treeNode*right;
treeNode(int x):val(x),left(nullptr),right(nullptr){}
};
treeNode*reConstruct(vectorlay,vectorvin){
if(vin.size()==0)return nullptr;
int temp=lay[0];
treeNode*head=new treeNode(temp);
int tag=0;
for(int i=0;i
if(vin[i]==temp){
tag=i;
break;
}
}
vector vinleft(vin.begin(),vin.begin()+tag);
vector vinright(vin.begin()+tag+1,vin.end());
vectorlayleft,layright;
for(int i=1;i
for(int j=0;j
if(lay[i]==vin[j]){
layleft.push_back(lay[i]);
break;
}
}
}
for(int i=1;i
for(int j=tag+1;j
if(lay[i]==vin[j]){
layright.push_back(lay[i]);
break;
}
}
}
head->left=reConstruct(layleft,vinleft);
head->right=reConstruct(layright,vinright);
return head;
}
void leafOrder(treeNode*head,vector&leaf){
if(head==nullptr)return ;
if(head->left==nullptr&&head->right==nullptr)
leaf.push_back(head->val);
if(head->left!=nullptr)
leafOrder(head->left,leaf);
if(head->right!=nullptr)
leafOrder(head->right,leaf);
}
void preOrder(treeNode*head,vector&pre){
if(head==nullptr)return ;
pre.push_back(head->val);
preOrder(head->left,pre);
preOrder(head->right,pre);
}
void posOrder(treeNode*head,vector&pos){
if(head==nullptr)return ;
posOrder(head->left,pos);
posOrder(head->right,pos);
pos.push_back(head->val);
}
int main(){
vectorlay,vin,pre,leaf,pos;
int a,b;
while(cin>>a){
lay.push_back(a);
if(cin.get()=='\n')break;
}
while(cin>>b){
vin.push_back(b);
if(cin.get()=='\n')break;
}
treeNode*head=reConstruct(lay,vin);
leafOrder(head,leaf);
preOrder(head,pre);
posOrder(head,pos);
for(int i=0;i
cout<
cout<
for(int i=0;i
cout<
cout<
for(int i=0;i
cout<
cout<
return 0;
}
发表于 2020-02-29 12:11:58
回复(0)
1
数据结构的题答案都很长
核心在于用递归，层次遍历的第一个数一定是根
#include
using namespace std;
const int maxn = 2050;
int arr[maxn];
vector pre, post, leaves;
struct Node{
int val;
Node *left, *right;
Node(int x):val(x) {left = right = NULL;}
};
Node *insert(vector layer, vector m_order) {
if(layer.size() == 0) return NULL;
int idx = 0;
for(idx; idx
Node *cur = new Node(m_order[idx]);
if(m_order.size() == 1) return cur;
vector left_layer;//左子树的层次遍历
for(int i = 1; i
for(int j = 0; j
if(layer[i] == m_order[j]) left_layer.push_back(layer[i]);
cur->left = insert(left_layer, vector(m_order.begin(), m_order.begin()+idx));
vector right_layer;//右子树的层次遍历
for(int i = 1; i
for(int j = idx + 1; j
if(layer[i] == m_order[j]) right_layer.push_back(layer[i]);
cur->right = insert(right_layer, vector(m_order.begin()+idx+1, m_order.end()));
return cur;
}
void pre_order(Node* head) {
if(head) {
if(!head->left && !head->right)
leaves.push_back(head->val);
pre.push_back(head->val);
pre_order(head->left);
pre_order(head->right);
}
}
void post_order(Node *head) {
if(head) {
post_order(head->left);
post_order(head->right);
post.push_back(head->val);
}
}
void print_vec(vector a) {
for(int i = 0; i
cout<
cout<
扫一扫
786
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
