一元 n 次多项式运算程序

已于 2022-03-15 20:01:52 修改
阅读量1.7k 收藏 20
点赞数 7
分类专栏： Project Code 文章标签： 链表 多项式乘法 数据结构
于 2019-11-28 14:00:18 首次发布
要转载的小可爱麻烦先私信我说明一下哦~~~
本文链接：https://blog.csdn.net/qq_37701948/article/details/103291506
版权

前言：个人实现的一个用带头结点的链表实现的一元 n 次多项式运算程序。该程序支持多项式的创建、打印、加、减、乘以及取反操作。并且具备相应的用户操作菜单，用户提示菜单。其中针对多项式的各种操作已经模块化，并且每一个函数的功能都做了非常详细的注释。话不多说，开始讲解代码。

文章目录

存储结构

链表结点结构体

采用单链表的结点形式来存储多项式的每一个单项式。结构体中定义了单项式的系数和次数，以及指向下一个结点的指针。

typedef struct LNode // 定义单项式结点结构体
{
	double coef; // 系数，全称 coefficient
	int power; // 次数
	struct LNode* next;
} LNode;

全局变量

定义了一个指针数组 List，用以存放指向每一个多项式的头结点的指针；
定义了一个 counter，用来计数多项式的个数。

LNode* List[MaxLen]; // 结点指针数组，存放指向多项式的头结点的指针
int counter = 0; // 全局计数器，计数多项式的个数

程序框架

运行过程

主程序运行过程很简单，总体就分这三步：

  1. 输入多项式的数据
  2. 选择相应的功能
  3. 退出程序

我尽量将所有的单一功能都放在了一个函数中，实现了很大程度上的模块化。这也就可以使得我的主程序代码尽量简单明了，仅仅做的事情就是打印用户菜单。

函数介绍

所有的 head 都是指头结点。

链表（多项式）复制函数

LNode* CopyPolyn(LNode* head);

将以 head 为头结点的链表复制给新的链表 head1，返回新链表的头结点。

  1. 指针 q 指向新链表的开始结点（头结点的后一个结点），指针 p 指向新链表的头结点 head1；
  2. while 循环中，创建新结点 s，将 q 所指结点信息复制给 s，q 后移，然后将 s 插入新链表；
  3. 重复第2步直到 q == NULL；
  4. 返回 head1。

结点（单项式）创建函数

void Creat(LNode* head, double iCoef, int iPower);

依据传入的系数 iCoef 和次数 iPower 创建新的结点，并将其添加到头结点为 head 的链表上。

  1. 定义遍历指针 p 指向开始结点，q 指向 p 的前驱；
  2. while 循环中，依据 p 指向的结点的次数和输入次数的大小来判断操作；

结点在链表中按照次数从小到大排列，所以新结点添加进链表时要做以下操作：

  • 遵循次数从小到大的插入。
  • 有同类项则合并，合并后若为0则删除结点。

链表（多项式）创建函数

void CreatPolynCin();
void CreatPolynIfs();

依据用户的选择，程序执行两种数据加载函数的其中之一。其中前者为读取键盘输入，后者为读取 txt 文本文件输入。txt 文本文件内容我会放在后文中。文本读取函数的具体执行过程用注释标注的非常详细，可以自行理解。

链表（多项式）选择函数

int Choose(int cho[], int len);

智能处理用户操作函数时输入的链表对象，既可以只操作一个链表，也可以操作多个链表。原理是借助一个数组来记录本次操作中用户希望操作的链表对象的头结点指针在数组 LIst 中的下标。

链表（多项式）打印函数

void PrintPolyn(LNode* head);
void ChoosePrint();

调用后者函数，用户输入希望打印的多项式。然后传入相应链表的头结点打印相应的多项式。同时对于输出要做一下格式化的处理。

链表（多项式）相加函数

LNode* AddPolyn(LNode* head1, LNode* head2);
void ChooseAdd();

加法的原理：复制以 head1 为头结点的链表给以 head 为头结点的链表，然后读取 head2 中每一个结点，就像创建链表一样与 head 中的每一个结点进行比较。有同类项则合并，无同类项则插入，有0项则删除。后者函数同理，智能处理用户输入的相加的多项式的对象。

链表（多项式）取反函数

void Opposite(LNode* head);
void ChooseOpposite();

用户选择要取反的对象，程序直接将其取反并打印输出。此函数最多取反一个多项式。

链表（多项式）相减函数

void ChooseSubtract();

该函数实际上是一个减法选择函数，因为多个多项式连续相减可以转换为多个多项式连续相加。只需要将第一个多项式取反，再将最后结果取反即可得到相减的结果。

链表（多项式）相乘函数

LNode* MutPolyn(LNode* head1, LNode* head2);
void ChooseMutiply();

同理，用户选择两个或多个要相乘的多项式，程序会自动处理。乘法的原理也很简单，同样的能化成加法来操作。在这里，我采用的是传统的，即我们平常笔算时用到的多项式乘法规则——项项相乘再相加。感兴趣的同学可以关注我的另一篇博客FFT应用于多项式乘法。这篇博客介绍了如何加快多项式乘法的算法，尤其在面对项数特别大时的情况，有着非常好的优化效果。但是对于项数一千以内的多项式乘法，逐个相乘的效果是要好一点的。

txt文本文件的内容

1.9 2 2 5
5 2 2.5 4
-1.5 2 -2 5 2 4 5 2
5.8 2 -2 4
8 9 5 2 -1 2 -2 5

其实这个你们完全可以自己写的，但是为了方便还是把我自己的，比较完整的测试数据放在这里，请自行取用吧。

完整代码（C++）

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <windows.h>
#define MaxLen 1024
using namespace std;

typedef struct LNode // 定义单项式结点结构体
{
	double coef; // 系数，全称 coefficient
	int power; // 次数
	struct LNode* next;
} LNode;

LNode* List[MaxLen]; // 结点指针数组，存放指向多项式的头结点的指针
int counter = 0; // 全局计数器，计数多项式的个数

// 链表的复制
LNode* CopyPolyn(LNode* head)
{
	/*
	将 head 所在多项式链表复制给head1
	*/
	LNode* q = head->next; // 一定要给下一个结点，否则头结点也会被复制进去
	LNode* head1 = new LNode;
	LNode* p = head1;

	while (q != NULL)
	{
		LNode* s = new LNode;
		s->coef = q->coef;
		s->power = q->power;
		p->next = s;
		p = s;
		q = q->next;
	}
	p->next = NULL;

	return head1;
}


// 创建单项式结点的函数，提高可重用性
void Creat(LNode* head, double iCoef, int iPower)
{
	LNode* p = head->next; // p 是遍历指针
	LNode* q = head; // q 是 p 的前驱

	while (1) // 该循环依据 p 指向的项的次数和输入次数的大小来判断操作
	{
		if (p == NULL || p->power > iPower)
		{
			/*
			如果找到了比输入次数大的项，就新建一个结点插在该项之前
			或者 p 指向了空，说明不存在比输入次数大的项，就在表尾插入新结点
			p == NULL 放在第一个 if 判断，否则在分支判断中会因为读取不到数据出问题
			而且由短路逻辑可知，p == NULL 判断为真后就不再判断后一个，同样不会出问题
			*/
			p = new LNode; // 令 p 指向一个新结点
			p->coef = iCoef;
			p->power = iPower;
			p->next = q->next;
			q->next = p;
			break; // 退出循环，读取下一个输入
		}
		else if (p->power < iPower)
		{ // 如果输入的次数更大则往后比较下一个结点
			p = p->next;
			q = q->next;
		}
		else if (p->power == iPower) // 如果次数一样就合并同类项
		{
			if (p->coef + iCoef == 0) // 如果系数相反就删除结点
			{
				q->next = p->next;
				free(p); // 释放指针 p 指向的结点空间
				p = q->next; // 令 p 指向 q 的后继，为空的话直接退出循环
			}
			else
				p->coef += iCoef;
			break; // 上述无论哪个操作执行完都要退出循环读取下一个输入
		}
	}
}

// 手动输入创建链表
void CreatPolynCin()
{
	int inputPower; // 输入的指数
	double inputCoef; // 输入的系数

	LNode* head = new LNode; // 创建头结点
	head->next = NULL; // 头结点 next 指针初始化

	cin.get(); // 过滤回车
	printf("\t请按照“系数”“次数”的格式输入多项式的各项\n");
	printf("\t注意：仅支持一次输入一个多项式\n\t");

	while (cin.peek() != EOF && cin.peek() != '\n') // 读到文件结尾或者回车时退出循环，按次数从小到大插入新的结点
	{
		cin >> inputCoef >> inputPower;
		Creat(head, inputCoef, inputPower); // 创建新结点并添加到链表上
	}
	List[++counter] = head; // 创建了新链表，计数值+1，并将头指针存入数组 List
	printf("\t成功创建了第%d个多项式\n", counter);
}

// 文本输入创建链表
void CreatPolynIfs()
{
	int i = 0, j, len, flag; // flag 标记是否为负数
	double temp; // temp 存储读到的数
	double input[MaxLen]; // 数组 input 保存多项式的项
	char line[MaxLen]; // 字符串 line 保存每一行的输入
    LNode* head;

	printf("\t正在读取文件，请稍等：\n");
	printf("\t加载中：");
	while ((i += 10) < 100) // 按一定的时间间隔输出字符
	{
		Sleep(300);
		printf("*");
	}
	printf(" 加载完成！\n\n");
	Sleep(1000);

	ifstream file; // 定义输入文本
	file.open("file.txt", ios::in); // 以读方式打开

	while (file.getline(line, MaxLen)) // 逐行读取 MaxLen 个字符，读取到 EOF 时会返回-1结束循环
	{
		for (i = 0, len = 0; line[i] != '\0'; ++i)
		{
			temp = 0, flag = 0;
			if (line[i] >= '0' && line[i] <= '9')
			{
				if (line[i - 1] == '-') // 前面有负号的话标记一下
					flag = 1;
				for (j = i; line[j] != '\0' && line[j] != '.' && line[j] != ' '; ++j) // 开始循环找完整的一个数
				{ // 循环结束的条件是读到了字符串的终止符或小数点或空格
					temp = temp * 10 + line[j] - '0';
				}
				if (line[j] == ' ') // 读到空格说明该数读完了，把 j - 1 赋给 i 跳过已遍历过的字符
					i = j - 1;
				if (line[j] == '.') // 如果读到了小数点
				{
					double num = 0, point = 0; // num 记录小数部分，point 记录小数数位
					for (j += 1; line[j] != '\0' && line[j] != ' '; ++j) // j += 1 表示挪到小数第一位
					{ // 由于已经读到了小数点，所以循环结束的条件是读到了字符串的终止符或空格
						num = num * 10 + line[j] - '0';
						++point;
					}
					temp += num / pow(10, point); // 将 num 转为小数加到 temp 上
					i = j - 1;
				}
				flag ? input[len++] = -1 * temp : input[len++] = temp;
			}
		}

		head = new LNode; // 每次都要让 head 指向新创建的结点，否则创建的所有链表都一样了
        head->next = NULL; // 头结点 next 指针初始化
		for (i = 0; i < len; i += 2) // 每两个相邻元素取出来作为一个项创建新结点
			Creat(head, input[i], (int)input[i + 1]); // 别忘记转换类型，不用担心丢失精度，次数是整数
		List[++counter] = head;
		printf("\t成功创建了第%d个多项式\n\n", counter);
	}
}


// 选择要操作的链表序号
int Choose(int cho[], int len)
{
	while (cin.peek() != '\n')
	{
		cin >> cho[len];
		if (cho[len] <= 0 || cho[len] > counter)
		{
			printf("\t您输入了不存在的%d号多项式！\n", cho[len]);
			cin.sync(); // 如果不存在的多项式后仍然有输入，sync 函数将清空它们以免读取进了用户操作
			return 0;
		}
		else
			++len;
	}

	return len;
}


// 多项式打印
void PrintPolyn(LNode* head)
{
	LNode* p = head->next;

	while (p != NULL)
	{
		// 因为次数递增，因此次数为0的情况只可能发生在第一个结点上，后面就无需判断次数是否为0
		if (p->power == 0) // 常数项直接输出
			printf("\t%.1lf", p->coef);
		else
		{
			if (p->coef > 0 && p != head->next) // 如果系数大于0且不是首项
				printf(" + %.1lfx^%d", p->coef, p->power);
			else if (p->coef < 0 && p != head->next) // 如果系数小于0且不是首项
				printf(" - %.1lfx^%d", -1 * p->coef, p->power);
			else // 如果是首项直接输出
				printf("\t%.1lfx^%d", p->coef, p->power);
		}
		p = p->next;
	}
	printf("\n\n");
}

// 用户选择要打印的多项式
void ChoosePrint()
{
	int snum[MaxLen] = {0}; // 序号，全称 serial number
	int serNum = 0;
	cin.get();
	printf("\t请输入您要打印的多项式的序号\n\t");
	serNum = Choose(snum, serNum);

	for (int i = 0; i < serNum; ++i)
	{
		printf("\t第%d个多项式是:", snum[i]);
		PrintPolyn(List[snum[i]]);
	}
	if (!serNum)
        return;
}

// 多项式相加
LNode* AddPolyn(LNode* head1, LNode* head2)
{
	/*
	加法原理：
	复制 head1 链表给 head
	将 head2 中的每个结点读入 head 中
	*/
	LNode* p, * head; // head 指向新链表的头结点
	p = head2->next; // q 指向 head2 头结点的后继结点
	head = CopyPolyn(head1);

	while (p != NULL)
	{
		Creat(head, p->coef, p->power);
		p = p->next;
	}
	return head;
}

// 用户选择要相加的多项式
void ChooseAdd()
{
	int add[MaxLen] = { 0 };
	int addNum = 0; // 计录参与相加的多项式个数，标记是否输入错误的标志

	cin.get();
	printf("\t请输入参与相加的多项式序号\n\t");
	addNum = Choose(add, addNum);
	if (!addNum)
        return;

	LNode* addHead = List[add[0]]; // 新建好和式链表头结点并初始化以便参与迭代
	for (int i = 1; i < addNum; ++i) // 逐个相加
		addHead = AddPolyn(addHead, List[add[i]]); // 迭代
	/*
	如果相加后的结果只有一个常数，就要存入一个系数次数都为0的结点
	而创建结点和相加函数要经常调用，因此不适合在它们内部放入这个操作
	*/
	if (addHead->next == NULL)
	{
		LNode* s = new LNode;
		s->coef = 0;
		s->power = 0;
		s->next = NULL;
		addHead->next = s;
	}
	List[++counter] = addHead;
	printf("\t相加后的结果是(第%d个多项式)：\n", counter);
	PrintPolyn(addHead);
}


// 多项式取反
void Opposite(LNode* head)
{
	LNode* p = head;
	while (p != NULL)
	{
		p->coef *= -1;
		p = p->next;
	}
}

// 用户选择取反的多项式
void ChooseOpposite()
{
	int oppoNum;
	printf("\t请输入要取反的多项式序号\n\t");
	cin >> oppoNum;
	if (oppoNum > counter || oppoNum <= 0)
		printf("\t您要取反的多项式不存在!\n");
	else
	{
		Opposite(List[oppoNum]);
		printf("\t取反后的结果是\n");
		PrintPolyn(List[oppoNum]);
	}
}


// 用户选择要相减的多项式并执行多项相减
void ChooseSubtract()
{
	int sub[MaxLen] = { 0 };
	int subNum = 0, flag = 0; // subNum 计数相减的多项式的个数，flag 标记是否输入错误的标志

	cin.get();
	printf("\t请输入参与相减的多项式序号\n\t");
	subNum = Choose(sub, subNum);
	if (!subNum) // 返回0表明输入序号异常，退出该操作
		return;

	LNode* subHead = CopyPolyn(List[sub[0]]);

	Opposite(subHead); // 先取一次反
	for (int i = 1; i < subNum; ++i) // 逐个相加
		subHead = AddPolyn(subHead, List[sub[i]]);
	Opposite(subHead); // 对最后的结果再取一次反就得到最终结果

	if (subHead->next == NULL)
	{
		LNode* s = new LNode;
		s->coef = 0;
		s->power = 0;
		s->next = NULL;
		subHead->next = s;
	}
	List[++counter] = subHead;
	printf("\t相减后的结果是(第%d个多项式)：\n", counter);
	PrintPolyn(subHead);
}


// 多项式相乘
LNode* MutPolyn(LNode* head1, LNode* head2)
{
	LNode* head = new LNode;
	head->next = NULL;
	LNode* p = head1->next;
	LNode* q = head2->next;
	while (p != NULL)
	{
		q = head2->next; // 每次循环都初始化q指向开始结点
		while (q != NULL)
		{
			Creat(head, p->coef * q->coef, p->power + q->power);
			q = q->next;
		}
		p = p->next;
	}
	return head;
}

// 用户选择要相乘的多项式
void ChooseMutiply()
{
	int mut[10] = { 0 };
	int mutNum = 0; // 计录参与相乘的多项式个数

	cin.get();
	cout << "\t请输入参与相乘的多项式序号\n\t";
	mutNum = Choose(mut, mutNum);
	if (!mutNum) return;

	LNode* mutHead = List[mut[0]]; // 新建好和式链表头结点并初始化以便参与递归
	for (int i = 1; i < mutNum; i++) // 逐个相加
		mutHead = MutPolyn(mutHead, List[mut[i]]); // 迭代
	List[++counter] = mutHead;

	cout << "\t相乘后的结果是(第" << counter << "个多项式)：" << endl;
	PrintPolyn(mutHead);
}


// 根据用户选择执行操作
void Operation(int choice)
{
	switch (choice)
	{
	case 1:
		printf("\t请问您要手动输入还是文本输入？\n");
		printf("\t1.我不怕累！我要手动输入！\n");
		printf("\t2.手太酸了，文本输入吧...\n\t");
		int c;
		cin >> c;
		if (c == 1)
			CreatPolynCin();
		else
			CreatPolynIfs();
		break;
	case 2:
		ChoosePrint();
		break;
	case 3:
		ChooseAdd();
		break;
	case 4:
		ChooseSubtract();
		break;
	case 5:
		ChooseMutiply();
		break;
	case 6:
		ChooseOpposite();
		break;
	case 7:
		printf("\t我说您是男神没意见吧？\n");
		exit(0);
	case 8:
		printf("\t我就知道您会瞎选，嘿嘿\n");
		break;
	default:
		printf("\t抱歉该选项功能还未开发！请重新输入！\n");
		break;
	}
}


// 主函数入口
int main(void)
{
	int choice;
	printf("\t\t程序初始化成功!\n");
	printf("\t\t  欢迎您!\n");

	while (1)
	{
		printf("\t*******************************\n");
		printf("\t***  请选择您要执行的操作   ***\n");
		printf("\t***      1.创建多项式       ***\n");
		printf("\t***      2.打印多项式       ***\n");
		printf("\t***      3.多项式相加       ***\n");
		printf("\t***      4.多项式相减       ***\n");
		printf("\t***      5.多项式相乘       ***\n");
		printf("\t***      6.多项式取反       ***\n");
		printf("\t***       7.退出程序        ***\n");
		printf("\t*******************************\n");
		printf("\t");
		cin >> choice;
		Operation(choice);
	}

	return 0;
}

希望本篇博客能对你起到一点的帮助作用，也希望能动动小手点个赞哟~~。

SakuraMay_Ai
关注
  • 7
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一元稀疏多项式加法运算实验报告
12-07
* 输入两个稀疏的一元 n 次多项式 * 计算两个多项式的和 * 输出和多项式 多项式相加的运算规则为： * 对于两个一元多项式中指数相同的子项，对应的系数相加，若和非零，将其构成和多项式中的一项 * 对于两个一元...
基于单链表实现一元n次多项式的创建、输出和求和操作
DX奥特曼的博客
12-29 7101
在主函数中调用函数CreatePolyn ()函数创建两个多项式： 2 + 3X + 5X3 + 2X4 3 + 2X + 4X2 然后调用函数AddPolyn求它们的和，最后打印出求和后的结果。 提示： /*①多项式数据结构定义*/ typedef  struct pnode{       float coef;                 //系数       int
数据结构学习笔记——单链表实现多项式加法
zzh
10-29 529
一元n次多项式的加法（单链表实现） 下面展示一些 代码。 首先是单链表结构体的定义 typedef struct LNode { int Base_number; int Index_number; struct LNode *Next; }LNode,*LinkList; typedef 将 struct LNode 的名字重定义成 LNode，将指向LNode的指针重定义成LinkList。 以下是用到的一些函数。 void Creat(LinkList &polynom
单链表实现多项式的表示及加减运算
qq_45929428的博客
04-08 1484
多项式运算多项式加法：多项式减法:运行实例 多项式的表示及运算 [问题描述] 设计一个算法，以实现一元稀疏多项式的加法运算。 [基本要求] （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列：n，c1，e1，c2，e2，……，cn，en，其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列； （3）多项式a和b相加，建立多项式a+b。 [测试数据] 由学生任意指定。 [实现提示] 　　用带表头结点的单链表存储多项式。 [选作内容] 　　多项式a和b相减，建立多项式a-b。
数据结构-多项式的基本操作（链表实现）
BH04250909的博客
04-07 1905
#include<iostream> #include<malloc.h> using namespace std; #define MAX 100 typedef struct { double coef; //系数 int exp; //指数 }PolyArray; //存放多项式的数组类型 typedef struct pnode { double coef; //系数 int exp; //指数 struct pnode* next; }PolyNod.
数据结构 C 代码 2.5:【链表】10的阶乘&多项式的加法 链表基本应用题
qq_61649579的博客
05-06 465
思考与理解： 代码补充：老师的结果之后还会有一个“+”不够美观，此处加了判断，消去式子后多余的加号。打印提示改为了中文，便于查看。 老师代码的巧妙：虽然只写了几个测试用例，但是测试用例覆盖了所有方法的所有内容，运用了特殊值，一般值对算法进行检验。相加后进行了判断不会留下0*x^n这样系数为0的无用项。 学习目标： 学习链表，做出题目：多项式的加法是链表的基本应用, 也有助于理解压缩表示. 学习指导：帆神的代码 学习任务： 抄写代码 学习成果目录 1定义结构体 2操作方..
一元n次多项式(polynomial)数据结构的（实现利用重载的）
11-25
一元n次多项式是由n个系数与n+1个变量的幂次组合而成的数学表达式，例如 `a_n*x^n + a_{n-1}*x^{n-1} + ... + a_1*x + a_0`。在这个项目中，我们将实现这个概念，以便在程序中进行多项式的创建、表示和操作。 首先...
一元多项式的运算
06-24
在计算机科学中，一元多项式是一类基本的数学对象，通常表示为 \(a_nx^n + a_{n-1}x^{n-1} + \cdots + a_1x + a_0\) 的形式，其中 \(a_n, a_{n-1}, \ldots, a_0\) 是常数，\(x\) 是变量。这些常数被称为多项式的系数...
c#版一元多项式四则运算程序
04-19
在C#编程环境中，一元多项式四则运算程序是一个基于数据结构的项目，它涉及到计算机科学中的核心概念，如线性表、类的设计以及算法的实现。这个程序的目的是处理一元多项式（仅含一个变量的数学表达式）的加、减、乘...
jsq.rar_多项式运算
09-24
在IT领域，尤其是在计算机科学和软件工程中，一元多项式运算是一种基本的数学操作，它们经常被用于数据处理和算法设计。本文将深入探讨如何使用C语言来实现一元多项式运算，以及如何通过提供的"计算器.cpp"文件进行...
C语言练习（2）——链表实现多项式加法
AZ10000000的博客
04-21 4574
文章目录前言一、题目描述二、解题思路三、代码展示1.SL.h（1）引用函数库（2）定义链表（3）声明接口函数2.SL.c（1）创建带头单链表（2）创建节点（3）头插（4）链表排序（5）节点合并(合并同类项)（6）链表求和（7）链表打印3.test.c四、运行检验总结（求赞:kissing_heart:） 前言 兄弟们，每日一题，怡情悦兴 使用链表来实现多项式的加法。 这本该是数据结构中最为简单的试题，菜的抠脚的我敲了半个下午。。。😠 警醒：多练习！多思考！ 切勿：走马观花，浅尝辄止！ 一、题目描述 成
[数据结构]一元n次多项式的抽象数据类型
weixin_34161083的博客
02-09 997
一、问题描述 一元n次多项式是代数学中经常出现的代数式，对于一元n次多项式的操作有很重要的实际意义。由于一个一元n次多项式最多有n+1项，且互不相关，所以可以用一个线性表来保存一个多项式，从前至后次数递增。对于一个一元n次多项式，我们可以定义操作：多项式的加法、减法、乘法。 本次小作业采用了链式表示的线性表实现，且只实现了多项式的加法。我认为如果要实现多项式的乘法，顺序表示的线性表更合适。 ...
学习数据结构的第一周（用链表实现简单的一元N次多项式相加）
qq_50133663的博客
09-13 664
一元多项式的相加，小白之作，只是简单的实现了一元N次多项式的相加（相乘的话都是差不多的原理，就没有想写的欲望了，摊手）。（只是记录，没有任何教学意义） 其实刚开始是使用数组实现的，但是感觉数组味道还是太浓了，和链表不太搭边，于是开始用真正的链表来实践，因为还要上课，所以断断续续写了3天，刚开始是没想写这么多的，结果发现实现一个功能就要先得到另一个数据，这就又要写一个函数来实现，所以写到最后子函数暴多还乱的离谱，最后也就是到可以让结果按指数由大到小的排列方式输出，同类项也没有...
数据结构与算法（ｅｄｕｃｏｄｅｒ作业）
m0_51622088的博客
05-16 3615
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、栈二、使用步骤1.引入库栈——实验及提升训练 前言 数据结构与算法（Ｃ语言）头歌平台 一、栈 顺序表 关卡一　第1关 求顺序线性表中连续子表（最少有一个元素）的最大和 #include <stdio.h> #include <stdlib.h> /*此处是顺序线性表数据结构定义*/ typedef int DataType; struct seqList {//有3个数据成员 int MAX.
一元多项式计算器（C语言实现）
最新发布
qq_62225979的博客
01-17 2743
数据结构线性表的链式存储的一个实验 用C语言实现了一元多项式的加、减、乘、求导、求值运算
求解n次函数多项式之拉格朗日插值
Coldfresh的博客
08-21 7129
设F(x)=a0+a1x+a2x2+...+anxnF(x)=a0+a1x+a2x2+...+anxnF(x)=a_0+a_1x+a_2x^2+...+a_nx^n 在一些题目中例如找规律，比如是我上次在区域赛的时候如果可以真名或者猜出一些式子是多项式，还有次数，那么我用的待定系数法，就可以解方程来做了。 可以直接手动解，但是也可以借助程序了。 这里就用到了一个东西叫拉格朗日插值法。 假如...
MATLAB多项式计算
热门推荐
路遥芝麻的博客
08-23 1万+
MATLAB多项式计算 在MATLAB中，n次多项式用一个长度为n+1的行向量表示（因为是n个幂次项系数加上一个常数项），缺少的幂次项系数为0。 例如 n次多项式： P(x)=anxn+an-1xn-1+an-2xn-2+…+a1x+a0 表示为： [an,an-1,an-2,…,a1,a0] 目录MATLAB多项式计算1.多项式的加减运算2.多项式的乘法运算3.多项式的除法运算4.多项式的导函数5.代数多项式求值6.矩阵多项式求值7.多项式求根 1.多项式的加减运算 事实上，多项式的加减运算就是其所对应的
一元n次多项式的处理
BanRuo_Cheng的博客
05-01 3646
题目描述：一元n次多项式的处理 问题描述：符号处理是一类非数值性问题，一元多项式就是符号处理的一类实例。一个一元n次多项式的一般形式如下： Pn(x)=p1xe1+p2xe2+…各+pmxem 其中p1,p2,…, pm为项的系数，非零； e1,e2,…, em 为各项的指数，满足0£e1£e2 £... £em     现要求在计算机中存储这样的多项式，并能对它们进行处理，如：
第8周笔记4-求解n项多项式的值(递归实现)
weixin_41297324的博客
10-31 373
求解n项多项式的值 求解n项多项式的值 Pn(x)=1,当n=0 Pn(x)= x,当n=1 Pn(x)=(2*n-1)*Pn-1(x)-(n-1)*Pn-2(x),当n>=2 /* 求解n项多项式的值 Pn(x)=1,n=0 x,n=1 (2*n-1)*Pn-1(x)-(n-1)*Pn-2(x),n>=2 */ #include<stdio.h...
一元多项式的加减求导运算算法(数据结构算法) (2).docx
10-30
在数据结构和算法领域，一元多项式运算是一种常见的问题，涉及到线性代数和计算机科学的基础知识。在本文档中，作者讨论了如何设计一个简单的一元稀疏多项式运算器，支持加减运算以及求导。以下是对文档中提及的知识...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值