【数据结构——线性表】（C语言）一元多项式乘法

• 问题描述

一元多项式A 、B 按降次排列，用带头结点的链表存储，求 C=A ×B，试编程实现。

• 代码实现

#include<stdio.h>
#include<stdlib.h>

typedef struct Lnode{
	int coef;	//定义系数
	int exp;	//定义指数
	struct Lnode *next;	//指向下一项 
}Lnode; 

void Read(Lnode *node);		//读取函数 
void Write(Lnode *node);	//输出函数 
void Mul(Lnode *node_a,Lnode *node_b,Lnode *node_c);	//乘法运算 
void Add(Lnode *node_a,Lnode *node_b);					//加法运算 

int main(void)
{	
	Lnode *lnode_a=(Lnode *)malloc(sizeof(Lnode));	//多项式A 
	Lnode *lnode_b=(Lnode *)malloc(sizeof(Lnode));	//多项式B 
	Lnode *lnode_c=(Lnode *)malloc(sizeof(Lnode));	//结果多项式C 
	lnode_c->next=NULL;
	printf("请输入多项式A:\n");
	Read(lnode_a);
	printf("\n请输入多项式B:\n");
	Read(lnode_b);
	Mul(lnode_a->next,lnode_b->next,lnode_c);
	printf("\n多项式A、B之积C为：\n");
	Write(lnode_c->next);
	
	return 0;
}

void Read(Lnode *node)
{
	int kaiguan=1; 	char r=getchar();			//kaiguan开关，用于判断存取为系数还是指数 
	node->next=(Lnode *)malloc(sizeof(Lnode));	//建立头结点 
	node=node->next;	node->coef=0;	node->exp=0;
	while(r!='\n')
	{
		if(r=='+')
		{
			node->next = ( Lnode* )malloc( sizeof( Lnode ) ); 
			node=node->next;	node->coef=0;	node->exp=0;
			kaiguan=1-kaiguan;
		}
		else	if(r=='x'||r=='X')	kaiguan=1-kaiguan;				//调整开关状态 
		else	if(kaiguan)	node->coef=10*(node->coef) + (r-48);	// ascII码存取数字 
		else	node->exp=10*(node->exp) + (r-48);
		r=getchar();
	}
	
		node->next=NULL;
}

void Write(Lnode *node)
{
	printf("%dX^%d ",node->coef,node->exp);
	node=node->next;
	while(node->next != NULL)
	{
		printf("+ %dX^%d ",node->coef,node->exp);
		node=node->next;
	}
	if(node->exp != 0)
		printf("+ %dX^%d",node->coef,node->exp);
	else if(node->coef != 0)
		printf("+ %d",node->coef);
}

void Mul(Lnode *node_a,Lnode *node_b,Lnode *node_c)
{
	Lnode *node_d=(Lnode *)malloc(sizeof(Lnode));	//D用于存放B的每一项与A的乘积 
	Lnode *memmory=node_d; 							//memmory记住D的头结点 
	Lnode *head=node_a;								//head记住A的头结点 
	node_d->next=(Lnode *)malloc(sizeof(Lnode));
	while(node_b!=NULL) 
	{
		while(node_a!=NULL)
		{	
			node_d=node_d->next;
			node_d->exp=node_a->exp+node_b->exp;
			node_d->coef=node_a->coef*node_b->coef;
			node_d->next=(Lnode *)malloc(sizeof(Lnode));
			node_a=node_a->next;
		}
		node_d->next=NULL;							 
		Add(node_c,memmory);						//将每次D的结果加入到C中 
		node_d=(Lnode *)malloc(sizeof(Lnode));
		memmory=node_d; 
		node_d->next=(Lnode *)malloc(sizeof(Lnode));
		node_a=head;
		node_b=node_b->next;
	}
}

void Add(Lnode *node_a,Lnode *node_b)
{	
	Lnode *node_c=node_a,*node_d=node_b->next;	//C的地址为A的前一项，D的地址与B同时 
	node_a=node_a->next;						//将B的每一项加入至A中，无需新建一个单链表；					
	node_b=node_b->next;                        //也可新建一个单链表，同时比较A、B的第一项，依次向后延申 
	while(node_b!=NULL)
	{
		if(node_a==NULL)
		{
			node_a=(Lnode *)malloc(sizeof(Lnode));
			node_a->exp=0;
			node_a->coef=0;
			node_a->next=NULL;
		}
		if(node_a->exp==node_b->exp)
		{
			node_a->coef=node_a->coef+node_b->coef;
			node_a=node_a->next;
			node_b=node_b->next;
			node_c=node_c->next;
			node_d=node_d->next;
		}
		else if(node_a->exp > node_b->exp)
		{
			node_a=node_a->next;
			node_c=node_c->next;
		}
		else if(node_a->exp < node_b->exp)
		{
			node_c->next=node_b;
			node_b=node_b->next;
			node_d->next=node_a;
			node_d=node_b;
			node_c=node_c->next;
		}
	}
}

• 知识总结

1. 线性表是具有相同特性数据元素的一个有限序列，其中序列所含元素的个数叫做线性表的长度。
2. 线性表的存储结构：顺序存储结构、链式存储结构。前者为顺序表，后者为链表。
3. 顺序表的两个特性：随机访问特性、占用连续的存储空间（存储分配只能预先进行）。
4. 链表的三个特性：不支持随机访问、结点的存储空间利用率稍低于线性表、支持存储空间的动态分配。
5. 带头结点的单链表 head=head->next 时链表为空；不带头结点时 head=NULL 时链表为空。
6. 顺序表和链表的比较

      (1)  基于空间的比较

          1）存储分配：顺序表  一次性分配； 链表  多次分配

          2）存储密度：顺序表  密度=1      ； 链表  密度<1

      (2)  基于时间的比较

          1） 存取方式：顺序表  随机存储  ；  链表  顺序存储

          2）  插入/删除 移动元素个数： 顺序表  近一半元素；链表  不移动元素