用单链表实现一元多项式相加 C++代码

 

#include <iostream>
using namespace std;
 
/*结点的定义*/
typedef struct LNode
{
      float coef;
      int  exp;
      struct LNode *next;
}LNode;
typedef LNode *Polynomial;
 
 
/*多项式的初始化*/
void initDuoX(Polynomial &Px)
{
      Px=new LNode;
      Px->next=NULL;
}
 
 
/*用正序插入法建立多项式*/
void creatDuoX(Polynomial &Px,int n)
{
      initDuoX(Px);
 
      LNode *p,*q;
      p=Px;
 
      for(int i=0;i<n;i++)
      {
             q=new LNode;
 
             cin>>q->coef>>q->exp;
             q->next=NULL;
 
             p->next=q;
             p=q;
 
      }
}
 
 
/*求多项式的长度*/
int lengthDuoX(Polynomial &Px)
{
      LNode *p;
      int count;
 
      p=Px->next;
      count=0;
 
      while(p!=NULL)
      {
             p=p->next;
             count++;
      }
      
      return count;
}
 
/*输出多项式*/
void outputDuoX(Polynomial &Px)
{
      LNode *p;
      p=Px->next;
 
      int i;
      for(i=0;i<lengthDuoX(Px);i++)
      {
             cout<<p->coef<<" "<<p->exp<<" ";
             p=p->next;
      }
      cout<<endl;
}
 
 
/*多项式相加*/
LNode * addDuoX(Polynomial &Pa,Polynomial &Pb)
{
      LNode *p,*q;
      LNode *prep;//prep指向p的前驱。
      LNode *u;
 
      p=Pa->next;
      q=Pb->next;//p、q分别指向多项式的第一项。
 
      prep=Pa;//因为是Pb加到Pa上,所以此处不需要使用q的前驱。
 
      while (p&&q)
      {
             if(p->exp<q->exp)//第一种情况,指针只需后移。
             {
                    prep=p;
                    p=p->next;
             }
             else if(p->exp > q->exp)//第二种情况,将q结点插入到p结点之前。
             {
                    u=q->next;
                    
                    q->next=p;
                    prep->next=q;
                    
                    prep=q;
                    q=u;
             }
             else//第三种情况,系数进行相加。
             {
                    p->coef=p->coef+q->coef;
                    if(p->coef==0)//系数相加等于0
                    {
                           LNode *temp1;
                           LNode *temp2;
                           temp1=p;
                           temp2=q;
                           prep->next=p->next;
                           p=p->next;
                           q=q->next;
                           
                           delete temp1;//这里不能直接释放p结点。
                           delete temp2;
                    }
                    else
                    {
                           LNode *temp2;
                           temp2=q;
 
                           prep=p;
                           p=p->next;
                           q=q->next;
                           delete temp2;
                    }
             }
      }
      if(q)
             prep->next=q;
 
      delete Pb;
      return Pa;
}
 
 
void main()
{
      Polynomial Pa,Pb,Pc;
      creatDuoX(Pa,4);
      creatDuoX(Pb,5);
 
      Pc=addDuoX(Pa,Pb);
      outputDuoX(Pc);
}

 

总体上来说,虽然是两个多项式相加,但两个多项式的地位是不一样的。是Pb加到Pa上,所以对两个多项式的处理也不一样。

虽然是照着算法写这个程序,可是还是费了老大的劲,才把它写出来,而且还出错了!经过调试之后,测试了一组数据,呵呵,正确!为确保万无一失,再测一组,呜呜,错了!所以写了程序,要多测几组数据 ,才能确保万无一失。

写这个程序没有学到多少新的东西,但是让我对单链表有了更深的理解,并且能够更加牢固的掌握它!嘿嘿,自己要加油啊!!!

写程序,写程序,乐在其中!!!

 

  • 15
    点赞
  • 59
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
一元多项式可以表示为: $P(x) = a_nx^n + a_{n-1}x^{n-1} + ... + a_1x + a_0$ 其中,$a_n, a_{n-1}, ..., a_1, a_0$ 为系数,$x$ 为未知数,$n$ 为次数。 我们可以用单链表来存储一元多项式,每个节点存储一个系数和次数。 接下来,分别介绍一下两个多项式的加减乘法运算。 ## 多项式的加法 两个多项式相加,只需要将相同次数的系数相加即可。 具体步骤如下: 1. 分别遍历两个单链表,将相同次数的系数相加。 2. 如果某个链表已经遍历完,将另一个链表剩余的项添加到结果链表中。 3. 如果最高次数的系数为0,则删除该节点。 下面是 C++ 代码实现: ```cpp struct Node { int coef; // 系数 int exp; // 次数 Node* next; }; Node* addPolynomial(Node* p1, Node* p2) { Node* result = new Node(); Node* tail = result; while (p1 && p2) { if (p1->exp == p2->exp) { int sum = p1->coef + p2->coef; if (sum != 0) { Node* node = new Node(); node->coef = sum; node->exp = p1->exp; tail->next = node; tail = node; } p1 = p1->next; p2 = p2->next; } else if (p1->exp > p2->exp) { Node* node = new Node(); node->coef = p1->coef; node->exp = p1->exp; tail->next = node; tail = node; p1 = p1->next; } else { Node* node = new Node(); node->coef = p2->coef; node->exp = p2->exp; tail->next = node; tail = node; p2 = p2->next; } } while (p1) { Node* node = new Node(); node->coef = p1->coef; node->exp = p1->exp; tail->next = node; tail = node; p1 = p1->next; } while (p2) { Node* node = new Node(); node->coef = p2->coef; node->exp = p2->exp; tail->next = node; tail = node; p2 = p2->next; } Node* temp = result; result = result->next; delete temp; return result; } ``` ## 多项式的减法 两个多项式相减,只需要将相同次数的系数相减即可。 具体步骤如下: 1. 分别遍历两个单链表,将相同次数的系数相减。 2. 如果某个链表已经遍历完,将另一个链表剩余的项添加到结果链表中。 3. 如果最高次数的系数为0,则删除该节点。 下面是 C++ 代码实现: ```cpp Node* subPolynomial(Node* p1, Node* p2) { Node* result = new Node(); Node* tail = result; while (p1 && p2) { if (p1->exp == p2->exp) { int diff = p1->coef - p2->coef; if (diff != 0) { Node* node = new Node(); node->coef = diff; node->exp = p1->exp; tail->next = node; tail = node; } p1 = p1->next; p2 = p2->next; } else if (p1->exp > p2->exp) { Node* node = new Node(); node->coef = p1->coef; node->exp = p1->exp; tail->next = node; tail = node; p1 = p1->next; } else { Node* node = new Node(); node->coef = -p2->coef; node->exp = p2->exp; tail->next = node; tail = node; p2 = p2->next; } } while (p1) { Node* node = new Node(); node->coef = p1->coef; node->exp = p1->exp; tail->next = node; tail = node; p1 = p1->next; } while (p2) { Node* node = new Node(); node->coef = -p2->coef; node->exp = p2->exp; tail->next = node; tail = node; p2 = p2->next; } Node* temp = result; result = result->next; delete temp; return result; } ``` ## 多项式的乘法 两个多项式相乘,需要将每一项都相乘,最后将所有结果相加。 具体步骤如下: 1. 遍历第一个链表,取出每一项。 2. 遍历第二个链表,取出每一项。 3. 将两个节点的系数和次数相乘,得到新的节点。 4. 将新的节点插入结果链表中。 5. 重复以上步骤,直到第一个链表遍历完。 下面是 C++ 代码实现: ```cpp Node* mulPolynomial(Node* p1, Node* p2) { if (!p1 || !p2) { return nullptr; } Node* result = new Node(); while (p1) { Node* p = p2; Node* tail = result; while (p) { int coef = p1->coef * p->coef; int exp = p1->exp + p->exp; Node* node = new Node(); node->coef = coef; node->exp = exp; while (tail->next && tail->next->exp > exp) { tail = tail->next; } if (tail->next && tail->next->exp == exp) { tail->next->coef += coef; } else { node->next = tail->next; tail->next = node; } p = p->next; } p1 = p1->next; } Node* temp = result; result = result->next; delete temp; return result; } ``` 以上就是单链表存储一元多项式,以及两个多项式的加减乘法运算的实现
评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值