数据结构第一次实验

最新推荐文章于 2023-05-22 15:55:06 发布
最新推荐文章于 2023-05-22 15:55:06 发布
阅读量1.2k 收藏 21
点赞数 3
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/besonn/article/details/105238019
版权

实验题目：多项式加法问题
实验目的：设计一个一元稀疏多项式简单计算器。实验内容与要求 一元稀疏多项式简单计算器的基本功能是： （1)输入并建立多项式； （2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,…,cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列。 （3）多项式a与多项式b相乘，建立多项式。

实验思路：

最朴素的想法就是用两个数组来表示一个多项式，一个数组存放指数，另一个存放系数，下标相同代表同一项。当实现加法时，就需要寻找指数相同的项进行相加，把得到的结果存入另外一个数组当中去。当实现乘法是，我们就循环遍历两个式子，让他们每个项之间两两相乘，结果保存在另外一个数组中。

然而注意到是一元稀疏多项式，也就是可能存在这样的式子
f ( x ) = 10 x 1000 + 6 x 2 f(x) = 10x^{1000}+6x^{2} f(x)=10x1000+6x2
那么我们必须至少用长度为1000的数组来存储，并且其中大多数数组的元素为零。这样算法的空间复杂度很高也很浪费。

因此决定使用链表这一数据结构来表示。

默认多项式一的长度为n，多项式二的长度为m。

实验步骤：

第一步：建立存储的链表

第一步我们需要定义一个链表，里面保存每一项的系数和指数。并且分别定义两个这样的链表，来表示需要相加的两个多项式。

实验代码

struct  PolyNode
{
	float coef; // 指数，考虑小数的情况
	int expon; // 次数
	struct PolyNode *link; // 后继节点
};
typedef struct PolyNode *Polynomial;
Polynomial p1, p2; //代表输入的两个多项式

第二步：明确读入数据并保存

我们的思路是，对于每个需要读入的多项式，首先读入项数。接着，按照指数的高低，分别读入。

专门写了一个ReadPoly（）函数用来读取多项式

实验代码

Polynomial ReadPoly(int n1)
{
	Polynomial P, rear, t;
	P = (Polynomial)malloc(sizeof(struct PolyNode));
	P->link = NULL;
	rear = P;
	for (int i = 1; i <= n1; i++)
	{
		float c; int f;
		printf("第%d项系数：", i); // 输入第i项系数
		scanf("%f", &c);
		printf("第%d项次数：", i); // 输入第i项次数
		scanf("%d", &f);
		Attach(c, f, &rear); // 链接成链表
	}
	t = P; P = P->link;
	free(t);
	return P;
}

时间复杂度
O ( N + M ) O(N+M) O(N+M)

指针P 用来保存多项式的结果。如何将输入的每一组系数和指数联系起来，我们则需要用一个Attach函数去完成。

第三步：将读入的系数和指数连接起来

写一个Attach 函数，新开辟一个节点，将指数和系数保存到节点当中，再将节点连接到rear链表的后面。

实验代码

void Attach(int c, int e, Polynomial *pRear)
{
	Polynomial p;
	p = (Polynomial)malloc(sizeof(struct PolyNode)); // 开辟新节点
	p->coef = c;  // 系数
	p->expon = e; // 次数
	p->link = NULL;
	(*pRear)->link = p;
	*pRear = p;
}

第四步：进行排序

我们默认输入是随机的，可以不按照次数降序排列。因此需要一个排序的函数进行排序。

实验代码

Polynomial Sort(Polynomial pHead)//链表排序
{
	Polynomial P = pHead;
	Polynomial p = NULL;
	Polynomial q = NULL;
	int temp;
	float tmp2;
	// 冒泡排序
	for (p= pHead; p != NULL; p = p->link)
	{
		for (q = p->link; q != NULL; q = q->link)
		{
			if (p->expon < q->expon)
			{
				// 分别交换系数和次数
				temp = p->expon; 
				tmp2 = p->coef;
				p->expon = q->expon;
				p->coef = q->coef;
				q->expon = temp;
				q->coef = tmp2;
			}
		}
	}
	return pHead;
}

时间复杂度
O ( N M ) O(NM) O(NM)

第四步：进行相加

我们使用PolyAdd() 函数进行相加。逻辑如下：

首先开辟一个新的链表用来保存相加之后的结果。
比较两个多项式的每一项，如果相同就进行系数相加并且存入新的链表。如果第一个的指数大，那么第二个就向后移动一个；如果第一个的指数小，那么第一个就向后移动一个。

只要当p1和p2任何一个为空时，那么比较就结束，p1或p2剩余没有比较的部分就自动存到p3后面。

其中，Compare函数是用来比较次数的大小，如果相同，返回0；如果前者大返回1，后者大返回-1.
实验代码

Polynomial PolyAdd(Polynomial p1, Polynomial p2)
{
	Polynomial Front, rear, temp;
	float sum;
	rear = (Polynomial)malloc(sizeof(struct PolyNode));
	Front = rear;
	while (p1&&p2) // 比较条件，都不为空
	{
		switch (Compare(p1->expon, p2->expon)) { // Compare 来比较大小
		case 1:
			Attach(p1->coef, p1->expon, &rear);
			p1 = p1->link; // 前者比较大的情况
			break;
		case -1:
			Attach(p2->coef, p2->expon, &rear);
			p2 = p2->link; // 后者比较大的情况
			break;
		case 0:
			sum = p1->coef + p2->coef;
			if (sum) Attach(sum, p1->expon, &rear); // 相加
			p1 = p1->link;
			p2 = p2->link;
			break;
		}
	}
	for (; p1; p1 = p1->link) Attach(p1->coef, p1->expon, &rear); // 保存剩余项
	for (; p2; p2 = p2->link) Attach(p2->coef, p2->expon, &rear); // 保存剩余项
	rear->link = NULL; // 最后为空
	temp = Front;
	Front = Front->link;
	free(temp);
	return Front;
}

时间复杂度
O ( m a x ( N , M ) ) O(max(N,M)) O(max(N,M))

第五步：进行相乘

与加法类似，首先开辟一个新的链表用来保存相乘之后的结果。

但是我们需要用两层循环，使得两个多项式中的每一项两两相乘运算。

最后将结果保存。

实验代码

Polynomial PolyMulti(Polynomial p1, Polynomial p2)
{
	Polynomial front, rear, temp;
	front = rear = (Polynomial)malloc(sizeof(struct PolyNode));
	Polynomial t1, t2;
	float product_coef; int product_expon;
	if (!p1 || !p2) return NULL;
	// 令每一项相乘
	for (t1 = p2; t1; t1 = t1->link)
	{
		for (t2 = p1; t2; t2 = t2->link)
		{
			product_coef = (t1->coef)*(t2->coef);
			product_expon = (t1->expon) + (t2->expon);
			Attach(product_coef, product_expon, &rear);
		}
	}
	temp = front;
	front = front->link;
	free(temp);
	return front;
}

时间复杂度
O ( N M ) O(NM) O(NM)

第六步：输出

输出就非常简单了，重点是输出的格式问题。我是将格式统一为
c o e f e x p o n coef \quad expon coefexpon
直接看代码吧

相加输出代码

while (p3!=NULL)
{
	printf("%.2f * x^%d", p3->coef, p3->expon);
	p3 = p3->link;
	if (p3 != NULL && p3->coef > 0)
		printf("+");
}

时间复杂度
O ( N + M ) O(N+M) O(N+M)
相乘输出代码

为了将次数一样的项合并，乘法的输出稍微复杂一点

    float C = p4->coef;
	int E = p4->expon;
	p4 = p4->link;
	if(p4==NULL)
		printf("%.2f*x^%d ", C, E);
	while (p4 != NULL)
	{
		int flag = 0;
		while (p4->expon == E && p4!=NULL)
		{
			C += p4->coef;
			if(p4->link!=NULL)
				p4 = p4->link;
			flag++;
		}
		printf("%.2f * x^%d ", C,E);
		C = p4->coef;
		E = p4->expon;
		p4 = p4->link;
		if (p4 != NULL && p4->coef > 0)
			printf("+");
		if(!p4)
			if (C>0)
				printf("+ %.2f * x^%d ", C, E);
			else
				printf("%.2f * x^%d ", C, E);
	}

时间复杂度

O ( N M ) O(NM) O(NM)

时间复杂度分析

假设多项式一的项数是 n n n，多项式二的项数是 m m m。由于我的程序各个部分的函数都是独立的，没有什么嵌套的关系，因此时间复杂度就是各部分时间复杂度最大的那个。在本程序里，时间复杂度最高的就是排序和相乘的 O ( N M ) O(NM) O(NM)，然而当输入是按照从高到低的次数进行输入的时候，排序的时间复杂度就可以降到 ( N ) (N) (N)

相乘的每两项相乘是不可避免的，因此本实验的时间复杂度为

O ( N M ) O(NM) O(NM)

运行截图

测试1：

多项式1：

f ( x ) = x 6 + 2 x 3 − 7 x 2 + 2 f(x) = x^6+2x^3-7x^2+2 f(x)=x6+2x3−7x2+2

多项式2：

f ( x ) = 3 x 4 − 4 x 3 + 2 x − 7 f(x) = 3x^4-4x^3+2x-7 f(x)=3x4−4x3+2x−7

结果：
相加

f ( x ) = x 6 + 3 x 4 − 2 x 3 − 7 x 2 + 2 x − 5 f(x) = x^6+3x^4-2x^3-7x^2+2x-5 f(x)=x6+3x4−2x3−7x2+2x−5
相乘

f ( x ) = 3 x 10 − 4 9 + 8 x 7 − 36 x 6 + 28 x 5 + 10 x 4 − 36 x 3 + 49 x 2 + 4 x − 14 f(x) = 3x^{10}-4^9+8x^7-36x^6+28x^5+10x^4-36x^3+49x^2+4x-14 f(x)=3x10−49+8x7−36x6+28x5+10x4−36x3+49x2+4x−14

测试结果：
在这里插入图片描述

测试2：

多项式1：
f ( x ) = 20 x 1000 − 7 f(x) = 20x^{1000}-7 f(x)=20x1000−7
多项式2：
f ( x ) = x 2 + 1 f(x) = x^2+1 f(x)=x2+1
结果：
相加
f ( x ) = 2 0 1000 + x 2 − 6 f(x) = 20^{1000}+x^2-6 f(x)=201000+x2−6
相乘
f ( x ) = 2 0 1002 + 2 0 1000 − 7 x 2 − 7 f(x) = 20^{1002}+20^{1000} -7x^2-7 f(x)=201002+201000−7x2−7

测试结果：
在这里插入图片描述
测试3：

多项式1：
f ( x ) = 0.2 x 2 + 0.1 x 1 f(x) = 0.2x^{2}+0.1x^1 f(x)=0.2x2+0.1x1
多项式2：
f ( x ) = 0.4 x 2 + 0.6 x 1 f(x) = 0.4x^2+0.6x^1 f(x)=0.4x2+0.6x1
结果：
相加
f ( x ) = 0.6 x 2 + 0.7 x 1 f(x) = 0.6x^{2}+0.7x^1 f(x)=0.6x2+0.7x1
相乘
f ( x ) = 0.08 x 4 + 0.16 x 3 + 0.06 x 2 f(x) = 0.08x^4+0.16x^3+0.06x^2 f(x)=0.08x4+0.16x3+0.06x2

测试结果：
在这里插入图片描述

心得体会

本次实验完成了稀疏多项式的乘法和加法，主要用了链表的操作和运算。在本次实验中，我学会了如何分析时间复杂度，让程序的运行效率更好；还学会了如何链表这一数据结构内在的层次逻辑，如何链接链表等等。对于链表而言，判断是否为空是非常重要的，如果没有判断链表为空会出现一定的错误，或者程序报错。

附录：完整代码

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

struct  PolyNode
{
	float coef;
	int expon;
	struct PolyNode *link;
};
typedef struct PolyNode *Polynomial;
Polynomial p1, p2;
int num = 0;
void Attach(float c, int e, Polynomial *pRear)
{
	Polynomial p;
	p = (Polynomial)malloc(sizeof(struct PolyNode));
	p->coef = c;
	p->expon = e;
	p->link = NULL;
	(*pRear)->link = p;
	*pRear = p;
}
int Compare(int c1, int c2)
{
	if (c1 == c2)
		return 0;
	if (c1 > c2)
		return 1;
	else
		return -1;
}
Polynomial PolyAdd(Polynomial p1, Polynomial p2)
{
	Polynomial Front, rear, temp;
	float sum;
	rear = (Polynomial)malloc(sizeof(struct PolyNode));
	Front = rear;
	while (p1&&p2)
	{
		switch (Compare(p1->expon, p2->expon)) {
		case 1:
			Attach(p1->coef, p1->expon, &rear);
			p1 = p1->link;
			break;
		case -1:
			Attach(p2->coef, p2->expon, &rear);
			p2 = p2->link;
			break;
		case 0:
			sum = p1->coef + p2->coef;
			if (sum) Attach(sum, p1->expon, &rear);
			p1 = p1->link;
			p2 = p2->link;
			break;
		}
	}
	for (; p1; p1 = p1->link) { Attach(p1->coef, p1->expon, &rear); }
	for (; p2; p2 = p2->link) { Attach(p2->coef, p2->expon, &rear); }
	rear->link = NULL;
	temp = Front;
	Front = Front->link;
	free(temp);
	return Front;
}
Polynomial PolyMulti(Polynomial p1, Polynomial p2)
{
	Polynomial front, rear, temp;
	front = rear = (Polynomial)malloc(sizeof(struct PolyNode));
	Polynomial t1, t2;
	float product_coef;
	int product_expon;
	if (!p1 || !p2) return NULL;
	for (t1 = p2; t1; t1 = t1->link)
	{
		for (t2 = p1; t2; t2 = t2->link)
		{
			product_coef = (t1->coef)*(t2->coef);
			product_expon = (t1->expon) + (t2->expon);
			Attach(product_coef, product_expon, &rear);
		}
	}
	temp = front;
	front = front->link;
	free(temp);
	return front;
}
Polynomial ReadPoly(int n1)
{
	Polynomial P, rear, t;
	P = (Polynomial)malloc(sizeof(struct PolyNode));
	P->link = NULL;
	rear = P;
	for (int i = 1; i <= n1; i++)
	{
		float c; int f;
		printf("第%d项系数：", i);
		scanf("%f", &c);
		printf("第%d项次数：", i);
		scanf("%d", &f);
		Attach(c, f, &rear);
	}
	t = P; P = P->link;
	free(t);
	return P;
}


Polynomial Sort(Polynomial pHead)//链表排序
{
	Polynomial P = pHead;
	Polynomial p = NULL;
	Polynomial q = NULL;
	int temp;
	float tmp2;
	for (p= pHead; p != NULL; p = p->link)
	{
		for (q = p->link; q != NULL; q = q->link)
		{
			if (p->expon < q->expon)
			{
				temp = p->expon;
				tmp2 = p->coef;
				p->expon = q->expon;
				p->coef = q->coef;
				q->expon = temp;
				q->coef = tmp2;
			}
		}
	}
	return pHead;
}

int main()
{
	int n1, n2;
	Polynomial p5 = NULL;
	Polynomial p6 = NULL;
	Polynomial p7 = NULL;
	printf("请输入多项式1的项数：\n");
	scanf("%d", &n1);
	printf("请分别输入多项式1的系数和次数:\n");
	p1=ReadPoly(n1);
	p1 = Sort(p1);
	p5 = p1;
	printf("请输入多项式2的项数：\n");
	scanf("%d", &n2);
	printf("请分别输入多项式2的系数和次数:\n");
	p2=ReadPoly(n2);
	p2 = Sort(p2);
	p6 = p2;
	Polynomial p3 = NULL;
	Polynomial p4 = NULL;
	p3 = PolyAdd(p1, p2);
	p7= PolyMulti(p5, p6);
	p4 = Sort(p7);
	while (p3!=NULL)
	{
		num++;
		p3 = p3->link;
	}
	p3 = PolyAdd(p1, p2);
	printf("\n相加之后的多项式项数为:%d \n", num);
	printf("\n相加之后的多项式为：\n");
	while (p3!=NULL)
	{
		printf("%.2f %d ", p3->coef, p3->expon);
		p3 = p3->link;
	}
	printf("\n相乘之后的多项式：\n");
	float C = p4->coef;
	int E = p4->expon;
	p4 = p4->link;
	if(p4==NULL)
		printf("%.2f %d ", C, E);
	while (p4 != NULL)
	{
		int flag = 0;
		while (p4->expon == E && p4!=NULL)
		{
			C += p4->coef;
			if(p4->link!=NULL)
				p4 = p4->link;
			flag++;
		}
		printf("%.2f %d ", C,E);
		C = p4->coef;
		E = p4->expon;
		p4 = p4->link;
		if(!p4)
			printf("%.2f %d ", C, E);
	}
}
LIA_7
关注
  • 3
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
西南交通大学数据结构第一次实验报告
10-17
从键盘输入数据，建立两个线性表；输出建好的这两个线性表；将这两个线性表的公共元素（交集）按由小到大次序创建第3个线性表；输出第3个有序的线性表。 要求：(1) 重复的公共元素在第3个有序线性表中只保存一个副本； (2) 用顺序表和链表两种存储结构分别实现上述功能； (3) 分析算法时间复杂度（假定1，2两个线性表的长度分别为m和n）。 从键盘实现数据输入与输出，格式自拟；要求完成两个同样功能的程序，一个程序采用顺序存储结构，另一个程序采用链表实现线性表的存储。
数据结构第一次实验报告.doc
10-06
数据结构第一次实验报告.doc
哈工大 数据结构 第一次实验 后缀表达式
11-03
哈工大 数据结构 第一次实验 后缀表达式
数据结构第一次实验.docx
07-11
数据结构第一次实验全文共5页，当前为第1页。数据结构第一次实验全文共5页，当前为第1页。数据结构第一次实验实验报告 数据结构第一次实验全文共5页，当前为第1页。 数据结构第一次实验全文共5页，当前为第1页。 2017211308班 2017211338 张杰 写实验报告 2017211308班 2017211326 于子涵 写主要程序 2017211308班 2017211346 赵灿坤 后期数据测试及修改 需求分析 我们的程序是一个检验程序，为的是做一个类似于猴子选大王的程序测试，使主人公能苟活到最后一个去参加任务。 我们会输入三个数据 分别是， 人数 ，起始的编号 ，以及每次需要数的个数。那么依据我们的输入可以能够验证最后留下的一个是谁。从而可以让加里森确定应该从哪儿去数这个数。 概要设计 //采用双向链表+节点删除的方法完成 #include<iostream> //输入输出控制函数的头文件 class Group //模拟组的 类 { private: class member //成员类 { public: int number;//编号 member* next_memb
数据结构第一次实验.ipynb
10-16
数据结构第一次实验.ipynb
c一元稀疏多项式计算器-课程设计实验报告.pdf
10-30
c一元稀疏多项式计算器-课程设计实验报告.pdfc一元稀疏多项式计算器-课程设计实验报告.pdf
数据结构第一次实验报告-多项式计算
qq_49383677的博客
05-22 3660
掌握顺序表和单链表的存储特点及插入、删除等算法。1、任务描述:灵活运用顺序表和单链表的相关算法实现一元多项式的计算。 2、主要数据类型与变量 该结构体数据域用来存储多项式每一项的系数和指数，指针域用来存储下一个项的地址。 3、算法或程序模块 利用while循环和switch语句将各个函数进行封装，生成系统菜单，实现简单的交互界面。1、方案 测试数据： 1 0 2 2 3 3 0 0 -2 2 3 3 -4 4 0 0 2、结果 点击运行，依次输入两个测试数据： 输入数据以规定的格式进行输出，操作命令集正常显
一元稀疏多项式简单计算器（C语言）含注释
m0_62925086的博客
02-22 5708
一元稀疏多项式简单计算器（C语言）含注释 问题描述 设计一个一元稀疏多项式简单计算器 基本要求 一元稀疏多项式简单计算器的基本功能是： （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en，其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列； （3）多项式a和b相加，建立多项式a+b； （4）多项式a和b相减，建立多项式a-b。
一元多项式计算器 (c语言数据结构实验）
零琴的Hope
01-20 7336
一元多项式计算器 (c语言数据结构实验） 班级 ： **** 学号 ： 201907020633 姓名 ： *** 实验机号: A3 实验日期 :2020.12.04 报告日期 :2020.12.07 实验题目：一元多项式计算器
数据结构课程设计一元稀疏多项式计算器
随风飘荡的鱼儿的博客
05-22 3965
数据结构课程设计任务书学生姓名： 专业班级：指导教师： 工作单位：题 目: 一元稀疏多项式计算器基础要求：一元稀疏多项式简单计算器的基本功能是：(1) 输入并建立多项式；(2) 输出多项式，输出形式为整数序列：nn，en，其中n是多项式的项数，ci和ei，分别是第 i 项的系数和指数，序列按指数降序排列；(3) 多项式a和b相加，建立多项式ab；(4) 多项式a和b相减，建立多项式ab。
一元多项式计算器.zip_C++_attentionyhs_单链表实现一元多项式_数据结构_表达式 计算器
07-14
(1)建立含有若干个元素的带表头的单链表； 要求从键盘输入和文件读入两个多项式，显示并保存。 （2）设有一元多项式Am(x)和Bn(x). Am(x)=A0+A1x1+A2x2+A3x3+...+Amxm Bn(x)=B0+B1x1+B2x2+B3x3+...+Bnxn 请实现求M(x)=Am(x)+Bn(x)、M(x)=Am(x)-Bn(x)、M(x)=Am(x)×Bn(x)以及计算M(x)=0的根，计算多项式在x处的值，求多项式M的导函数M，并将结果保存在文本文件中。 （3）多项式的输出形式为类数学表达式。例如，多项式-3x8+6x3-18的输出形式为-3x^8+6x^3-18，x15+(-8)x7-14的输出形式为x^15+8x^7-14。注意，数值为1的非零次项的输出形式中略去系数1，如项1x8的输出形式为x8，项-1x3的输出形式为-x3。
一元多项式计算器（C语言实现）
qq_62225979的博客
01-17 2390
数据结构线性表的链式存储的一个实验 用C语言实现了一元多项式的加、减、乘、求导、求值运算
ZJNU数据结构1001 实验一 链表及其多项式相加
Khalil三省的博客妙妙屋
05-26 684
Description 通过有序对输入多项式的各个项，利用单链表存储该一元多项式，并建立的2个存储一元多项式的单链表，然后完成2个一元多项式的相加，并输出相加后的多项式。 要求： 一个主函数和三个子函数，包括： (1) 多项式输入函数——链表建立函数 (2) 多项式相加函数——链表的合并 (3) 多项式输出函数——链表的输出 Input 输入数据有多组，对于每组测试数据，第一行一个整数n，表示第一个多项式La的项数；接下来n行，每行表示多项式的一项，包含两个元素，表示系数和指数；接下来一个整数
大二上期数据结构实验记录（二）【初版】C实现简单一元多项式加减乘求导及代值计算（有借鉴删改）
cyannxc的博客
11-03 1035
想要记录自己编程思维的成长所以发到博客，欢迎并且感激大家指出缺点和错误！ 一、【实验构思（Conceive）】 本次实验要求是用C或C++语言设计并实现一个一元稀疏多项式的简单计算器，要求是要有如下功能 1、输入并建立多项式 2、输出多项式，序列按指数降序排列 3、多项式A(x)和B(x)相加，并建立多项式A(x)+B(x) 4、多项式A(x)和B(x)相减，并建立多项式A(x)-B(x) 5、给...
一元稀疏多项式（详解加注释）
冰月灵狐
01-26 8559
题目：    一元稀疏多项式简单计算器的基本功能是： 1.输入并建立多项式； 2.输出多项式,输出形式为整数序列：n,c1,e1,,c2,e2 …… cn,en,其中 n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列。 3.多项式a和b相加,建立多项式a+b 4.多项式a和b相减 ,建立多项式a-b 代码如下： #include &lt;iostream&...
一元稀疏多项式计算器
forever的博客
06-03 6737
【问题描述】设计一个一元稀疏多项式得简单计算器。 【基本要求】采用带头结点的单链表存储一元稀疏多项式，设计实现简单计算器以下基本功能。 （1）输入并且建立多项式。 （2）一元多项式的相加运算。 （3）一元多项式的相减运算。 （4）一元多项式的相乘运算。 （5）一元多项式的求导运算。【测试数据】 输入数据：第一个多项式A，共5项，分别是（6，0）（2，1）（8，7）（4，15）（3，18）；第二个多项式B，共3项，分别是（7，1）（2，6）（-8，7）。 输出数据： A多项式的结果：6 + 2X + 8X ^
【链表应用】| 一元多项式的操作
狮子也疯狂的博客
05-16 1235
下面是一些双向链表应用场景：双向链表是一种数据结构，它允许在列表中快速、高效地添加、删除和查找元素。与单向链表不同，双向链表允许在每个节点中存储一个指向前一个节点和一个指向后一个节点的指针。这使得双向链表具有许多优点和应用，如下所述。实现LRU缓存算法：LRU（最近最少使用）缓存算法是一种在计算机内存中向硬盘存储一些数据的方法，它会在内存满了之后替换最近最少使用的数据。在这种情况下，双向链表可用于实现快速的插入和删除操作，从而使LRU缓存算法更加高效。
(数据结构)一元稀疏多项式计算器
热门推荐
weixin_41082201的博客
12-21 1万+
一．实习题目与要求 【问题描述】 设计一个一元稀疏多项式简单计算器。 【基本要求】 （1）输入并建立两个多项式； （2）多项式a与b相加，建立和多项式c； （3）多项式a与b相减，建立差多项式d； （3）输出多项式a,b,c,d。输出格式：比如多项式a为：A(x)=c1xe1+ c2xe2+… + cmxem，其中，ci和ei分别为第i项的系数和指数，且各项按指数的升幂 排列，即0≤e1＜e2＜…...
C语言数据结构：一元多项式运算器
weixin_44270855的博客
09-22 3843
一元多项式运算器的分析与实现 首先，需要解决一元多项式在计算机中的存储问题。 对于一元多项式： P = p0 + p1x + …+pnx^n 在计算机中，可以用一个线性表来表示： P = (p0,p1,…,pn), 但是对于形如 S(x) = 1 + 5x^10 000 -12x^15 000 的多项式，上面的方法显然不合适，会有很多的项系数为0，造成存储空间的浪费，因此只需要存...
数据结构与算法实验课第一颗学生成绩管理系统
最新发布
09-11
你好！对于数据结构与算法实验课的第一次实验，你可以创建一个学生成绩管理系统。这个系统可以用来记录和管理学生的成绩信息。你可以使用适当的数据结构和算法来实现该系统。以下是一些可能的功能和实现思路： 1. 学生信息的录入：你可以创建一个学生类，包含学生的姓名、学号等信息，并为每个学生创建一个对象。 2. 成绩录入：为每个学生创建一个成绩列表或数组，用于记录不同科目的成绩。你可以使用合适的数据结构来存储和管理这些成绩。 3. 成绩查询：提供一个查询功能，可以根据学生的姓名或学号来查询其成绩信息。你可以使用适当的算法来实现高效的查询。 4. 成绩统计：实现对学生成绩的统计功能，例如计算每个学生的平均成绩、最高分、最低分等。 5. 成绩排序：提供对学生成绩的排序功能，例如按照总分或某个科目的成绩进行排序。你可以使用适当的排序算法来实现。 6. 成绩修改和删除：提供对学生成绩的修改和删除功能，可以根据学生的姓名或学号进行操作。 以上只是一些基本的功能和实现思路，你可以根据实际需求进行扩展和优化。希望对你的学生成绩管理系统有所帮助！如果你有更多的问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值