String 类型的 先序,中序,后序 三者，知二求一！

咱不装B，咱直接发车！！！有啥疑问，下面留言，相互学习，迈向通往老司机的大道上！

工具类:
StringOrderUtil.java

public class StringOrderUtil{ 
    /**
	 * @author	Franer
	 * @param	Forder	先序遍历
	 * @param	FOorder	后序遍历
	 * @return	中序遍历
	 * */
	private static String getInfix_order(String Forder, String FOorder) {
		// 如果已经只有1位了，只可能是末端节点
		if (Forder.equals(FOorder) && Forder.length() == 1) {
			return Forder;
		}
		String topNode = Forder.substring(0, 1);
		//先去掉头部节点
		Forder = Forder.substring(1, Forder.length());
		FOorder = FOorder.substring(0, FOorder.length() - 1);
		StringBuilder sb = new StringBuilder();
		int divider = 0;
		for (int i = 0; i < Forder.length(); i++) {
			if (!sb.toString().contains(Forder.substring(i, i + 1))) {
				sb.append(Forder.substring(i, i + 1));
			}
			if (!sb.toString().contains(FOorder.substring(i, i + 1))) {
				sb.append(FOorder.substring(i, i + 1));
			}
			if (sb.length() == i + 1) {
				divider = i+1;
				break;
			}
		}
		String Left_Order = "";
		if (divider != 0) {
			// 左子节点先序
			String Left_Forder = Forder.substring(0, divider);
			// 左子节点后序
			String Left_FOorder = FOorder.substring(0, divider);
			// 对左子节点排序
			Left_Order = getInfix_order(Left_Forder, Left_FOorder);
		}
		
		String Right_Order = "";
		if (divider != Forder.length()) {
			// 右子节点先序
			String Right_Forder = Forder.substring(divider, Forder.length());
			// 右子节点后序
			String Right_FOorder = FOorder.substring(divider, Forder.length());
			//对右子节点排序
			Right_Order = getInfix_order(Right_Forder, Right_FOorder);
		}
		return String.format("%s%s%s", Left_Order, topNode, Right_Order);
	}
	
	/**
	 * @author	Franer
	 * @param	Iorder	中序序列
	 * @param	FOorder	后序序列
	 * @return	先序遍历
	 * */
	private static String getFirst_order(String Iorder, String FOorder) {
		// 顶部节点
		String topNode = FOorder.substring(FOorder.length() - 1,
				FOorder.length());
		// 顶部节点在中序中的位置
		int topNode_In_Iorder = Iorder.indexOf(topNode);
		String Right_Order = "";
		// 如果顶部节点在中序中的位置不是最后一个,标示有孩子不为空
		if (topNode_In_Iorder != Iorder.length() - 1) {
			// 右子节点们的中序
			String Right_Iorder = Iorder.substring(topNode_In_Iorder + 1);
			// 右子节点们的后序
			String Right_Forder = FOorder.substring(FOorder.length() - 1
					- Right_Iorder.length(), FOorder.length() - 1);
			// 右子节点们进行排序
			Right_Order = getFirst_order(Right_Iorder, Right_Forder);
		}
		String Left_Order = "";
		// 如果顶部节点在中序中的位置不为0，标示左孩子不为空
		if (topNode_In_Iorder != 0) {
			// 左子节点们的中序
			String Left_Iorder = Iorder.substring(0, topNode_In_Iorder);
			// 左子节点们的后序
			String Left_FOorder = FOorder.substring(0, Left_Iorder.length());
			// 左子节点进行排序
			Left_Order = getFirst_order(Left_Iorder, Left_FOorder);
		}
		return String.format("%s%s%s", topNode, Left_Order, Right_Order);
	}
	
	/**
	 * @author	Franer
	 * @param	Forder	先序序列
	 * @param	Iorder	中序序列
	 * @return	后序遍历
	 * */
	private static String getFollow_order(String Forder, String Iorder) {
		// 顶部节点
		String topNode = Forder.substring(0, 1);
		// 顶部节点在中序中的位置
		int topNode_In_Iorder = Iorder.indexOf(topNode);
		String Left_Order = "";
		// 如果顶部节点在中序中的位置不为0，标示左孩子不为空
		if (topNode_In_Iorder != 0) {
			// 左子节点们的中序
			String Left_Iorder = Iorder.substring(0, topNode_In_Iorder);
			// 左子节点们的先序
			String Left_Forder = Forder.substring(1, Left_Iorder.length() + 1);
			// 左子节点进行排序
			Left_Order = getFollow_order(Left_Forder, Left_Iorder);
		}
		String Right_Order = "";
		// 如果中序末不等与先序头.标示右子节点不为空
		if (topNode_In_Iorder != Iorder.length() - 1) {
			// 右子节点们的中序
			String Right_Iorder = Iorder.substring(topNode_In_Iorder + 1,
					Iorder.length());
			// 右子节点们的先序
			String Right_Forder = Forder.substring(Forder.length()
					- Right_Iorder.length(), Forder.length());
			// 右子节点们进行排序
			Right_Order = getFollow_order(Right_Forder, Right_Iorder);
		}
		return String.format("%s%s%s", Left_Order, Right_Order, topNode);
	}
	
}

调用:
模拟数据图：

Main 函数调用过程：

public class VisitTree {
    public static void main(String[] args) {
        System.out.println("~~~~~~~~~~~~~~~~~~~先中序求后~~~~~~~~~~~~~~~~~~~~");
        String First_order = "ABDEGIHCF";/* 先序 */
        String Infix_order = "DBIGEHACF";/* 中序 */
        /* 求出后序 */
        String Follow_order = StringOrderUtil.getFollow_order(First_order, Infix_order);
        System.out.println("先序遍历是:" + First_order);
        System.out.println("中序遍历是:" + Infix_order);
        System.out.println("后续遍历是:" + Follow_order);

        System.out.println("~~~~~~~~~~~~~~~~~~~~中后序求先~~~~~~~~~~~~~~~~~~~");
        String Infix_order1 = "DBIGEHACF";/* 中序 */
        String Follow_order1 = "DIGHEBFCA";/* 后续 */
        /* 求出先序 */
        String First_order1 = StringOrderUtil.getFirst_order(Infix_order1, Follow_order1);
        System.out.println("先序遍历是:" + First_order1);
        System.out.println("中序遍历是:" + Infix_order1);
        System.out.println("后续遍历是:" + Follow_order1);

        System.out.println("~~~~~~~~~~~~~~~~~~~~~先后序求中~~~~~~~~~~~~~~~~~~");
        String First_order2 = "ABDEGIHCF";/* 先序 */
        String Follow_order2 = "DIGHEBFCA";/* 后续 */
        String Infix_order2 = StringOrderUtil.getInfix_order(First_order2, Follow_order2);
        System.out.println("先序遍历是:" + First_order2);
        System.out.println("中序遍历是:" + Infix_order2);
        System.out.println("后续遍历是:" + Follow_order2);

    }
}