已知二叉树的前序/后序遍历和中序遍历，求后序/前序遍历

前序遍历：

1、访问根节点

2、前序遍历左子树

3、前序遍历右子树

中序遍历：
1、中序遍历左子树

2、访问根节点

3、中序遍历右子树

后序遍历：
1、后序遍历左子树

2、后序遍历右子树

3、访问根节点

一、假设前序遍历为adbgcefh 中序遍历为 dgbaechf

首先访问根节点，a为根节点，找到中序遍历中的a 

然后中序遍历分为dgb a echf

dgb是左子树，echf是右子树

dbg是左子树，cefh是右子树

变成递归

#include <iostream>
#include <string>
using namespace std;

int find(const string &str, char c)
{
    for (int i = 0; i < str.size(); ++ i)
        if (c == str[i])
            return i;
    return -1;
}

bool PreMid(const string &pre, const string &mid)
{
    if (pre.size() == 0)
        return false;
    if (pre.size() == 1)
    {
        cout << pre;
        return true;
    }
   
    //根节点是第一个元素
    int k = find(mid, pre[0]);
    
    string pretmp = pre.substr(1, k);
    string midtmp = mid.substr(0, k);
    PreMid(pretmp, midtmp);
    
    pretmp = pre.substr(k + 1, pre.size() - k - 1);
    midtmp = mid.substr(k + 1, mid.size() - k - 1);
    PreMid(pretmp, midtmp);
    
    //变成后序遍历要最后输出节点的值
    cout << pre[0];
}

int main()
{
    string pre, mid;
    while (cin >> pre >> mid)
    {
        PreMid(pre, mid);
        cout << endl;
    }
}

同理，已知后序遍历和中序遍历的程序：

bool BackMid(const string &back, const string &mid)
{
    if (back.size() == 0)
        return false;
    
    if (back.size() == 1)
    {
        cout << back;
        return true;
    }
    
    //根节点是最后一个元素
    int k = find(mid, back[back.size() - 1]);
    
    //变成前序遍历要先输出节点的值
    cout << back[back.size() - 1];
    
    string backTmp = back.substr(0, k);
    string midTmp = mid.substr(0, k);
    BackMid(backTmp, midTmp);
    
    backTmp = back.substr(k, back.size() - k - 1);
    midTmp = mid.substr(k + 1, mid.size() - k - 1);
    BackMid(backTmp, midTmp);
}