java 根据二叉树前序 ,中序求后续

在一棵二叉树总,前序遍历结果为:ABDGCEFH,中序遍历结果为:DGBAECHF,求后序遍历结果。

我们知道:

前序遍历方式为:根节点->左子树->右子树

中序遍历方式为:左子树->根节点->右子树

后序遍历方式为:左子树->右子树->根节点

从这里可以看出,前序遍历的第一个值就是根节点,然后再中序遍历中找到这个值,那么这个值的左边部分即为当前二叉树的左子树部分前序遍历结果,这个值的右边部分即为当前二叉树的右子树部分前序遍历结果。因此,通过这个分析,可以恢复这棵二叉树,得到这样的一段伪码:

节点 getRoot(前序,中序)

c=前序第一个字符

pos=c在中序中的位置

len1=中序pos左半部分长度

len2=中序pos右半部分长度

新建节点r,令r的元素等于c

r的左儿子=getRoot(前序位置1开始的len1长度部分,中序pos位置的左半部分)

r的右儿子=getRoot(前序位置len1开始右半部分,中序pos位置的右半部分)

return r

如图1示:

图1

输入前序ABDGCEFH,中序DGBAECHF,可以得出

A为该二叉树的根节点

1: BDG为该二叉树左子树的前序

2: DGB为该二叉树左子树的中序

根据1和2可以构建一棵左子树

3: CEFH为该二叉树右子树的前序

4: ECHF为该二叉树右子树的中序

根据3和4可以构建一个右子树

执行至该步骤的时候就得到了该二叉树的云结构,如图2所示,A为根节点,BDG在它的左子树上,CEFG在它的右子树上。

如此递归即可以构建一棵完整的二叉树

java代码

class DataNode{
    int data;
    DataNode leftChild = null;
    DataNode rightChild = null;
}

public class NodeTree {

    DataNode rootNode;
    DataNode tempNode;
    //int index_root;
    DataNode left_childDataNode;
    DataNode right_childDataNode;

    public DataNode initRootNode(int[] preArray){
        rootNode = new DataNode();
        rootNode.data = preArray[0];
        return rootNode;
    }

    public  void BuildTree(int[] preArray,int[] midArray,DataNode rootNode){
        int index_root = getIndex(midArray, rootNode.data);
        int lengthOfRightTree = preArray.length - index_root -1;

        int[] preArray_left;
        int[] preArray_right;
        int[] midArray_left;
        int[] midArray_right;

        if (index_root>0) {
            left_childDataNode = new DataNode();
            if (index_root==1) {
                left_childDataNode.data = midArray[0];
                rootNode.leftChild = left_childDataNode;
            }else {
                preArray_left = new int[index_root];
                midArray_left = new int[index_root];
                System.arraycopy(preArray, 1, preArray_left, 0, index_root);
                System.arraycopy(midArray, 0, midArray_left, 0, index_root);
                left_childDataNode.data = preArray_left[0];
                rootNode.leftChild = left_childDataNode;
                BuildTree(preArray_left, midArray_left, left_childDataNode);
            }
        }

        if (lengthOfRightTree>0) {
            right_childDataNode = new DataNode();
            if (lengthOfRightTree==1) {
                right_childDataNode.data = midArray[index_root+1];
                rootNode.rightChild = right_childDataNode;
                return;
            }else {
                preArray_right  = new int[lengthOfRightTree];
                midArray_right = new int[lengthOfRightTree];
                System.arraycopy(preArray, index_root+1, preArray_right, 0,lengthOfRightTree);
                System.arraycopy(midArray, index_root+1, midArray_right, 0, lengthOfRightTree);
                right_childDataNode.data = preArray_right[0];
                rootNode.rightChild = right_childDataNode;
                BuildTree(preArray_right, midArray_right,right_childDataNode);
            }
        }
    }

    public int getIndex(int[] array,int temp){
        int index = -1;
        for (int i = 0; i < array.length; i++) {
            if (array[i]==temp) {
                index = i;
                return index;
            }
        }
        return index;
    }
    //后序遍历
    public void postOrderTraverse(DataNode node){
        if (node==null) {
            return;
        }
        postOrderTraverse(node.leftChild);
        postOrderTraverse(node.rightChild);
        System.out.print(node.data);
    }
    //前序遍历
    public void preOrderTraverse(DataNode node){
        if (node==null) {
            return;
        }
        System.out.print(node.data);
        preOrderTraverse(node.leftChild);
        preOrderTraverse(node.rightChild);
    }
    //中序遍历
    public void inOrderTraverse(DataNode node){
        if (node==null) {
            return;
        }
        inOrderTraverse(node.leftChild);
        System.out.print(node.data);
        inOrderTraverse(node.rightChild);
    }

    public static void main(String args[]){
        int[] preArray = {1,2,3};
        int[] midArray = {1,2,3};
        NodeTree tree = new NodeTree();
        DataNode headNode = tree.initRootNode(preArray);
        tree.BuildTree(preArray, midArray, headNode);
        tree.postOrderTraverse(headNode);
    }

}
时间: 2024-10-07 01:04:55

java 根据二叉树前序 ,中序求后续的相关文章

PAT A1086 Tree Traversals Again [二叉树前序中序求后序]

题目描述 链接 用栈的形式给出一棵二叉树的建立的顺序,求这棵二叉树的后序遍历 分析 性质:树的先序等于入栈次序,树的中序遍历等于出栈次序 先序:先访问根再入栈,所以入栈次序就是先序遍历次序 中序:先递归访问左子树,回溯时访问根,回溯时即出栈时,所以出栈次序就是中序遍历 所以问题转换为已知先序中序,求后序 已知先序中序求后序的方法 \(root\) 保存先序中根的位置,\(st\),\(ed\) 为中序子树的起始结束位置 遍历中序,找到中序根的位置\(i\),从而分成左右子树 左子树在先序中根的位

POJ2255-已知二叉树前序中序求后序

水题--也可以不建立二叉树来做 如果pre[pl:pr]对应in[il:ir],那么pre[pl]是这棵树的根,它在in的位置记为root,显然root在[il,ir]内 那么二叉树的左子树是in[il:root-1],也即pre[pl+1:pl+root-il] 二叉树的右子树是in[root+1,ir],也即pre[pl+root-il+1:pr] 按照左子树-右子树-树根的后序遍历方式输出即可 附代码 #include <string> #include <iostream>

hdu 1701 (Binary Tree Traversals)(二叉树前序中序推后序)

Binary Tree Traversals Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Description A binary tree is a finite set of vertices that is either empty or consists of a root r and two disjoint binary trees called

hihocoder(第十周)二叉树(前序中序推后续)递推实现

题目 : 后序遍历 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 在参与过了美食节之后,小Hi和小Ho在别的地方又玩耍了一阵子,在这个过程中,小Ho得到了一个非常有意思的玩具——一棵由小球和木棍连接起来的二叉树! 小Ho对这棵二叉树爱不释手,于是给它的每一个节点都标记了一个标号——一个属于A..Z的大写字母,并且没有任意两个节点的标号是一样的.小Hi也瞅准了这个机会,重新巩固了一下小Ho关于二叉树遍历的基础知识~就这样,日子安稳的过了两天. 这天,小Ho正好在求解

已知前序中序求后序-二叉树

writer:pprp 思路很容易理解,但是实现还是有一点难度,容易错 参考书目:<算法竞赛宝典> 代码如下: //已知前序中序,求后序 #include <iostream> using namespace std; //a是前序,b是中序 void hwg(string a,string b) { int ll,lr; for(unsigned int i = 0; i < b.length(); i++) { if(a[0] == b[i]) //找到根节点 { ll

NOJ 2015年陕西省程序设计竞赛网络预赛(正式赛)(小女警的异世界之战-前序中序求后序)

A - 小女警的异世界之战 Time Limit: 1000 ms        Memory Limit: 65536 KB Submit Description 这一天,小女警花花,泡泡和毛毛来到终极Boss"Him"所在的异世界并准备与其决一死战,却被困在了他的城堡里.她们发现异世界是一个巨大的城堡.城堡由一个个大小不同的房间组成,房间有着以下的规则: 每个房间有且仅有一扇黄门,此外至多有一扇红门和一扇绿门:黄色代表通向更大的房间,绿色和红色代表通向更小的房间.很显然,如果你打开

面试之路(11)-java递归和非递归二叉树前序中序后序遍历

二叉树的遍历 对于二叉树来讲最主要.最基本的运算是遍历. 遍历二叉树 是指以一定的次序访问二叉树中的每个结点.所谓 访问结点 是指对结点进行各种操作的简称.例如,查询结点数据域的内容,或输出它的值,或找出结点位置,或是执行对结点的其他操作.遍历二叉树的过程实质是把二叉树的结点进行线性排列的过程.假设遍历二叉树时访问结点的操作就是输出结点数据域的值,那么遍历的结果得到一个线性序列. 从二叉树的递归定义可知,一棵非空的二叉树由根结点及左.右子树这三个基本部分组成.因此,在任一给定结点上,可以按某种次

二叉树前序中序遍历求后序遍历

已知先序和中序遍历序列,求后序遍历序列. 已知该二叉树的先序遍历序列为:A-B-D-E-G-C-F,中序遍历序列为:D-B-G-E-A-C-F. 接下来我们就可以求出该二叉树的后序遍历序列,具体步骤如下: 第一步:先求root根节点,根据先序遍历规则我们可知root为先序遍历序列的第一个节点,因此该二叉树的root节点为A. 第二步:求root的左子树和右子树,这点我们可以从中序遍历序列中找出,位于root节点A左侧的D-B-G-E为root的左子树,位于A右侧的C-F为右子树. 第三步:求ro

UVA 536 Tree Recovery(由前序中序求后序,经典)

Tree Recovery Time Limit: 3000 MS Little Valentine liked playing with binary trees very much. Her favorite game was constructing randomly looking binary trees with capital letters in the nodes. This is an example of one of her creations: D / / B E /