UVA548递归二叉树求路径和和根据中序和后序建立二叉树

由于自己很少写递归，这题刚开始递归写了一半就放弃了，其实这个递归挺简单的，根据中序遍历和后序遍历

，每步都加上根节点的和就可，到达叶子节点的时候判断下改变一下值即可。

另外这题也可以建树做，后面给出建树的代码。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<string>
#include<cctype>
#include<cmath>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<ctime>
#include<algorithm>
#include<sstream>
#define LL long long
using namespace std;
const int maxn=1e4+10;
int inorder[maxn],postorder[maxn];
int minsum,ans;
void work(int n,int *in,int *post,int sum)
{
    if(n<=0)
        return;
    int j;
    for(j=0;j<n;j++)
        if(in[j]==post[n-1])
            break;
 //   cout<<len1<<endl;
    sum+=post[n-1];
    if(j<=0&&n-j-1<=0)
    {
        if(sum==minsum)
            ans=(ans,post[n-1]);
        else if(sum<minsum)
        {
            minsum=sum;
            ans=post[n-1];
        }
    }
    work(j,in,post,sum);
    work(n-j-1,in+j+1,post+j,sum);
}
int main()
{
    string s1;
    string s2;
    while(getline(cin,s1))
    {
        istringstream sin(s1);
        int a;
        int len=0;
        while(sin>>a)
        {
            inorder[len++]=a;
        }
        getline(cin,s2);
        len=0;
        istringstream ssin(s2);
        while(ssin>>a)
        {
            postorder[len++]=a;
        }
        ans=minsum=(int)(1e7+10);
     //   cout<<len<<endl;
        work(len,inorder,postorder,0);
        cout<<ans<<endl;
    }
    return 0;
}

建树：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cctype>
#include<cstdlib>
using namespace std;
struct node
{
    struct node *left;
    struct node *right;
    int v;
};
node *root;
char s[100005];
int v1[100005],v2[100005],top;
int init(char *s,int *v)
{
    int top=0;
    for(int i=0;s[i];i++)
    {
        while(s[i]=='')
        i++;
        v[top]=0;
        while(s[i]&&isdigit(s[i]))
        {
            v[top]=v[top]*10+s[i]-'0';
            i++;
        }
        top++;
        if(!s[i]) break;
    }
    return top;
}
int find(int *v,int n,int c)
{
    for(int i=n-1;i>=0;i--)
    if(v[i]==c)
    return i;
    return 0;
}
node *build(int n,int *v1,int *v2)
{
    if(n<=0)
    return NULL;

    int p=find(v1,n,v2[n-1]);

    node *root=(node *)malloc(sizeof(node));
    root->v=v2[n-1];

    root->left=build(p,v1,v2);
    root->right=build(n-p-1,v1+p+1,v2+p);

    return root;
}
int min_sum,ans;

void dfs(node *root,int sum)
{
    if(root==NULL)
    return ;
    sum+=root->v;
    if(root->left==NULL&&root->right==NULL)
    {
        if(min_sum>sum)
        {
            min_sum=sum;
            ans=root->v;
        }
        else if(min_sum==sum)
        ans=min(ans,root->v);

        return;
    }
    dfs(root->left,sum);
    dfs(root->right,sum);
}
int main()
{
    while(gets(s))
    {
        int v;
        init(s,v1);
        gets(s);
        top=init(s,v2);

        node *root;
        root=build(top,v1,v2);

        ans=min_sum=10000000;
        dfs(root,0);
        printf("%d\n",ans);
    }
    return 0;
}