数据结构 - 链表 - 一元多项式
采用链表形式实现一元多项式数据结构，对该结构最重要的一个操作是一元多项式相乘。
一元多项式相乘
要求采用链表形式，求两个一元多项式的乘积：\(h_3 = h_1 * h_2\)。函数原型为：
void multiplication( NODE * h1, NODE * h2, NODE * h3 )。
输入格式
输入数据为两行，分别表示两个一元多项式。每个一元多项式以指数递增的顺序输入多项式各项的系数（整数）、指数（整数）。
例如：\(1+2x+x^2\) 表示为：<1,0>,<2,1>,<1,2>,
输出格式
以指数递增的顺序输出乘积： <系数,指数>,<系数,指数>,<系数,指数>,
零多项式的输出格式为：<0,0>,
预置代码
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{ int coef, exp;
struct node *next;
} NODE;
void multiplication( NODE *, NODE * , NODE * );
void input( NODE * );
void output( NODE * );
void input( NODE * head )
{ int flag, sign, sum, x;
char c;
NODE * p = head;
while ( (c=getchar()) !='\n' )
{
if ( c == '<' )
{ sum = 0;
sign = 1;
flag = 1;
}
else if ( c =='-' )
sign = -1;
else if( c >='0'&& c <='9' )
{ sum = sum*10 + c - '0';
}
else if ( c == ',' )
{ if ( flag == 1 )
{ x = sign * sum;
sum = 0;
flag = 2;
sign = 1;
}
}
else if ( c == '>' )
{ p->next = ( NODE * ) malloc( sizeof(NODE) );
p->next->coef = x;
p->next->exp = sign * sum;
p = p->next;
p->next = NULL;
flag = 0;
}
}
}
void output( NODE * head )
{
while ( head->next != NULL )
{ head = head->next;
printf("<%d,%d>,", head->coef, head->exp );
}
printf("\n");
}
int main()
{ NODE * head1, * head2, * head3;
head1 = ( NODE * ) malloc( sizeof(NODE) );
input( head1 );
head2 = ( NODE * ) malloc( sizeof(NODE) );
input( head2 );
head3 = ( NODE * ) malloc( sizeof(NODE) );
head3->next = NULL;
multiplication( head1, head2, head3 );
output( head3 );
return 0;
}
/* PRESET CODE END - NEVER TOUCH CODE ABOVE */
输入输出样例
样例 1
输入
<1,0>,<2,1>,<1,2>,
<1,0>,<1,1>,
输出
<1,0>,<3,1>,<3,2>,<1,3>,
样例 2
输入
<-1,0>,<1,1>,
<1,0>,<1,1>,
输出
<-1,0>,<1,2>,
样例 \(3\)
输入
<5,0>,<10,1>,
<2,0>,<3,1>,<4,2>,<5,3>,
输出
<10,0>,<35,1>,<50,2>,<65,3>,<50,4>,
题解
一元多项式相乘就直接使用两层 for 嵌套对第一个多项式的指针和第二个多项式的指针进行遍历相乘即可（实际实现中使用 while）。设第一个多项式有 \(m\) 项，第二个多项式有 \(n\) 项，显然共有 \(m * n\) 轮多项式相乘，把每一次相乘结果加到第三个多项式中去，即得到答案。
由于一元多项式在输入输出规定了指数递增，因此对第三个多项式不用再进行一次指针遍历，第三个 while 循环并没有对第三个多项式从头到尾在遍历一次。实际上，它是从第三个多项式当前指针 tmp 开始，根据当前创建结点（此轮多项式相乘的结果）的指数大小（一定大于等于 tmp 指向结点的指数 ），向后移动到合适的位置，把当前创建结点“加到”tmp结点上或“加到”tmp结点后面。
在代码中要充分讨论到边界情况。同时应该要注意到隐藏测试用例中有两个是关于零多项式的。
代码如下：
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
int coef, exp;
struct node* next;
}node;
void multiplication(node* n1, node* n2, node* n3);
void input(node* head);
void output(node* head);
/*
* 有限自动机解析字符串（非工程不严谨的解析）
*/
void input(node* head)
{
int flag, sign, sum, x;
char c;
node* p = head;
while ((c = getchar()) != '\n') {
if (c == '<')
{
sum = 0;
sign = 1;
flag = 1;
}
else if (c == '-')
{
sign = -1;
}
else if (c >= '0' && c <= '9')
{
sum = sum * 10 + c - '0';
}
else if (c == ',')
{
if (flag == 1) {
x = sign * sum;
// 重新设置
sum = 0;
sign = 1;
flag = 2;
}
}
else if (c >= '>')
{
if (flag == 2) {
p->next = (node*)malloc(sizeof(node));
p->next->coef = x;
p->next->exp = sign * sum;
p = p->next;
p->next = NULL;
flag = 0;
}
}
}
}
void output(node* head)
{
while (head->next != NULL) {
head = head->next;
printf("<%d,%d>,", head->coef, head->exp);
}
printf("\n");
}
void multiplication(node* head1, node* head2, node* head3)
{
// 注意输入顺序是递增的
node* pt1 = head1->next; // 第一个多项式的指针
node* pt2 = head2->next; // 第二个多项式的指针
node* tmp = head3->next; // 第三个多项式的指针
node* pre = head3; // tmp 的前一个指针
if ((pt1->coef == 0 && pt1->exp == 0) || (pt2->coef == 0 && pt2->exp == 0)) {
// 零多项式单独讨论
node* newn = (node*)malloc(sizeof(node));
newn->coef = 0;
newn->exp = 0;
newn->next = NULL;
pre->next = newn;
return;
}
while (pt1 != NULL) {
pre = head3;
tmp = head3->next;
pt2 = head2->next;
while (pt2 != NULL) {
// 创建新的结点。注意多项式乘法，系数相乘，指数相加
node* newn = (node*)malloc(sizeof(node));
newn->coef = pt2->coef * pt1->coef;
newn->exp = pt2->exp + pt1->exp;
newn->next = NULL;
// 将创建的新结点加入到第三个多项式中，因此需要将 tmp 移动到合适的位置
while (tmp != NULL) {
if (tmp->next == NULL || (tmp->exp <= newn->exp && newn->exp < tmp->next->exp)) break;
tmp = tmp->next;
pre = pre->next;
}
// 将 “退出循环条件”分情况讨论
if (tmp == NULL) {
pre->next = newn;
tmp = newn;
}
else if (tmp->exp == newn->exp) {
tmp->coef = tmp->coef + newn->coef;
if (tmp->coef == 0) {
// 删除当前节点
pre->next = tmp->next;
tmp = pre->next;
}
}
else {
if (tmp->next != NULL) {
newn->next = tmp->next;
}
tmp->next = newn;
tmp = tmp->next;
pre = pre->next;
}
pt2 = pt2->next;
}
pt1 = pt1->next;
}
}
int main()
{
node* head1;
node* head2;
node* head3;
head1 = (node*)malloc(sizeof(node));
input(head1);
head2 = (node*)malloc(sizeof(node));
input(head2);
head3 = (node*)malloc(sizeof(node));
head3->next = NULL;
multiplication(head1, head2, head3);
output(head3);
return 0;
}
