多项式的简单运算（栈和队列的应用）

思路：

   首先要考虑存储多项式，只需存它每一项的系数和指数，用队列来存储比较方便，所以需要调用之前的链表队
   列，将每一项的指数和系数当做一个数据存入队列。然后简单的加减乘除运算可以套用计算器（栈的应用），
   只需将Stack_entry类型换为多项式即可。

**要求：**运算的多项式必须按未知数指数从大到小排列。

**多项式加法：**对比两个多项式的指数，指数相同的系数相加。

**多项式减法：**对比两个多项式的指数，指数相同的系数相减。

**多项式乘法：**将一个多项式拆开，让其每一项都与另一个多项式相乘，最后所有结果相加。

多项式除法：
需要递归，将被除数首项和除数首项取出相除，结果记为一部分商，余数继续取出首 项和除数首项相除，将结果与前面求出的部分商相加，以此循环，直到余数小于除数。

说明：
chainqueue.cpp可参考之前的博客：用链表存储队列。
stack.cpp可参考之前的博客：用c++程序实现栈。
代码：
term.h

struct Term {  //定义结构体存储多项式的一项
   int degree;  //指数
   double coefficient;  //系数
   Term (int exponent = 0, double scalar = 0); //构造函数
};

Term::Term(int exponent, double scalar)  //构造函数
{
   degree = exponent;
   coefficient = scalar;
}

polynomial.cpp

#include "term.h"
typedef Term Nodequeue_entry;
typedef Nodequeue_entry Queue_entry;
#include "chainqueue.cpp"

class Polynomial: private Extended_queue {  //调用扩展队列
public:
   void read(); //读取
   void print() const;  //打印
   void equals_sum(Polynomial p, Polynomial q);  //加法
   void equals_difference(Polynomial p, Polynomial q);  //减法
   void equals_product(Polynomial p, Polynomial q);  //乘法
   Error_code equals_quotient(Polynomial p, Polynomial q);  //除法
   int degree() const;  //读取首项的指数
private:
   void mult_term(Polynomial p, Term t); //求多项式与一项的乘积
};

void Polynomial::mult_term(Polynomial p, Term t)  //求多项式与一项的乘积
{
    clear(); //清空链表
    while(!p.empty()) //遍历p
    {
        Term pterm;
        p.serve_and_retrieve(pterm); //读出首项元素并删除
        Term answer_term(pterm.degree + t.degree,t.coefficient * pterm.coefficient); //计算，指数相加，系数相乘
        append(answer_term);  //将每一项的结果存起来
    }
}

void Polynomial::print() const //打印
{
   Nodequeue *print_node = front;
   bool first_term = true;

   while (print_node != NULL) {  //检测是否有数据
      Term &print_term = print_node->entry; //定义一项并将头节点的数据赋给它
      if (first_term) {
         first_term = false;
         if (print_term.coefficient < 0) cout << "- ";
      }
      else if (print_term.coefficient < 0) cout << " - ";
      else cout << " + ";  //打印各项之间的符号
      double r = (print_term.coefficient >= 0)
                 ? print_term.coefficient : -(print_term.coefficient);
      if (r != 1) cout << r; //打印系数
      if (print_term.degree > 1) cout << " X^" << print_term.degree;
      if (print_term.degree == 1) cout << " X";//打印指数部分
      if (r == 1 && print_term.degree == 0) cout << " 1";
      print_node = print_node->next; //遍历
   }
   if (first_term)
      cout << "0";
   cout << endl;
}

void Polynomial::read() //读取
{
   clear(); //清空链表
   double coefficient;  //系数
   int last_exponent, exponent;
   bool first_term = true;

   cout << "Enter the coefficients and exponents for the polynomial, "
        << "one pair per line.  Exponents must be in descending order." << endl
        << "Enter a coefficient of 0 or an exponent of 0 to terminate." << endl; //提示输入规则

   do {
      cout << "coefficient? " << flush;
      cin  >> coefficient;  //获取系数
      if (coefficient != 0.0)
      {
         cout << "exponent? " << flush;
         cin  >> exponent;  //获取指数
         if ((!first_term && exponent >= last_exponent) || exponent < 0) {
            exponent = 0;

            cout << "Bad exponent: Polynomial terminates without its last term."
                 << endl; //如果输入指数比上次的指数大，则提示错误
         }
         else {
            Term new_term(exponent, coefficient);
            append(new_term); //存入链表
            first_term = false;
         }
         last_exponent = exponent;
      }
   } while (coefficient != 0.0 && exponent != 0);
}

void Polynomial::equals_sum(Polynomial p, Polynomial q)  //加法
{
    clear();  //清空链表
    while (!p.empty() || !q.empty())
    {  //若两个链表同时为空则不用执行操作
        Term p_term, q_term;  //定义两项分别用来存储两个多项式的和
        if (p.degree() > q.degree())
        {
            p.serve_and_retrieve(p_term);
            append(p_term);
        }  //如果p的首项指数大于q的首项指数则读出并删除p的首项，将结果存入p_term中
        else if (q.degree() > p.degree())
        {
            q.serve_and_retrieve(q_term);
            append(q_term);
        }  //如果q的首项指数大于p的首项指数则读出并删除q的首项，将结果存入q_term中
        else {  //如果两个多项式首项指数相等，则执行下面操作
            p.serve_and_retrieve(p_term);  //读取并删除p的首项
            q.serve_and_retrieve(q_term);  //读取并删除q的首项
            if (p_term.coefficient + q_term.coefficient != 0)
            {  //判断两个多项式首项是否可抵消
                Term answer_term(p_term.degree,p_term.coefficient + q_term.coefficient); //将两个首项系数相加，指数不变
                append(answer_term); //将结果存入链表中
            }
        }
   }
}

void Polynomial::equals_difference(Polynomial p, Polynomial q)  //减法
{
    clear();  //清空链表
    Term p_term, q_term;  //定义两项分别用来存储两个多项式运算的值
    while (!p.empty() || !q.empty())
    {  //若两个链表同时为空则不用执行操作

        if (p.degree() > q.degree())
        {
            p.serve_and_retrieve(p_term);
            append(p_term);
        }  //如果p的首项指数大于q的首项指数则读出并删除p的首项，将结果存入p_term中
        else if (q.degree() > p.degree())
        {
            q.serve_and_retrieve(q_term);
            q_term.coefficient = -q_term.coefficient;
            append(q_term);
        }  //如果q的首项指数大于p的首项指数则读出并删除q的首项，将q指数的相反数存入q_term中
        else {  //如果两个多项式首项指数相等，则执行下面操作
            p.serve_and_retrieve(p_term);  //读取并删除p的首项
            q.serve_and_retrieve(q_term);  //读取并删除q的首项
            if (p_term.coefficient - q_term.coefficient != 0)
            {  //判断两个多项式首项是否可抵消
                Term answer_term(p_term.degree,p_term.coefficient - q_term.coefficient); //将两个首项系数相减，指数不变
                append(answer_term); //将结果存入链表中
            }
        }
   }
}

void Polynomial::equals_product(Polynomial p, Polynomial q)  //乘法
{
    clear();  //清空链表
    Term p_term, term;  //p_term用来存储p的每一项，term用来存最终的结果
    Polynomial partial_prod,old_sum,new_sum;  //partial_prod用来存当前项与q的乘积
    while(p.serve_and_retrieve(p_term) == success)  //遍历p
    {
        partial_prod.mult_term(q,p_term); //将p的当前项与q相乘
        new_sum.equals_sum(old_sum,partial_prod);  //新的和等于上次的多项式加这次的多项式
        old_sum = new_sum;  //将新的和赋给上次多项式
    }
    while(new_sum.serve_and_retrieve(term) == success) append(term); //遍历完后，将结果存入链表
}

Error_code Polynomial::equals_quotient(Polynomial p, Polynomial q)  //除法
{
    clear(); //清空链表
    if(q.empty()) return fail; //若除数为0则算式不成立
    if(p.degree() < q.degree()) return success; //如果被除数的首项次幂大于除数的首项次幂则不用计算
    Term p_term,q_term,term;  //p_term表示p的当前项，q_term表示q的当前项
    Polynomial partial_prod,remainder,tail; //partial_prod表示当前结果，remainder
    p.serve_and_retrieve(p_term); //读取p首项并删除
    q.retrieve(q_term); //读取q的首项
    Term lead_term(p_term.degree - q_term.degree,p_term.coefficient / q_term.coefficient); //首项相除
    append(lead_term);  //首项相除结果保存
    partial_prod.mult_term(q,lead_term); //将上次得到的商与除数相乘
    partial_prod.serve_and_retrieve(term); //取出首项
    remainder.equals_difference(p,partial_prod); //相减得余数
    tail.equals_quotient(remainder,q); //递归
    while(tail.serve_and_retrieve(term) == success) append(term); //将最终结果存入链表
    return success;
}

int Polynomial::degree() const  //读取首项的指数
{
   if (empty()) return -1;  //如果是空表则返回-1
   Term lead;
   retrieve(lead); //读取首项数据
   return lead.degree;  //返回首项的指数
}

main.cpp

#include "polynomial.cpp"
typedef Polynomial Stack_entry;
#include "stack.cpp"

void introduction() //说明程序作用
{
    cout << "Reverse Polish Calculator Program." << "\n----------------------------------" << endl << endl;
}

void instructions() //说明输入规则
{
    cout << "User commands are entered to read in and operate on integers." << endl;
    cout << "The valid commands are as follows:" << endl << "[Q]uit." << endl;
    cout << "[?] to enter an integer onto a stack." << endl << "[=] to print the top integer in the stack." << endl;
    cout << "[+] [-] [*] [/] are arithmetic operations." << endl << "These operations apply to the top pair of stacked integers." << endl;
}

char get_command() //检测输入的字符是否有效
{
   char command;
   bool waiting = true;
   cout << "Select command and press <Enter>:";

   while (waiting) {
      cin >> command;
      command = tolower(command);
      if (command == '?' || command == '=' || command == '+' ||
          command == '-' || command == '*' || command == '/' ||
          command == 'q' ) waiting = false;  //当输入合法时给waiting赋false,跳出循环，执行操作


      else {
         cout << "Please enter a valid command:"   << endl
              << "[?]push to stack   [=]print top" << endl
              << "[+] [-] [*] [/]   are arithmetic operations" << endl
              << "[Q]uit." << endl;  //当输入不合法时，提示重新输入
      }
   }
   return command;
}

bool do_command(char command, Stack &stored_polynomials)
{
   Polynomial p, q, r;
   switch (command) {
   case '?':
      p.read();
      if (stored_polynomials.push(p) == overflow)
         cout << "Warning: Stack full, lost polynomial" << endl;
      break;

   case '=':
      if (stored_polynomials.empty())
         cout << "Stack empty" << endl;
      else {
         stored_polynomials.top(p);
         p.print();
      }
      break;

   case '+':
      if (stored_polynomials.empty())
         cout << "Stack empty" << endl;
      else {
         stored_polynomials.top(p);
         stored_polynomials.pop();
         if (stored_polynomials.empty()) {
            cout << "Stack has just one polynomial" << endl;
            stored_polynomials.push(p);
         }

         else {
            stored_polynomials.top(q);
            stored_polynomials.pop();
            r.equals_sum(q, p);
            if (stored_polynomials.push(r) == overflow)
               cout << "Warning: Stack full, lost polynomial" << endl;
         }
      }
      break;
    case 'q':
      cout << "Calculation finished." << endl;
      return false;
   }
   return true;
}

int main()
{
   Stack stored_polynomials;
   void introduction();
   void instructions();
   while (do_command(get_command(), stored_polynomials));
}