两个多项式相乘

两个多项式相乘
千次阅读

2016-03-31 21:12:00

一个m项，一个n项

相加：从第一项开始，每一次都拿两个多项式的头开始比较，小的项就进目标链表，前进一格，从而完成相加，复杂度o（m+n）

相乘：

算法1：o（m*m*n*n)

每一项相乘，结果插入目标链表里

算法2：o（m*n*n）

拿一个多项式每一项与另一整个多项式相乘，然后将这m个或n个多项式相加；这个算法比上个算法的优点在于利用了这两个多项式升序排的条件

算法3：待续

转载于:https://www.cnblogs.com/xuehongyang/p/5342807.html

更多相关内容
【练习3.7】编写一个函数将两个多项式相乘
千次阅读 2019-07-27 22:53:41

【练习3.7】编写一个函数将两个多项式相乘，用一个链表实现。你必须保证输出的多项式按幂次排列，并且任意幂次最多只有一项。 a.给出以O(M2N2)时间求解该问题的算法。一种算法是将结果保存在按指数排序的链表中。...

转载：https://www.cnblogs.com/catnip/p/4331347.html

【练习3.7】编写一个函数将两个多项式相乘，用一个链表实现。你必须保证输出的多项式按幂次排列，并且任意幂次最多只有一项。

a.给出以O(M²N²)时间求解该问题的算法。

一种算法是将结果保存在按指数排序的链表中。每个mn乘法都需要搜索链表中的重复项。由于链接列表的大小为mn，因此总运行时间为O（m ² n²）。

b.写一个以O(M² N)时间执行乘法的程序，其中M≤N。

M≤1时，方法易知。
M≥2时，每次将长度为M的链表的一项，与另一链表的所有项相乘，每次一组N个有序的多项式元素。
对于每两组上式的N个多项式元素，基本按两个有序链表求并的算法（除幂次相同需将系数相加）操作。
求并算法时间复杂度O(M+N)，故该算法复杂度为(乘法时间）O(MN)+（求并时间）O（(N+N)+(2N+N)+(3N+N)+……+(MN+N))=O（M²N）

c.写一个以O(MNlog(MN))时间执行乘法的程序。

同a先将两链表元素两两相乘并列出，对MN项元素进行O(NlogN)的排序
排序完成后，遍历代码，合并同幂次项，最后全部插入链表。
时间复杂度为：（乘法时间）O(MN)+（排序时间）O(MNlogMN)+（合并同类项时间）O(MN)=O(MNlogMN)

d.上面哪个时间界最好？

算法的选择取决于m和n的相对值。如果它们接近，那么（c）部分的解决方案更好。如果一个多项式非常小，那么解决方案为：（b）部分更好。

收起

展开全文
Python程序将两个多项式相乘，其中多项式的每个项表示为一对整数（系数，指数）？
2020-11-25 10:47:37

Python程序将两个多项式相乘，其中多项式的每个项表示为一对整数（系数，指数）？- >首先要求no。存储每个幂的系数的字典乘以多项式p2的所有系数。然后将所有具有相同功率的字典系数相加。def multpoly(p1,p2):dp1=...

功能需要两个列表（具有元组作为值）作为输入我在我的脑海中，后面的算法为此编写代码，但要正确编写它。Python程序将两个多项式相乘，其中多项式的每个项表示为一对整数（系数，指数）？

- >首先要求no。存储每个幂的系数的字典乘以多项式p2的所有系数。

然后将所有具有相同功率的字典系数相加。

def multpoly(p1,p2):

dp1=dict(map(reversed, p1))

dp2=dict(map(reversed, p2))

kdp1=list(dp1.keys())

kdp2=list(dp2.keys())

rslt={}

if len(kdp1)>=len(kdp2):

kd1=kdp1

kd2=kdp2

elif len(kdp1)

kd1=kdp2

kd2=kdp1

for n in kd2:

for m in kd1:

rslt[n]={m:0}

if len(dp1)<=len(dp2):

rslt[n][m+n]=rslt[n][m+n] + dp1[n]*dp2[m]

elif len(dp1)>len(dp2):

rslt[n][m+n]=rslt[n][m+n] + dp2[n]*dp1[m]

return(rslt)

+0

请提出具体问题。 –

+0

不清楚你问什么或你的问题是什么 –

+0

[this]的可能重复（http://stackoverflow.com/questions/39057546/how-to-calculate-sum-of-two-polynomials/ 39058521＃39058521）问题？ –

收起

展开全文

python连乘函数

链表——多项式相乘、相加、求导、相乘

2022-03-31 17:20:17

//NODE节点的定义，这里最好的就是template模板，AN类型的任何数据域都可以在这里添加，比如再来一个结构体定义，data就可以封装多个数据 template <class AN> struct NODE { AN DATA; NODE<AN>* next...

#include<iostream> 
using namespace std;
//NODE节点的定义，这里最好的就是template模板，AN类型的任何数据域都可以在这里添加，比如再来一个结构体定义，data就可以封装多个数据
template <class AN>
struct NODE
{
	AN DATA;
	NODE<AN>* next = NULL;
};
struct element//element就是节点的数据域
{
	double a;//系数
	int e;//指数
	element(double cc = 0, int ee = 0) :a(cc), e(ee) {};
};//定义element
//链表定义基类的定义
template<class AN>
class LinkList
{
public:
	LinkList() { front = new NODE<AN>; front->next = NULL; }//无参构造函数
	LinkList(AN a[], int n);//含参构造函数
	~LinkList();//析构
	NODE<AN>* front;
	int Length = 0;
};
//派生类
class TruList :public LinkList<element>
{
public:
	TruList(element data[], int n) :LinkList(data, n) {};//构造函数，构造出多项式链表
	void Add(TruList& b);//函数相加
	void Cut(TruList& b);//函数相减 
	void Sum(int x);//求某一点的值
	void Der();//求导数
	void PrintList();//输出
	element* OneAndMore(TruList& a, element b);
	void Pro(TruList& a, TruList& b);//多项式相乘
};
//基类构造函数
template<class AN>
LinkList<AN>::LinkList(AN a[], int n)//头插法插入数组
{
	Length = n;
	front = new NODE<AN>;
	front->next = NULL;
	for (int i = n - 1; i >= 0; i--)
	{
		NODE<AN>* s = new NODE<AN>;
		s->DATA = a[i];
		s->next = front->next;
		front->next = s;
	}
}
//基类析构函数
template<class AN>
LinkList<AN>::~LinkList()
{
	NODE<AN>* p = front;
	while (p)
	{
		front = p;
		p = front->next;
		delete front;
	}
}

//Add函数
void TruList::Add(TruList& b)
{
	NODE<element>* p_front = front;//p前面的指针
	NODE<element>* p = p_front->next;//p指针指向a的第一个element
	NODE<element>* q = b.front->next;//q指向b的第一个element
	while (p && q)
	{
		if (p->DATA.e < q->DATA.e)//a的指数比b小
		{
			p_front = p;
			p = p->next;//p和p_front向后移
		}
		else if (p->DATA.e > q->DATA.e)//a的指数比b大,把b加入到a
		{
			p_front->next = q;
			p_front = q;
			q = q->next;
			p_front->next = p;

		}
		else//如果相等
		{
			p->DATA.a += q->DATA.a;
			if (fabs(p->DATA.a) < 1e-7)
			{
				p_front->next = p->next;
				delete p;
				p = p_front->next;
			}
			else
			{
				p_front = p;
				p = p_front->next;
			}
			NODE<element>* temp = q;
			q = q->next;
			delete temp;
		}
	}
	if (q)p_front->next = q;
	b.front->next = NULL;
}
//CUt函数
void TruList::Cut(TruList& b)
{
	NODE<element>* p_front = front;//p前面的指针
	NODE<element>* p = p_front->next;//p指针指向a的第一个element
	NODE<element>* q = b.front->next;//q指向b的第一个element
	while (p && q)
	{
		if (p->DATA.e < q->DATA.e)//a的指数比b小
		{
			p_front = p;
			p = p->next;//p和p_front向后移
		}
		else if (p->DATA.e > q->DATA.e)//a的指数比b大,把-b加入到a
		{
			q->DATA.a = (-1)*(q->DATA.a);
			p_front->next = q;
			p_front = q;
			q = q->next;
			p_front->next = p;

		}
		else
		{
			p->DATA.a -= (q->DATA.a);
			if (fabs(p->DATA.a) < 1e-7)
			{
				p_front->next = p->next;
				delete p;
				p = p_front->next;
			}
			else
			{
				p_front = p;
				p = p_front->next;
			}
			NODE<element>* temp = q;
			q = q->next;
			delete temp;
		}
	}
	if (q)//q后面还有节点
	{
		NODE<element>* qq = q;
		while (q)
		{
			
			q->DATA.a = (-1) * q->DATA.a;
			q = q->next;
		}
		p_front->next = qq;
	}
	b.front->next = NULL;
}
//Sum函数
void TruList::Sum(int x)
{
	if (x == 0)throw"0";
	double sum = 0;
	NODE<element>* p = front->next;
	while (p)
	{
		if (p->DATA.e < 0)//如果指数为负
		{
			int jiecheng = 1;
			for (int i = 1; i < -(p->DATA.e); i++)
			{
				jiecheng = jiecheng * (1 / x) * (1 / x);
			}
			sum = sum + (p->DATA.a) * jiecheng;
		}
		else if (p->DATA.e == 0)
		{
			sum = sum + p->DATA.a;
		}
		else
		{
			int jiecheng = 1;
			for (int i = 1; i < (p->DATA.e); i++)
			{
				jiecheng = jiecheng * x * x;
			}
			sum = sum + (p->DATA.a) * jiecheng;
		}
		p = p->next;
	}
	cout << sum;

}
//求导
void TruList::Der()
{
	NODE<element>* p = front->next;
	NODE<element>* p_front = front;
	while (p)
	{
		if (p->DATA.e != 0)
		{
			p->DATA.a = p->DATA.a * p->DATA.e;
			p->DATA.e = p->DATA.e - 1;
			if (p->DATA.e != 0)
			{
				p_front = p;
				p = p->next;
			}
			else if (p->DATA.e == 0 && p_front->DATA.e == 0)
			{
				p_front->DATA.a += p->DATA.a;
				p = p->next;
			}
			else
			{
				p_front = p;
				p = p->next;
			}
		}
		else
		{
			p_front = p;
			p = p->next;
		}

	}
}
//多项式乘单项式
element* TruList::OneAndMore(TruList& a, element b)//传入多项式链表和单项式的数据域
{

	NODE<element>* p = a.front->next;//获取第一个
	element* s = new element[100];//创建element用于存储和返回
	int i = 0;//i用于s指针的定位
	while (p)
	{
		s[i].a = p->DATA.a * b.a;//s[i]储存相乘的系数和指数
		s[i].e = p->DATA.e * b.e;
		i++;//计数+1
		p = p->next;//多项式后移

	}
    return s;
}
//多项式相乘
void TruList::Pro(TruList& a, TruList& b)//多项式相乘函数，需要传入两个相乘的多项式类
{

	NODE<element>* p = front->next;//获取第一个多项式
	NODE<element>* q = b.front->next;//获取第二个多项式

	element kong[1] = {};//创建一个element用于构造储存多项式的对象
	TruList temp1(kong, 1);//temp1就是用于储存的多项式
	while (q)//第二个单项式逐项乘第一个多项式
	{
		TruList temp2(OneAndMore(a, q->DATA), a.Length);//传入第一个单项式，进行单项式乘多项式
		temp1.Add(temp2);//多项式相加
		q = q->next;
	}
	temp1.PrintList();//输出
}
//输出函数
void TruList::PrintList()
{
	NODE<element>* p = front->next;//获取第一个多项式的信息
	int i = 0;
	while (p)//如果p指向的区域非空
	{
		if (p->DATA.a < 0)//如果系数小于零
		{
			if (p->DATA.a == (-1))//如果系数小于零且等于-1
			{
				cout << "-";
				if (p->DATA.e != 0 && p->DATA.e != 1)//如果指数为非0或非1
				{
					cout << "X^" << p->DATA.e << " ";
				}
				else if (p->DATA.e == 1)//如果指数为1
				{
					cout << "X";
				}
				p = p->next;
			}
			else//如果系数
			{
				cout << p->DATA.a;
				if (p->DATA.e != 0 && p->DATA.e != 1)
				{
					cout << "X^" << p->DATA.e << " ";
				}
				else if (p->DATA.e == 1)
				{
					cout << "X";
				}
				p = p->next;
			}

		}
		else if (p->DATA.a == 0)//系数等于零直接跳过
		{
			p = p->next;
		}
		else//系数为正
		{
			if (i == 0)//如果是第一个，不用输出正号
			{
				if (p->DATA.a == 1)
				{
					if (p->DATA.e != 0 && p->DATA.e != 1)
					{
						cout << "X^" << p->DATA.e << " ";
					}
					else if (p->DATA.e == 1)
					{
						cout << "X";
					}
					p = p->next;
				}
				else//系数不为1
				{
					cout << p->DATA.a;
					if (p->DATA.e != 0 && p->DATA.e != 1)
					{
						cout << "X^" << p->DATA.e << " ";
					}
					else if (p->DATA.e == 1)
					{
						cout << "X ";
					}
					p = p->next;
				}
				i++;
			}
			else//不是第一个要输出＋
			{
				if (p->DATA.a == 1)
				{
					if (p->DATA.e != 0 && p->DATA.e != 1)
					{
						cout << "+X^" << p->DATA.e << " ";
					}
					else if (p->DATA.e == 1)
					{
						cout << "+X" << " ";
					}
					p = p->next;
				}
				else//系数不为1
				{
					cout << "+" << p->DATA.a;
					if (p->DATA.e != 0 && p->DATA.e != 1)
					{
						cout << "X^" << p->DATA.e << " ";
					}
					else if (p->DATA.e == 1)
					{
						cout << "X";
					}
					p = p->next;
				}
			}
		}
	}
	cout << endl;
}


int main()
{
	//操作界面
	int choose;
	cout << " *********************************************************************************************" << endl << endl;;
	cout << "          注：请按升幂次序依次输入多项式各项的系数和指数   如：X+8X^2   您可输入：1 1 8 2" << endl;
	cout << "                              多项式相加请输入                 1" << endl;
	cout << "                              多项式相减请输入                 2" << endl;
	cout << "                              多项式求导请输入                 3" << endl;
	cout << "                              多项式求某个值请输入             4" << endl;
	cout << "                              多项式相乘请输入                 5" << endl;
	cout << "                              退出请输入                       0" << endl;
	cout << "***********************************************************************************************" << endl;
	
	do
	{
		cout << "请输入您的操作(数字）：";
		cin >> choose;
		switch (choose)
		{
		case 0:break;
		case 1:
		{//多项式相加

		//首先完成多项式链表的构建
			cout << "请输入第一组多项式：";
			int a = 0, e = 0; int i = 0;
			element* s = new element[100];
			do 
			{
				cin >> a >> e;
				s[i].a = a;
				s[i].e = e;
				i++;
			} while (getchar() != '\n');
			TruList aa(s, i + 1);
			cout << "请输入第二组多项式：";
			a = 0, e = 0;  i = 0;
			element* p = new element[100];
			do
			{
				cin >> a >> e;
				p[i].a = a;
				p[i].e = e;
				i++;
			} while (getchar() != '\n');
			cout << endl;
			//相加函数
			TruList bb(p, i + 1);
			aa.Add(bb);
			aa.PrintList();
			delete[] s;
			delete[] p;

			cout << endl;
			break;
		}
		case 2://多项式相减
		{//首先完成多项式链表的构建
			cout << "请输入第一组多项式：";
			int a = 0, e = 0; int i = 0;
			element* s = new element[100];
			do
			{
				cin >> a >> e;
				s[i].a = a;
				s[i].e = e;
				i++;
			} while (getchar() != '\n');
			TruList aa(s, i + 1);
			cout << "请输入第二组多项式：";
			a = 0, e = 0;  i = 0;
			element* p = new element[100];
			do
			{
				cin >> a >> e;
				p[i].a = a;
				p[i].e = e;
				i++;
			} while (getchar() != '\n');
			cout << endl;
			//相加函数
			TruList bb(p, i + 1);
			aa.Cut(bb);
			aa.PrintList();
			delete[] s;
			delete[] p;
			cout << endl; 
			break;
		}
		case 3://多项式求导
		{
			cout << "请输入要求导的多项式：";
			int a = 0, e = 0; int i = 0;
			element* s = new element[100];
			do
			{
				cin >> a >> e;
				s[i].a = a;
				s[i].e = e;
				i++;
			} while (getchar() != '\n');
			TruList aa(s, i + 1);
			cout << endl;
			aa.Der();
			aa.PrintList();
			delete[] s; 
			break;
		}
		case 4:
		{
			cout << "请输入要值的多项式：";
			int a = 0, e = 0; int i = 0;
			element* s = new element[100];
			do
			{
				cin >> a >> e;
				s[i].a = a;
				s[i].e = e;
				i++;
			} while (getchar() != '\n');
			TruList aa(s, i + 1);
			
			cout << "请输入您要求的X的值";
			int m = 0; cin >> m;
			aa.Sum(m);
			cout << endl;
			delete[] s;
			break;
		}
		case 5://多项式相乘
		{//首先完成多项式链表的构建
			cout << "请输入第一组多项式：";
			int a = 0, e = 0; int i = 0;
			element* s = new element[100];
			do
			{
				cin >> a >> e;
				s[i].a = a;
				s[i].e = e;
				i++;
			} while (getchar() != '\n');
			TruList aa(s, i + 1);
			cout << "请输入第二组多项式：";
			a = 0, e = 0;  i = 0;
			element* p = new element[100];
			do
			{
				cin >> a >> e;
				p[i].a = a;
				p[i].e = e;
				i++;
			} while (getchar() != '\n');
			TruList bb(p, i + 1);
			cout << endl;
			aa.Pro(aa, bb);
			break;
		}
		default: 
		{
			cout << "输入错误，注意提示，请重新输入！" << endl;
		}
        }
	} while (choose != 0);

}

收起

展开全文

c++ 链表

C++多项式相乘
千次阅读 2020-02-23 16:28:26

//累加的原因是，因为是两个相加的式子相乘，所以要合并幂次相同的项 } for ( int i = 20 ; i >= 0 ; i -- ) { if ( ans [ i ] != 0 ) { cout ans [ i ] " " i endl ; } } ...

收起
两个多项式相乘
千次阅读 2012-08-30 21:08:34

#include #include #define swap(x, y, t) ((t)=(x),(x)=(y),(y)=(t)) #define MAX_SIZE 1000 void readpoly( int *starta, int *startb, int *finisha, int *finishb); void muti(int starta, int startb, int fin

收起

struct float input
两个多项式相乘求解系数数组算法
千次阅读 2019-09-27 03:22:08

　给出两个多项式，最高次幂分别为n和m，求解这两个系数相乘得到的系数数组。分析：　最高次幂如果是m和n，那么他们相乘得到的系数数组的最高次幂一定是n+m，对于其他的系数，不妨设a[],b[]是给定的两个系数数组...

收起
计蒜客-多项式相乘
2020-04-29 21:02:58

题目链接：多项式相乘 题目思路：用数组存每个指数所对应的系数，题中所说，a,b<=10,所以指数最大为20 #include <bits/stdc++.h> using namespace std; int a[2][2]; //存第一项 int b[2][2];//存第二项...

收起
《程序设计实践》第06练——多项式相乘
2021-08-07 22:26:35

【问题描述】编程实现若干个多项式相乘。多项式的输入输出格式为：系数在前，指数在后，各项按指数递增排列，每个多项式输入时以两个0结束。系数为0的项不输出。例如：1+4X3-9X5  输入格式可以为：1 0 0 1 0 2 4...

收起
链表实现多项式相乘-数据结构学习
2019-10-03 08:18:12

链表实现多项式相乘<线性表> 初学数据结构,我这个菜鸟没看教程完全自己想. 这个题做好了好久....　输入两个多项式,多项式的第一个数是项数.后续是两两一对,一个系数,一个指数. 多项式有序,按照系数...

收起
用c编写一元多项式相乘
2011-08-30 16:27:23

两个一元多项式相乘: 如： pa=5X50+15X20+20X10 pb=10X30+20X20+150X2 分析：就是pa中的每一项分别乘以pb的各项，然后合并同类项。指数公式：AXABXB=ABXA+B 相乘的结果是: pc=50X80+100X70+750X52+ 150X50+300X40...

收起
多项式相乘 数据结构课程设计
2009-05-29 09:55:58

多项式相乘 数据结构课程设计，含源代码，和详细的实验报告

收起
C语言实现两个多项式相加&相减&相乘运算
2021-11-09 10:59:01

} 程序分析：运行结果：实现两个多项式相乘 算法思路：创建两个链表，其中包含数据域(系数、指数)，以及指向下一个结点的指针域。将链表中数据域进行相乘后得到新的链表，将新链表按照指数递减的规则排序。定义两...

收起

数据结构链表 c语言
C C++程序设计求两个一元多项式相乘的算法.txt
2022-05-18 19:08:32

C C++程序设计求两个一元多项式相乘的算法.txt

收起
单向链表练习3.7 多项式相乘
2017-03-19 22:00:45

多项式相乘 用链表实现

收起
单链表实现多项式的相乘-c语言
2021-05-19 14:09:24

若是当前k值,表明该指数找到了，此时就是a,b都后继一位，因为只有这种组合才可能有同样系数若是当前指数k,表明要减少系数和，只有b增加这也就看出了，a,b两个链表指数一个升序一个降序的好处了。这种思路很好 3....

收起
多项式相乘一元稀疏多项式简单计算器
2014-12-15 12:13:14

多项式相乘一元稀疏多项式简单计算器的基本功能是：（1)输入并建立多项式；（2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,...,cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序...

收起
C语言实现两个多项式加法与乘法
2021-10-23 22:00:46

先说一下，我用了两种方法实现，一种是顺序表实现，一种是链表实现，所以，为了方便，将两种方法分别写成头文件了，主函数是一样的方法一（顺序表实现）直接上代码，头文件"List.h"代码： //头文件"List.h" #...

收起

c语言链表开发语言
数据结构__两个多项式乘法运算
千次阅读 2018-10-29 13:32:50

这个，也是第一次数据结构课程设计的题目一共四个文件，分别命名为main.cpp head.h list.h cal.h。作用分别是main函数主程序，基本头文件卷入，单链表和其基本操作的定义，计算并合并同类项目操作注释就不写了，...

收起
数据结构多项式相乘
2013-04-16 20:23:30

建立链表表示一个一元多项式，并完成两个多项式的乘法，并输出。

收起
BUAA(2021春)多项式相乘
2021-04-29 17:11:11

编写一个程序实现两个一元多项式相乘。输入形式首先输入第一个多项式中系数不为0的项的系数和指数，以一个空格分隔。且该多项式中各项的指数均为0或正整数，系数和最高幂次不会超过int类型的表示范围。对于多项式 ...

收起

算法字符串 c语言
A1009 Product of Polynomials（两个多项式相乘）
2019-01-11 14:00:51

给出两个多项式，求两个多项式的乘积。注意：答案的数组至少会取得2000，所以要开到2001. 没必要开两个数组，读完两个多项式之后再处理，读完一个多项式，对于第二个边读边处理。段错误：越界错误 ...

收起
多项式相乘（链表）
千次阅读 2019-09-19 19:04:41

这个要相乘，那就必须把A中的每一项分别和B中的每一项相乘。所以就是，A中的每一项分别和B中的所有相乘，得到一个链表，然后把所有链表相加？感觉能做，但是好麻烦啊。有没有更简单的做法呢？去网上搜索，emmm，...

收起
C语言实现多项式相乘
2012-11-05 13:57:56

编程实现若干个多项式相乘。多项式的输入输出格式为：系数在前，指数在后，各项按指数递增排列，每个多项式输入时以两个0结束。系数为0的项不输出。例如：1+4X3-9X5输入格式为：1 0 0 1 0 2 4 3 0 4 -9 5 0 0或者 1 ...

收起
数据结构-多项式相乘.doc
2022-07-11 12:17:56

多项式相乘 * 问题描述此程序解决的是一元多项式相乘的问题。定义两个一元多项式，然后进行两个一元多项式的相乘。最后得到一个结果，并按升幂输出最终的多项式。 * 设计思路定义一个结构体，里面包含一元多项式...

收起
多项式相乘
2020-07-25 20:25:11

下面两种方法计算结果是一致的。 matlab 计算结果 f=(x^2+2*x+1)*(2*x^2+x+3) collect(f,x) 2*x^4 + 5*x^3 + 7*x^2 + 7*x + 3 conv([1,2,1],[2,1,3]) 2 5 7 7 3

收起
编程实现若干个多项式相乘。多项式的输入输出格式为：系数在前，指数在后，各项按指数递增排列，每个多项式...
千次阅读 2019-03-16 17:07:52

/实现n个多项式相乘/ #include “stdio.h” const int N0=20; //常数: 多项式最多20个 typedef struct node{ //多项式的项(链表节点), 数据包含: 项的系数和指数, 下一项的指针. int c, e; //c-系数(coefficient);...

收起

C语言链表

【练习3.7】编写一个函数将两个多项式相乘

【练习3.7】编写一个函数将两个多项式相乘，用一个链表实现。你必须保证输出的多项式按幂次排列，并且任意幂次最多只有一项。

a.给出以O(M²N²)时间求解该问题的算法。

b.写一个以O(M² N)时间执行乘法的程序，其中M≤N。

c.写一个以O(MNlog(MN))时间执行乘法的程序。

d.上面哪个时间界最好？

Python程序将两个多项式相乘，其中多项式的每个项表示为一对整数（系数，指数）？

链表——多项式相乘、相加、求导、相乘

C++多项式相乘

两个多项式相乘

两个多项式相乘求解系数数组算法

计蒜客-多项式相乘

《程序设计实践》第06练——多项式相乘

链表实现多项式相乘-数据结构学习

用c编写一元多项式相乘

多项式相乘数据结构课程设计

C语言实现两个多项式相加&相减&相乘运算

C C++程序设计求两个一元多项式相乘的算法.txt

单向链表练习3.7 多项式相乘

单链表实现多项式的相乘-c语言

多项式相乘一元稀疏多项式简单计算器

C语言实现两个多项式加法与乘法

数据结构__两个多项式乘法运算

数据结构多项式相乘

BUAA(2021春)多项式相乘

A1009 Product of Polynomials（两个多项式相乘）

多项式相乘（链表）

C语言实现多项式相乘

数据结构-多项式相乘.doc

多项式相乘

编程实现若干个多项式相乘。多项式的输入输出格式为：系数在前，指数在后，各项按指数递增排列，每个多项式...

两个多项式相乘

【练习3.7】编写一个函数将两个多项式相乘

【练习3.7】编写一个函数将两个多项式相乘，用一个链表实现。你必须保证输出的多项式按幂次排列，并且任意幂次最多只有一项。

a.给出以O(M2N2)时间求解该问题的算法。

b.写一个以O(M2 N)时间执行乘法的程序，其中M≤N。

c.写一个以O(MNlog(MN))时间执行乘法的程序。

d.上面哪个时间界最好？

Python程序将两个多项式相乘，其中多项式的每个项表示为一对整数（系数，指数）？

链表——多项式相乘、相加、求导、相乘

C++多项式相乘

两个多项式相乘

两个多项式相乘求解系数数组算法

计蒜客-多项式相乘

《程序设计实践》第06练——多项式相乘

链表实现多项式相乘-数据结构学习

用c编写一元多项式相乘

多项式相乘 数据结构课程设计

C语言实现两个多项式相加&相减&相乘运算

C C++程序设计 求两个一元多项式相乘的算法.txt

单向链表 练习3.7 多项式相乘

单链表实现多项式的相乘-c语言

多项式相乘一元稀疏多项式简单计算器

C语言实现两个多项式加法与乘法

数据结构__两个多项式乘法运算

数据结构多项式相乘

BUAA(2021春)多项式相乘

A1009 Product of Polynomials（两个多项式相乘）

多项式相乘（链表）

C语言实现多项式相乘

数据结构-多项式相乘.doc

多项式相乘

编程实现若干个多项式相乘。多项式的输入输出格式为：系数在前，指数在后，各项按指数递增排列，每个多项式...

两个多项式相乘

a.给出以O(M²N²)时间求解该问题的算法。

b.写一个以O(M² N)时间执行乘法的程序，其中M≤N。

多项式相乘数据结构课程设计

C C++程序设计求两个一元多项式相乘的算法.txt

单向链表练习3.7 多项式相乘