Java已知二叉樹的前序中序求後序序列

已知前序與中序的字符序列，輸出後序序列。

後序序列爲：左子樹，右子樹，根

第一種 利用一個索引，從最大索引值寫入，依此遞減寫入右子樹和左子樹，循環利用遞歸實現。不使用String類的api

package whut.tree;
//已知二叉樹前序和中序，求後序
public class BeforeMiddleTree {
                                           
    // i:表示要插入後序序列的位置對於生成的後序序列，應該從最後位置開始寫，
    //從索引最大值遞減依此先寫入根，而後寫入右子樹，最後寫左子樹
    public static int i = 0;
    public void getLast(char[] pre, char[] mid, char[] last)
    {
        // 若是序列的長度小於等於1，將該序列中的元素插入last序列，而後返回
        if (pre.length <= 1) {
            last[i] = pre[0];
            i--;
            return;
        }
        //若是序列長度大於1，則將二叉樹的根插入last序列，而後將序列分紅兩個，分別進行遞歸
        else {
            //添加元素
            last[i] = pre[0];
            i--;
            int j = 0;
            // 在mid中找到根元素，今後處將mid分紅兩部分
            for (; j < mid.length && pre[0] != mid[j]; j++);
            //循環結束後j爲根元素在mid中的索引位置
            //兩部分以mid分開
            char[] newmid1 = new char[j];//j-1
            char[] newmid2 = new char[mid.length - j - 1];
            char[] newpre1 = new char[j];
            char[] newpre2 = new char[mid.length - j - 1];
            // 求右子樹的後序序列
            //必需要保證j < mid.length - 1，當相等的時候，表示沒有右子樹
            if (j < mid.length - 1)
            {
                //初始化右子樹
                for (int n = 0; n < mid.length - j - 1; n++) {
                    newmid2[n] = mid[n + j + 1];
                    newpre2[n] = pre[n + j + 1];
                }
                getLast(newpre2, newmid2, last);
            }
            // 求左子樹的後序序列
            //必需要保證j>0，當相等的時候，表示沒有左子樹
            if (j > 0) {
                for (int m = 0; m < j; m++) {
                    newmid1[m] = mid[m];
                    newpre1[m] = pre[m + 1];
                }
                getLast(newpre1, newmid1, last);
            }
        }
    }
    public static void main(String[] args) {
        BeforeMiddleTree st = new BeforeMiddleTree();
        char[] pre = {'A','B','C','D','E','F','G'};
        char[] mid = {'C','D','B','E','A','G','F'};
        char[] last = new char[pre.length];
        i = mid.length-1;
        st.getLast(pre, mid,last);
        for(int j=0;j<last.length;j++)
            System.out.print(last[j]);
    }
}

第二種，利用String的api，正向的進行遍歷，先寫左子樹，後寫右子樹，最後寫根，循環利用遞歸實現。

package whut.tree;
//利用java api來進行遍歷
//已知二叉樹前序和中序，求後序
public class BeforeMiddleTree2 {
    //全局變量存放後序序列
    //先寫左子樹，後寫右子樹，最後寫根
    public static String res = "";
    //兩個字符串是否包含了相同的字符
    public static boolean StringEquals(String a1, String a2) {
        boolean state = true;
        if (a1.length() != a2.length()) {
            state = false;
        }
        if (a1.length() == a2.length())
        {
          for (int i = 0; i < a1.length(); i++)
            {
                if (a2.indexOf(a1.charAt(i))== -1)
                state = false;
            }
        }
        return state;
    }
    //進行遍歷輸出
    public static void cal_tree(String sa, String sb) {
        boolean state = StringEquals(sa, sb);
        if (state == false)
            return;
        //當是空字符串的時候
        if (sb.length() == 0)
            return;
        //當sa==sb==1的時候，則就添加
        if (sa.length() == 1) {
            res += sa;
            return;
        }
        //獲取先序序列的第一個字符，做爲根節點來劃分中序序列
        char root = sa.charAt(0);
        //獲取根字符在中序序列中的位置
        int mid = sb.indexOf(root);
        //拆分中序序列
        //中序序列的左子樹
        String c = sb.substring(0, mid);
        //中序序列的右子樹
        String d = sb.substring(mid + 1);
        //下面就是先左子樹，後右子樹，最後根節點。即後序順序
        //先序左子樹，中序左子樹
        cal_tree(sa.substring(1, c.length() + 1), c);
        //先序右子樹，中序右子樹
        cal_tree(sa.substring(1 + c.length()), d);
        //寫入根
        res += String.valueOf(root);
        return;
    }
    public static void main(String[] agrs) {
        //cal_tree("DBACEGF","ABCDEFG");
        //cal_tree("ABCD","BDAC");
        String s1 = "ABCDEFG";
        String s2 = "CDBEAGF";
        cal_tree(s1, s2);
        if (res.length() != s1.length())
            System.out.println("wrong tree list!");
        else {
            System.out.println(res);
        }
    }
}