多项式系数提取算法 c++

bool isNumber(char s)
{
    if (s >= 48 && s <= 57)
        return true;
    else
        return false;
}

bool isLetter(char s)
{
    if (s >= 97 && s <= 122)
        return true;
    else
        return false;
}

//函数的作用是把如“-45+2*a-a^2-4*a^6+a^8”这样的字符串提取成这样：（-45,2,-1,0,0,0,-4,0,1）,只提取系数，并根据指数安排起位置.
//s为传入的字符串，result为处理后的一组数，返回这组数的个数
//恩,我需要这样的一个函数
int fenxi(string &s,double **result)
{
    //    string s("-45+2*a-a^2-4*a^6+a^8");
    int letter = 0;                                        //字符串中字母的个数
    int operators = 0;                                    //字符串中运算符的个数（+ - * ^）,包括最开头隐藏的+号

    double *num = new double[s.length()];                //存储数字，存储已经判断过正负号的数字
    int dijige_num = 0;                                    //和num配合，定位每一个数字，是合起来的数字，不是单个字符数字

    double *pow = new double[s.length()];                //存储幂指数的数字，只能判断正指数。抱歉，负指数无法判断
    int dijige_pow = 0;                                    //和pow配合，定位每一个指数数字，也是合起来的数字

    double *list = new double[s.length()];                //队列数据结构，用于存储每个数字位，未免溢出，开辟的和字符串长度相等
    int front = (int)(s.length() / 2);                    //指向队列头部，填入数据时减小，开始位置在list正中间
    int tail = (int)(s.length() / 2);                    //指向队列尾部，取出数据时减小，开始位置和front一样

    int *op = new int[s.length()];                        //用来存储正负号运算符，用来确定数字的正负号
    int pin = 0;                                        //指向每一个正负号运算符，用来定位

    for (int i = 0; i < s.length(); i++)                //初始化，全初始为0
    {
        list[i] = 0;
        pow[i] = 0;
        num[i] = 0;
        op[i] = 0;
    }

    if (s.length() == 1 &&isLetter(s[0]))                //处理为“a”的情况
    {
        num[dijige_num++]=1;
        pow[dijige_pow]=1;
        goto end;
    }

    if (s.length() ==2 &&isLetter(s[1]))                //处理为‘-a’的情况
    {
        num[dijige_num++] = -1;
        pow[dijige_pow] =1;
        goto end;
    }

    for (int i=0;i<s.length();i++)        
    {
        if (isLetter(s[i]))
        {
            letter++;
        }
    }
    if (letter == 0)                                    //处理全为数字的情况，正负均可
    {
            num[dijige_num++] =atoi(s.c_str());
            pow[dijige_pow] = 0;
            goto end;
    }

    letter=0;
    if (s[0] == '-')                                    //判断最初的运算符正负号，这是为负号的情况
    {
        op[0] = -1;
        pin++;
        operators++;
    }
    else                                                //以一个字符不是‘-’时，是数字或字母，都判断为正号
    {
        op[0] = 1;
        pin++;
        if (!isLetter(s[0]))                            //不是字母的话，这个operators加一
        {
            operators++;
        }
    }

    for (int i = 0; i < s.length(); i++)
    {
        if (isLetter(s[i]))                                        
        {
            if (letter == 0)
            {
                if (!isLetter(s[s.length()-1]))
                {
                    if (s[i+1] != '^')                        //用来判断单个a的情况，如 1+a+a^2;这是a的下一个字符如果不是'^',就说明这个a的幂指数为1
                    {
                        pow[dijige_pow] = 1;
                        dijige_pow++;
                    }    
                }
                else
                {
                    pow[dijige_pow] = 1;
                }
            }
            letter++;
            if (i != 0)
            {
                if (s[i-1] == '+')                //不是第一个字母时，看字母前的正负号，来设置num中为+1或-1
                {
                    num[dijige_num] = 1;            
                    dijige_num++;
                }
                if (s[i-1] == '-')
                {
                    num[dijige_num] = -1;                
                    dijige_num++;
                }
            }
            if (i == 0)                            //如果第一个为字母的话，那这个字母的系数肯定是+1
            {
                num[dijige_num] = 1;
                dijige_num++;
            }
        }

        if (isNumber(s[i]))
        {
            if (letter ==0 && front == tail &&operators < 2 )            //第一个位为数字时，pow这一位值为0，比如12=12*a^0
            {
                pow[dijige_pow] = 0;
                dijige_pow++;
            }

            front--;
            list[front] = (double)(s[i] - 48);                    //将ascii字符-48就变为数字了
        }

        if (s[i] == '+')
        {
            if (i != 0)
            {
                operators++;
            }
            if (letter == 0)                        //后面多次有这个，主要是把list队列中存储的单个数逐次取出并合成num中或pow中的数
            {                                        
                if (front != tail)                    
                {
                    while (front != tail)
                    {
                        tail--;
                        num[dijige_num] = list[tail] + num[dijige_num] * 10;
                    }
                    num[dijige_num] = num[dijige_num] * op[pin-1];            //存入num中的数还需要判断正负号，就用op存的数判断
                    dijige_num++;
                    tail = (int)(s.length() / 2);
                    front = tail;
                }
            }
            else
            {
                if (front != tail)
                {
                    while (front != tail)
                    {
                        tail--;
                        pow[dijige_pow] = list[tail] + pow[dijige_pow] * 10;                    //存入pow中的数没有判断正负号，这就是为什么不支持负幂指数的原因
                    }
                    dijige_pow++;
                    tail = (int)(s.length() / 2);
                    front = tail;
                }            
            }    
            if (i != 0)
            {
                op[pin] = 1;
                pin++;
            }
        }

        if (s[i] == '-')
        {
            if (i != 0)
            {
                operators++;
            }
            if (letter == 0)
            {
                if (front != tail)
                {
                    while (front != tail)
                    {
                        tail--;
                        num[dijige_num] = list[tail] + num[dijige_num] * 10;
                    }
                    num[dijige_num] = num[dijige_num] * op[pin-1];
                    dijige_num++;
                    tail = (int)(s.length()/2);
                    front = tail;
                }
            }
            else
            {
                if (front != tail)
                {
                    while (front != tail)
                    {
                        tail--;
                        pow[dijige_pow] = list[tail] + pow[dijige_pow] * 10;
                    }
                    dijige_pow++;
                    tail = (int)(s.length() / 2);
                    front = tail;
                }
            }
            if (i != 0)
            {
                op[pin] = -1;
                pin++;
            }
        }

        if (s[i] == '*')
        {
            operators++;
            if (operators == 2 )                //用来处理类似 2*a+..这样的情况
            {
                dijige_pow--;
            }
            if (front != tail)                    //'*'号之前一般是num吧,一般不会是幂指数吧 ,如“1+2*a^2+34*a^5”,"*"好像都是系数
            {
                while (front != tail)
                {
                    tail--;
                    num[dijige_num] = list[tail] + num[dijige_num] * 10;
                }
                num[dijige_num] = op[pin-1] * num[dijige_num];
                dijige_num++;
                tail = (int)(s.length() / 2);
                front = tail;
            }
        }
    }

    
    while (tail != front)                                        //把最后一个幂指数添加入pow中
    {
        tail--;
        pow[dijige_pow] = list[tail] + pow[dijige_pow] * 10;
    }


end:

    dijige_pow++;
    int res_num = pow[dijige_pow-1] + 1;        //最终数组中的数的个数
/*
    for (int i=0;i<dijige_num;i++)
    {
        cout<<num[i]<<"  ";
    }
    cout<<endl;
    for (int i=0;i<dijige_pow;i++)
    {
        cout<<pow[i]<<"  ";
    }
*/

    double *temp = new double[res_num];
    *result = new double[res_num];        //最终要输出的数据

    for (int i = 0; i < res_num; i++)
    {
        temp[i] = 0;
    }

    for (int i = 0; i < dijige_pow; i++)        //以pow中的数来定位，把num中的数添加到result中相应的位置
    {
        int tmp1;
        tmp1 = pow[i];
        temp[tmp1] = num[i];
    }
/*
    cout<<endl;
    for (int i=0;i<res_num;i++)
    {
        cout<<temp[i]<<"  ";
    }
*/
    *result=temp;
    return res_num;
}