24点游戏（1）

一、题目

读入表达式树的先序遍历字符串,
这里的表达式树是来自24点游戏的真实场景，也就是对应四个数字（值在1到13之间）组成的表达式，问该表达式树能不能得到24？

二、分析
先序遍历创建二叉树。然后递归求其值。
栈来处理左子树与右子树运算，不过这里要注意许多细节，像除数为0，还有这里是浮点型。
同样是用栈计算值，但是这里有许多细节，像除数为0，还有这里是浮点型。
之前就是没注意浮点型，结果错了很多次。
三、算法实现
（主要代码）

typedef struct tree
{
    
    
    char data[4];
    struct tree*ld,*rd;
}*Tree;

 char s[100][4];
int n,k,x;
double a[20];
void inOrder(Tree T)//遍历得括号表达式
{
    
    
    if(T==NULL)
        return;
    int h;
    if(T->ld==NULL && T->rd==NULL)//1-13
    {
    
    
        if(T->data[0]=='A')
            h=1;
        else if('2'<=T->data[0]&&T->data[0]<='9')
            h=(T->data[0])-'0';
        else if(T->data[0]=='1'&&T->data[1]=='0')
            h=10;
        else if(T->data[0]=='J')
            h=11;
        else if(T->data[0]=='Q')
            h=12;
        else if(T->data[0]=='K')
            h=13;
        printf("%d",h);
    }
    else
    {
    
    
        printf("(");
        if(T->ld)
            inOrder(T->ld);
        printf("%s",T->data);
        if(T->rd)
            inOrder(T->rd);
        printf(")");
    }
}
 
void sum(Tree T)
{
    
    
    if(T)
    {
    
    
        double f,d,y=0;
        int h,flag=1;
        sum(T->ld);
        sum(T->rd);
        if(T->data[0]!='+'&&T->data[0]!='-'&&T->data[0]!='*'&&T->data[0]!='/')
        {
    
    
            if(T->data[0]=='A')
                h=1;
            else if('2'<=T->data[0]&&T->data[0]<='9')
                h=(T->data[0])-'0';
            else if(T->data[0]=='1'&&T->data[1]=='0')
                h=10;
            else if(T->data[0]=='J')
                h=11;
            else if(T->data[0]=='Q')
                h=12;
            else if(T->data[0]=='K')
                h=13;
            a[++x]=h;
        }
        else
        {
    
    
            d=a[x--];
            f=a[x--];
            switch(T->data[0])
            {
    
    
            case '+':
                y=f+d;
                break;
            case '-':
                y=f-d;
                break;
            case '*':
                y=f*d*1.0;
                break;
            case '/':
                if(d-0>=0.000001)
                {
    
    
                    y=f*1.0/d;
                    break;
                }
                else
                {
    
    
                    flag=0;
                    break;
                }
            }
            if(flag)
                a[++x]=y;
        }
    }
}

四、算法分析
算法分析：递归输出与计算都为：O（logn).故时间复杂度为O（logn)
空间复杂度：递归栈为O（logn），故空间复杂度为O（logn）。