数据结构 一元多项式运算

链表的生成

利用链表实现一元多项式的+、-、*运算,注意具体的思路是判断同类项,对其进行合并同类项,在乘法运算达到了O(n^3),可以优化的地方是先对结果链表C进行预处理,先复制这个链表给C,然后表C的操作过程就将了一维,变成O(n^2),并且每次可以利用链表的有序性这一点进行二分,但这是链表啊!怎么二分?还没想到,干脆把链表先导入数组中,然后在操作?这样就O(nlogn)了?....扯远了,就先O(n^3)吧。

要求:

实验五、线性表应用—一元多项式加减运算

1 实验目的

掌握用线性结构表示一元多项式的方法及实现一元多项式的加、减运算。

实验内容

两个一元多项式从键盘输入,每一项主要包括系数和指数两个数据,分别将两个一元多项式存到两个单链表中,然后对两个一元多项式进行加、减运算,最后输出结果。

实验过程

1):

(截图

2) :

(截图

(3

(截图

 

源代码

(附件)

具体代码如下:

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

//******宏定义参数******
#define OK 1
#define NO 0
#define DATA_MAX_SIZE 20

//******定义数据类型别名******
typedef int Status;
typedef char Excelelem;
typedef int Numelem;
typedef double db;

//******声明数据结构******
typedef struct Node
{
	db xishu;
	db mi;
	struct Node *next;
}LNode,*LinkList;

typedef struct
{
	Excelelem name[100];
	Numelem length;
	LinkList next;
}HeadList,*HeadLinkList;

//******声明函数******
LinkList Init(Numelem *n); //初始化链表体
HeadLinkList HeadInit(char a[]); //初始化链表头
LinkList DATA_UPPER_FIND(LinkList Head,db ans); //查找链表中第一个系数大于ans的结点的前驱
void DATA_ADD(HeadLinkList A,HeadLinkList B,HeadLinkList C); //多项式加法 O(n)
void DATA_SUB(HeadLinkList A,HeadLinkList B,HeadLinkList C); //多项式减法 O(n)
void DATA_Free(HeadLinkList Head); //释放链表体内存
void DATA_cout(HeadLinkList Head); //将链表数据域以多项式形势输出
void DATA_MUL(HeadLinkList A,HeadLinkList B,HeadLinkList C); //多项式乘法 O(n^3)

int main()
{
	HeadLinkList A,B,C;
	Numelem n;
	printf("**********start!**********\n");
	A=HeadInit("A多项式");
	printf("请输入%s:\n",A->name);
	A->next=Init(&A->length);
	B=HeadInit("B多项式");
	printf("请输入%s:\n",B->name);
	B->next=Init(&B->length);
	C=HeadInit("C多项式");
	C->next=NULL;
	printf("请输出%s的内容:\n",A->name);
	DATA_cout(A);
	printf("请输出%s的内容\n",B->name);
	DATA_cout(B);
	printf("%s+%s:\n",A->name,B->name);
	DATA_ADD(A,B,C);
	DATA_cout(C);
	printf("%s-%s:\n",A->name,B->name);
	DATA_SUB(A,B,C);
	DATA_cout(C);
	printf("%s*%s:\n",A->name,B->name);
	DATA_MUL(A,B,C);
	DATA_cout(C);
	printf("操作结束,释放内存!\n");
	DATA_Free(A);DATA_Free(B);DATA_Free(C);
	free(A),free(B),free(C);
	printf("***********End!***********\n");
	return 0;
}

//******查找插入的位置******
LinkList DATA_UPPER_FIND(LinkList Head,db ans)
{
	if(Head->next == NULL || Head->next->mi > ans)
		return Head;
	return DATA_UPPER_FIND(Head->next,ans);
}

LinkList Init(Numelem *n)
{
	//以系数=0为输入结束标志,以下为输入的多项式默认为已合并同类项,否则在查找的时候多一项特判
	LinkList Head,p,q;
	Numelem i=0;
	db a,b;
	Head=NULL;
	while(~scanf("%lf",&a) && a!=0.0)
	{
		scanf("%lf",&b);
		q=(LinkList)malloc(sizeof(LNode));
		q->xishu=a;
		q->mi=b;
		if(*n==0 || Head->mi>b) q->next=Head,Head=q;
		else
		{
			p=DATA_UPPER_FIND(Head,b);
			//if p->mi==b ...  未合并同类项的情况
			q->next=p->next;
			p->next=q;
		}
		*n++;
	}
	return Head;
}

HeadLinkList HeadInit(char *a)
{
	HeadLinkList Head;
	Head=(HeadLinkList)malloc(sizeof(HeadList));
	strcpy(Head->name,a);
	Head->length=0;
	return Head;
}

void DATA_ADD(HeadLinkList A,HeadLinkList B,HeadLinkList C)
{
	LinkList qa=A->next,qb=B->next,p,q=NULL;
	DATA_Free(C);
	while(qa || qb)
	{
		p=(LinkList)malloc(sizeof(LNode));
		if(qb==NULL || qa && qa->mi<qb->mi)
		{
			*p=*qa;
			qa=qa->next;
		}
		else if(qa==NULL || qb && qa->mi>qb->mi)
		{
			*p=*qb;
			qb=qb->next;
		}
		else
		{
			p->xishu=qb->xishu+qa->xishu;
			p->mi=qb->mi;
			qa=qa->next;
			qb=qb->next;
		}
		if(q==NULL) p->next=q,C->next=q=p;
		else
			p->next=q->next,q->next=p,q=p;
		C->length++;
	}
}

void DATA_SUB(HeadLinkList A,HeadLinkList B,HeadLinkList C)
{
	LinkList qa=A->next,qb=B->next,p,q=NULL;
	DATA_Free(C);
	while(qa!=NULL || qb!=NULL)
	{
		p=(LinkList)malloc(sizeof(LNode));
		if(qb==NULL || qa && qa->mi<qb->mi)
		{
			*p=*qa;
			qa=qa->next;
		}
		else if(qa==NULL || qb && qa->mi>qb->mi)
		{
			*p=*qb;
			p->xishu*=-1;
			qb=qb->next;
		}
		else
		{
			*p=*qa;
			p->xishu-=qb->xishu;
			qa=qa->next;
			qb=qb->next;
			if(p->xishu==0)
			{
				free(p);
				continue;
			}
		}
		if(q==NULL) p->next=q,C->next=q=p;
		else
			q->next=p->next,q->next=p,q=p;
		C->length++;
	}
}

void DATA_MUL(HeadLinkList A,HeadLinkList B,HeadLinkList C)
{
	LinkList qa,qb,p,q;
	db a,b;
	DATA_Free(C);
	for(qa=A->next;qa;qa=qa->next)
	{
		for(qb=B->next;qb;qb=qb->next)
		{
			a=qa->xishu*qb->xishu;
			b=qa->mi+qb->mi;
			if(C->length)
			{
				p=DATA_UPPER_FIND(C->next,b);
				if(p->mi == b)
					p->xishu+=a;
				else
				{
					q=(LinkList)malloc(sizeof(LNode));
					q->xishu=a;
					q->mi=b;
					q->next=p->next;
					p->next=q;
					C->length++;
				}
			}
			else
			{
				p=(LinkList)malloc(sizeof(LNode));
				p->xishu=a;
				p->mi=b;
				p->next=C->next;
				C->next=p;
				C->length++;
			}
		}
	}
}

void DATA_Free(HeadLinkList Head)
{
	LinkList q=Head->next,p;
	while (q)
	{
		p=q;
		q=q->next;
		free(p);
	}
	Head->length=0;
	Head->next=NULL;
	return ;
}

void DATA_cout(HeadLinkList Head)
{
	LinkList q=Head->next;
	while(q)
	{
		if(q->xishu>0 && q!=Head->next)
			printf("+");
		printf("%.1lfx^(%.1lf)",q->xishu,q->mi);
		q=q->next;
	}
	printf("\n");
	return ;
}

总结:

链表和顺序表的直接操作各有优点,在处理离散程度较大的数据时,链表可以节省空间,顺序表就会比较耗内存;在处理相对连续的数据时,用到顺序表就可以利用其逻辑结构和物理结构一直这一特点,降低算法的复杂度。
数据结构是计算机科学中研究数据组织、存储和管理的一门学科。一元多项式是数学中的概念,它由一个变量和对应的系数构成。一元多项式运算器是一个能够对一元多项式进行各种运算的程序或工具。 在Java中实现一元多项式运算器,可以使用链表或数组等数据结构来表示和存储多项式。以下是一个简单的示例代码: ```java import java.util.*; class Term { int coefficient; int exponent; public Term(int coefficient, int exponent) { this.coefficient = coefficient; this.exponent = exponent; } } class Polynomial { List<Term> terms; public Polynomial() { terms = new ArrayList<>(); } public void addTerm(int coefficient, int exponent) { terms.add(new Term(coefficient, exponent)); } public Polynomial add(Polynomial other) { Polynomial result = new Polynomial(); result.terms.addAll(this.terms); for (Term term : other.terms) { boolean found = false; for (Term existingTerm : result.terms) { if (existingTerm.exponent == term.exponent) { existingTerm.coefficient += term.coefficient; found = true; break; } } if (!found) { result.terms.add(term); } } return result; } public Polynomial multiply(Polynomial other) { Polynomial result = new Polynomial(); for (Term term1 : this.terms) { for (Term term2 : other.terms) { int coefficient = term1.coefficient * term2.coefficient; int exponent = term1.exponent + term2.exponent; result.addTerm(coefficient, exponent); } } return result; } public void print() { for (Term term : terms) { System.out.print(term.coefficient + "x^" + term.exponent + " + "); } System.out.println(); } } public class PolynomialCalculator { public static void main(String[] args) { Polynomial p1 = new Polynomial(); p1.addTerm(2, 3); p1.addTerm(4, 2); p1.addTerm(1, 0); Polynomial p2 = new Polynomial(); p2.addTerm(3, 2); p2.addTerm(1, 1); p2.addTerm(5, 0); Polynomial sum = p1.add(p2); Polynomial product = p1.multiply(p2); System.out.println("Sum:"); sum.print(); System.out.println("Product:"); product.print(); } } ``` 这个示例代码实现了一个简单的一元多项式运算器,可以进行多项式的加法和乘法运算。你可以根据需要扩展该代码,添加其他运算功能。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小胡同的诗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值