一元多项式表示及相加表示

已于 2023-06-11 15:37:09 修改
阅读量204 收藏
点赞数 2
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2022-11-02 17:47:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63282188/article/details/127645494
版权

1.（新手小白，总体代码写的比较繁琐，见谅，勿喷）

总体代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
//#include<vld.h>   用于检查内存泄漏

typedef struct listnode
{
	float data;                                                             //存放系数
	int cep;                                                                 //存放指数
	struct listnode* next;
}listnode,*linknode;
linknode creatlist();                                                        //创建空链表
linknode buynode();                                                          //购买节点
void printflist( linknode s);                                                //打印一元多项式
void insert_value(linknode s);                                               //插入数据
void push_back(linknode s);                                                  //尾插法
void push_front(linknode s);                                                 //头插法
void Freenode(linknode p);                                                   //释放内存
void clearlist(linknode s);                                                  //清空链表
void Destorylist(linknode s);                                                //摧毁链表
int capity(linknode s);                                                      //计算项数
void rever_list(linknode s);                                                 //顺序存放
void sort(int* b, int n);                                                    //排序
int findpos(int* a, int n, int b);                                           //查找下标
void download(linknode s, int n, int* a, float* b, int* c);                 //提取系数和项数
void Add(linknode a, linknode b);                                            //多项式合并
void brief_add(linknode a);                                                  //化简合并后的多项式
void clear_brieflist(linknode s);                                            //删除合并后的多项式的无用项
int clear_brieflist2(linknode s);
linknode buynode()
{
	listnode* s = (linknode)malloc(sizeof(listnode));
	if (NULL == s)  exit(1);
	memset(s, 0, sizeof(listnode));
	return s;
}
linknode creatlist()
{
	return buynode();
}
void printflist( linknode s)
{
	assert(s != NULL);
	linknode p = s->next;
	while (NULL != p)
	{
		if (p->data == 0) {
			p = p->next;
			continue;
		}
			printf("%.2lf(X)^%d", p->data, p->cep);
			if (p->next != NULL ) printf("+");
			p = p->next;
	}
	printf("\n");
}
void Freenode(linknode p)
{
	free(p);
	p = NULL;
}
void insert_value(linknode s)
{
		linknode cp =  buynode();
		scanf("%f,%d",& cp->data,& cp->cep);
		 cp->next =s->next;
		 s->next = cp; 
}
void push_back(linknode s)
{
	assert(NULL != s);
	while (NULL != s->next)
		s = s->next;
	insert_value(s);
}
void push_front(linknode s)
{
	assert(NULL != s);
	insert_value(s);
}
void clearlist(linknode s)
{
	assert(s != NULL);
	while (NULL != s->next)
	{
		linknode p;
		p = s->next;
		s->next = p->next;
		Freenode(p);
	}

}
void Destorylist(linknode s)
{
	clearlist(s);
	Freenode(s);
}
int capity(linknode s)
{
	assert(NULL != s);
	int n = 0;
	while (s->next != NULL)
	{
		n++;
		s = s->next;
	}
	return n;
}
void rever_list(linknode s)
{
	assert(NULL != s);
	int n = capity(s);
	int* a = (int*)malloc(sizeof(int) * n);                                         //顺序存放
	float* b = (float*)malloc(sizeof(float) * n);                                   //链表顺序 
	int* c = (int*)malloc(sizeof(int) * n);                                         //链表顺序  
	download(s, n,a,b,c);
	s = s->next;
	for(int i=0,j=0;i<n;i++)
	{ 
	  j = findpos(c, n, a[i]);                                                       //
	  s->data = b[j];
	  s->cep = a[i];
	  s =s->next;
	}
	free(a);
	free(b);
	free(c);
	a = NULL;
	b = NULL;
	c = NULL;
}
void sort(int* b, int n)
{
	assert(NULL != b);
	int temp;
	for (int i = 0; i < n-1; i++)
		for (int j = 0; j < n -1- i; j++)
			if (b[j] < b[j+1])
			{
				temp = b[j];
				b[j] = b[j+1];
				b[j+1] = temp;
			}
}
int findpos(int*a,int n, int b)
{
	assert(NULL != a);
	int i;
	for (i = 0; i < n ; i++)
	{
		if (a[i] == b)
		{
			a[i] = 0;
			return i;
		}
	}
}
void download(linknode s, int n,int* a,float* b,int* c)
{
	assert(NULL != s);
	linknode p = s->next;
	for (int i = 0; i < n; i++)
	{
		a[i] = p->cep;
		c[i] = p->cep;
		b[i] = p->data;
		p = p->next;
	}
	sort(a, n);
}

void Add(linknode a, linknode b)
{
	int n=0;
	assert(NULL != a && NULL != b);
	n = capity(a) + capity(b);
	
	while (a->next != NULL)	
		a=a->next;
		a->next = b->next;
		b->next = NULL;
		Freenode(b);
}
void brief_add(linknode a)
{
	int n = capity(a),i=0,j;
	linknode p = a->next;
	linknode q = a;
	float* b = (float*)malloc(sizeof(float) * n);
	int* c = (int*)malloc(sizeof(int) * n);
	while (a->next != NULL)
	{
		b[i] = a->next->data;
		c[i] = a->next->cep;
		a = a->next;
		i++;
	}
	
	for (i = 0 ; i < n; i++)
		for (j = i + 1; j < n; j++)
		{
			if (c[i] == c[j]) {
				b[i] += b[j];
				b[j] = 0;
			}
		}
	for (i = 0; i < n; i++)
	{
		 p->data = b[i];
		p= p->next;
	     
	}
	clear_brieflist(q);
	free(b);
	free(c);
}
void clear_brieflist(linknode s)
{
	assert(s != NULL);
	int i = 0;
	linknode p = s;
	while (NULL!=s->next)
	{
		s = s->next;
	}
	if (s->data == 0) {
		while (i <= clear_brieflist2(p))
			p = p -> next;
	}
	clearlist(p);
}
int clear_brieflist2(linknode s)
{
	assert(s != NULL);
	int i = 0,n=capity(s);
	float* a = (float*)malloc(sizeof(float) *n );
	while (NULL != s->next)
	{
		a[i] = s->next->data;
		s = s->next;
		i++;
	}
	for (i = n-1;; i--)
	{
		if (a[i] != 0) {
			free(a);
			return i;
		}
	}

}
int main()
{
	int n=0,m=0;
	listnode* a = creatlist();
	printf("请输入多项式a个数：");
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		printf("请输入多项式a第%d项的系数和指数：", i + 1);
		push_front(a);
	}
	printf("原一元多项式a为：");
	printflist(a);
	printf("排序后的一元多项式a为：");
	rever_list(a);
	printflist(a);
	listnode* b = creatlist();
	printf("请输入多项式b个数：");
	scanf("%d", &m);
	for (int i = 0; i < m; i++)
	{
		printf("请输入多项式b第%d项的系数和指数：", i + 1);
		push_back(b);
	}
	printf("原一元多项式b为：");
	printflist(b);
	printf("排序后的一元多项式b为：");
	rever_list(b);
	printflist(b);
	
	Add(a, b);
	printf("合并后的一元多项式b为：");
	printflist(a);
	rever_list(a);
	brief_add(a);
	printf("合并排序化简后的一元多项式b为：");
	printflist(a);
	Destorylist(a);
	return 0;
}

 注（main函数可自行设定）

1.结构体定义

typedef struct listnode
{
	float data;                                                             //存放系数
	int cep;                                                                 //存放指数
	struct listnode* next;
}listnode,*linknode;

注解：*linknode为指针，是指向lisinode类型的指针。

2.建立链表

linknode buynode()
{
	listnode* s = (linknode)malloc(sizeof(listnode));
	if (NULL == s)  exit(1);
	memset(s, 0, sizeof(listnode));
	return s;
}
linknode creatlist()
{
	return buynode();
}

定义linknode 型函数，内部动态申请内存。

3.输出链表 

void printflist( linknode s)
{
	assert(s != NULL);
	linknode p = s->next;
	while (NULL != p)
	{
		if (p->data == 0) {
			p = p->next;
			continue;                                             //防止无效项输出(系数为0)
		}
			printf("%.2lf(X)^%d", p->data, p->cep);
			if (p->next != NULL ) printf("+");
			p = p->next;
	}
	printf("\n");
}

4.插入函数（向链表里放入数据）

void insert_value(linknode s)
{
		linknode cp =  buynode();
		scanf("%f,%d",& cp->data,& cp->cep);
		 cp->next =s->next;
		 s->next = cp; 
}

原理图如下：先构建一个节点，进行插入（先断右链，再断左链，不然会造成数据丢失，无法找到下一节点地址。

 1.头插法

void push_front(linknode s)
{
	assert(NULL != s);
	insert_value(s);
}

 2.尾插法

void push_back(linknode s)
{
	assert(NULL != s);
	while (NULL != s->next)
		s = s->next;
	insert_value(s);
}

 5.清空链表

1.释放节点

void Freenode(linknode p)
{
	free(p);
	p = NULL;
}

2.无限头删法

void clearlist(linknode s)
{
	assert(s != NULL);
	while (NULL != s->next)
	{
		linknode p;
		p = s->next;
		s->next = p->next;
		Freenode(p);
	}

}

3.摧毁头节点

void Destorylist(linknode s)
{
	clearlist(s);
	Freenode(s);
}

6.计算数据个数（链表容量）

int capity(linknode s)
{
	assert(NULL != s);
	int n = 0;
	while (s->next != NULL)
	{
		n++;
		s = s->next;
	}
	return n;
}

 7.排序（更改链表数据域，使指数从高到底）

1.保存原链表的数据（用数组保存）

void download(linknode s, int n,int* a,float* b,int* c)
{
	assert(NULL != s);
	linknode p = s->next;
	for (int i = 0; i < n; i++)
	{
		a[i] = p->cep;
		c[i] = p->cep;
		b[i] = p->data;
		p = p->next;
	}
	sort(a, n);
}

2.排序（将指数进行排序）

void sort(int* b, int n)
{
	assert(NULL != b);
	int temp;
	for (int i = 0; i < n-1; i++)
		for (int j = 0; j < n -1- i; j++)
			if (b[j] < b[j+1])
			{
				temp = b[j];
				b[j] = b[j+1];
				b[j+1] = temp;
			}
}

 3.查找下标

int findpos(int*a,int n, int b)
{
	assert(NULL != a);
	int i;
	for (i = 0; i < n ; i++)
	{
		if (a[i] == b)
		{
			a[i] = 0;
			return i;
		}
	}
}

4. 重新给链表赋值，使其有序

void rever_list(linknode s)
{
	assert(NULL != s);
	int n = capity(s);
	int* a = (int*)malloc(sizeof(int) * n);                                         //顺序存放
	float* b = (float*)malloc(sizeof(float) * n);                                   //链表顺序 
	int* c = (int*)malloc(sizeof(int) * n);                                         //链表顺序  
	download(s, n,a,b,c);
	s = s->next;
	for(int i=0,j=0;i<n;i++)
	{ 
	  j = findpos(c, n, a[i]);                                                       //返回原链表指数的下标
	  s->data = b[j];
	  s->cep = a[i];
	  s =s->next;
	}
	free(a);
	free(b);
	free(c);
	a = NULL;
	b = NULL;
	c = NULL;
}

8.合并两个链表

合并方式如图


void Add(linknode a, linknode b)
{
	int n=0;
	assert(NULL != a && NULL != b);
	n = capity(a) + capity(b);
	
	while (a->next != NULL)	
		a=a->next;
		a->next = b->next;
		b->next = NULL;
		Freenode(b);
}

 9.化简合并后的链表

1.找到同类项（指数相同），将系数求和赋给第一个同类项，后续系数赋为0.

void brief_add(linknode a)
{
	int n = capity(a),i=0,j;
	linknode p = a->next;
	linknode q = a;
	float* b = (float*)malloc(sizeof(float) * n);
	int* c = (int*)malloc(sizeof(int) * n);
	while (a->next != NULL)
	{
		b[i] = a->next->data;
		c[i] = a->next->cep;
		a = a->next;
		i++;
	}
	
	for (i = 0 ; i < n; i++)
		for (j = i + 1; j < n; j++)
		{
			if (c[i] == c[j]) {
				b[i] += b[j];
				b[j] = 0;
			}
		}
	for (i = 0; i < n; i++)
	{
		 p->data = b[i];
		p= p->next;
	     
	}
	clear_brieflist(q);
	free(b);
	free(c);
}

2.判断尾结点数据域中系数是否0，并清除链表中无效节点（某一节点到尾结点的数据域中系数全为0）

void clear_brieflist(linknode s)
{
	assert(s != NULL);
	int i = 0;
	linknode p = s;
	while (NULL!=s->next)
	{
		s = s->next;
	}
	if (s->data == 0) {
		while (i <= clear_brieflist2(p))
			p = p -> next;
	}
	clearlist(p);
}

 3.找到链表中最后一个数据域中系数不为0的结点为几号。

int clear_brieflist2(linknode s)
{
	assert(s != NULL);
	int i = 0,n=capity(s);
	float* a = (float*)malloc(sizeof(float) *n );
	while (NULL != s->next)
	{
		a[i] = s->next->data;
		s = s->next;
		i++;
	}
	for (i = n-1;; i--)
	{
		if (a[i] != 0) {
			free(a);
			a=NULL;
			return i;
		}
	}

}

最后运行一下代码

可以看到代码正常运行，且无内存泄漏。 

槐夏风清7
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构--一元多项式
qq_38318537的博客
09-13 1613
函数功能说明：Void InitList(PolyNode &L) /初始化多项式单链表*/ Int GetLength(PolyNode*L) /求多项式单链表的长度/ PolyNode GetElem(PolyNode *L,int i) /返回多项式单链表中第i个结点的指针*/ PolyNode Locate(PolyNode *L,float
一元多项式的建立及其运算
Like_BC
02-05 6359
在表处理时经常遇到的问题是多项式的表示和运算。所以如何建立一个符合多项式的结构是十分重要的。 （一）一元多项式的表示：    一种方法是用顺序表表示，即顺序表的物理位置存储的是多项式中x的指数，而顺序表中物理位置相对应的值便是与以物理位置为指数的项的系数。但是这种方法有缺陷：对于稀疏多项式（缺很多项或是多项式的指数跳动很大）而言，将会浪费大量存储空间。在这种情况下，考虑第二方法：对于每一个系数
一元多项式的表示
fighting123678的博客
07-17 1103
1、 在计算机中，可以用一个线性表来表示: P = (p0, p1, …，pn)，但是对于形如S(x) = 1 + 3x10000 – 2x20000的多项式，上述表示方法不合适。 2、对于形如S(x) = 1 + 3x10000 – 2x20000的多项式为稀疏多项式，一般情况下的一元稀疏多项式可写成Pn(x) = p1xe1 + p2xe2 + ┄ + pmxem，其中：pi 是指数为ei...
多项式的表示及运算
weixin_37616150的博客
04-06 2408
可相加接口public interface Addible&lt;T&gt; //可相加接口 { public void add(T t); //+=加法，约定两元素相加规则 public boolean removable(); //约定删除元素条件 } 项类...
实验四 一元多项式的表示及相加
11-18
在本实验中，我们将深入探讨一元多项式的表示方法及其相加操作，这是计算机科学，尤其是数值计算和算法设计中的基础知识。一元多项式是由常数、变量以及它们的乘积组成的数学表达式，例如 \( ax^3 + bx^2 + cx + d \...
一元多项式表示及相加
10-17
在本实验“一元多项式表示及相加”中，我们聚焦于使用C语言来实现链式结构来处理一元多项式，并进行它们的相加操作。这个实验旨在加深对数据结构的理解，特别是链表这一基本数据结构的应用。 一元多项式是由变量...
数据结构线性表一元多项式的表示及相加PPT学习教案.pptx
10-05
数据结构线性表一元多项式的表示及相加 数据结构是一门研究计算机存储、传输和处理数据的方法和技术的学科。在线性表中，一元多项式的表示及相加是数据结构中的一个重要概念。本文将对一元多项式的表示及相加进行...
cpp链表实现一元多项式表示，相加，相乘
06-18
在计算机科学中，一元多项式是数学中的一个重要概念，它可以被用来表示一系列系数与变量的线性组合。在编程中，特别是在C++这样的语言中，我们常常需要以数据结构的形式来表示和操作这些多项式。在这个场景下，链表...
一元多项式的表示及相加
11-07
数据结构中用c++编写一元多项式的表示及相加。
【初阶数据结构篇】单链表的实现（赋源码）
2301_79849925的博客
07-25 1482
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1219
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 411
对于二分搜索的理论与实现的知识点学习。
数据结构（2）
m0_62881487的博客
07-23 1154
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
2024.7.24 作业
qq_64434282的博客
07-24 2053
【代码】2024.7.24 作业。
《数据结构1800题》基础回合总结——第1章 绪论
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-23 435
前言：《数据结构1800》这本书相信大家或多或少都有所耳闻，收录了诸多不同档次学校的考研真题，因为和汤老师的1800撞名所以备受调侃。这1800道题目里面有选择有填空，也有简答和一些编程题，总的来说质量良莠不齐——亦或说没什么性价比。因此无论考研还是备战期末或者面试的同学，当学有余力的时候，再去看本题集的内容~注：基础阶段，强烈建议不要学算法题，这玩意对于大部分人的水平来说非常耽误效率——ACM佬不在此行列。因此本次刷题相当于基础阶段，只针对除了算法设计的一切基础题~答案如下：答案如下：答案如下： 这一部分
数据结构和算法入门
weixin_67852890的博客
07-25 1566
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
最新发布
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
一元多项式表示与相加：数据结构优化
一元多项式的表示及相加是数据结构课程中的重要内容，它涉及到数学和计算机科学的结合。在一元多项式Pn(x)中，如Pn(x) = a0 + a1x + a2x^2 + ... + anx^n，每个系数ai与变量x的幂次形成多项式的项。在计算机中，这样...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值