大整数的加乘多项式运算

水平有限，代码粗糙。。。。。。。。。

将表达式转化成后缀表达形式，然后利用栈计算。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <stack>
using namespace std;
char str[10][100010];
char a[50];
char ts[50];


const int N=100010;
stack<char > Stack;
stack<char *> SS;
void c_to_d(char str[N], char d[N], int &start)
{//把str的各位转变成对应整数，右对齐存入d, start为最高位下标
int len; //strlen(str)=5 N=10 start =10-5=5
int i,j;
for(i=0;i<N;i++)
d[i]=0;
len=strlen(str);
start=N-len;
for(i=0,j=start;i<len;i++,j++)
d[j]=str[i]-'0';
}


void d_to_c(char d[N], char str[N], int start)
{
//把d中数字d[start...N-1]转变为字符左对齐存入str
int i,j;
int len=N-start;
for(i=0,j=start; i<len; i++,j++)
str[i]=d[j]+'0';
str[len]='\0';
}


//加法 addition
void add(char str_a[N], char str_b[N], char str_c[N])
{
char a[N], b[N],c[N]; //以右对齐的方式存储各位数
int i;
int start_a,start_b,start_c;//分别存储a,b,c中最高位的下标
int carry;//进位


//把str_a,str_b的各位转变成对应整数，右对齐存入a,b
c_to_d(str_a, a, start_a);
c_to_d(str_b, b, start_b);


//从低位到高位，对应位相加
i=N-1;
carry=0;
start_c=min(start_a,start_b);
while(i>=start_c)
{
c[i]=a[i]+b[i]+carry;
carry=c[i]/10;
c[i]=c[i]%10;
i--;
}
//如果有进位
if(carry>0)
{
start_c--;
c[start_c]=carry;
}


//把c转化为字符串str_c
d_to_c(c, str_c, start_c);
}
int compare(char str1[N], char str2[N])  //str1,str2内存的是要进行比较的大整数
{ //如果前者大于后者，返回正数，若相等返回0，否则返回负数
int len1,len2;
len1=strlen(str1);
len2=strlen(str2);
if(len1<len2)
return -1;
else if(len1>len2)return 1;
else
return strcmp(str1,str2);
}


//乘法multiplication
void mul(char str_a[N], char str_b[N], char str_c[N])
{
int len1, len2,i,j,k,carry;
char a[N], b[N], c[N], d[N];
int start_a, start_b, start_c, start_d;


len1=strlen(str_a);
len2=strlen(str_b);


//把str_a,str_b的各位转变成对应整数，右对齐存入a,b
c_to_d(str_a, a, start_a);
c_to_d(str_b, b, start_b);
memset(c, 0, sizeof(c));


//用b[j](j=N-1,N-2....,) 乘a，存入d，再把d累加到c中，注意错位问题，d的最低位下标不是N-1，而是j




for(j=N-1;j>=start_b;j--)
{
memset(d, 0, sizeof(d));
carry=0;
for(i=N-1,k=j;i>=start_a;i--,k--) //注意d的最低位下标从j开始，而不是从N-1开始
{
d[k]=a[i]*b[j]+carry;
carry=d[k]/10;
d[k]=d[k]%10;
}
//如果有进位
if(carry>0)
{
d[k]=carry;
k--;
}
start_d=k+1;


//把d累加到c中
carry=0;
for(i=N-1;i>=start_d;i--)
{
c[i]=c[i]+d[i]+carry;
carry=c[i]/10;
c[i]=c[i]%10;
}
//如果有进位
if(carry>0)
{
c[i]=carry;
i--;
}
}


start_c=i+1;


//把c转化为字符串str_c
d_to_c(c, str_c, start_c);
}


int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
        scanf("%s",str[i]);
    scanf("%s",a);
    memset(ts,0,sizeof(ts));
    int k=0;
    for(int i=0;a[i]!='\0';i++)
    {
        if(a[i]>='a'&&a[i]<='z')
        {
            ts[k++]=a[i];
        }
        else if(a[i]=='+')
        {
            if(Stack.empty())
            {
                Stack.push('+');
            }
            else
            {
                while(!Stack.empty())
                {char x=Stack.top();
                if(x=='*'||x=='+')
                {
                    ts[k++]=x;
                    Stack.pop();
                }
                else if(x=='(')
                {
                    break;
                }
                }
                Stack.push('+');
            }
        }
        else if(a[i]=='*')
        {
            if(Stack.empty())
            {
                Stack.push(a[i]);
            }
            else
            {
                while(!Stack.empty())
                {char x=Stack.top();
                if(x=='*')
                {
                    ts[k++]=x;
                    Stack.pop();
                }
                else if(x=='+')
                {
                    break;
                }
                else if(x=='(')
                {
                    break;
                }
                }
                Stack.push(a[i]);
            }
        }
        else if(a[i]=='(')
        {
            Stack.push(a[i]);
        }
        else if(a[i]==')')
        {
            while(!Stack.empty())
            {
                char x=Stack.top();
                if(x!='(')
                {
                    ts[k++]=x;
                    Stack.pop();
                }
                else
                {
                    Stack.pop();
                    break;
                }
            }
        }
    }


    while(!Stack.empty())
    {
        ts[k++]=Stack.top();
        Stack.pop();
    }
    for(int i=0;ts[i]!='\0';i++)
    {
        if(ts[i]>='a'&&ts[i]<='z')
        {
            SS.push(str[ts[i]-'a']);
        }
        else
        {
            if(ts[i]=='+')
            {
                char *s3=new char[N];
                char *s1=SS.top();
                SS.pop();
                char *s2=SS.top();
                SS.pop();
                add(s1,s2,s3);
                SS.push(s3);
            }
            else if(ts[i]=='*')
            {
                char *s3=new char[N];
                char *s1=SS.top();
                SS.pop();
                char *s2=SS.top();
                SS.pop();
                mul(s1,s2,s3);
                SS.push(s3);
            }
        }




    }
    char *t=SS.top();
    puts(t);
    SS.pop();
}