用链表实现带菜单功能的一元多项式的基本操作 (Use linked list to realize the basic operation of a one-dimensional polynom)

最新推荐文章于 2024-01-07 22:14:26 发布
最新推荐文章于 2024-01-07 22:14:26 发布
阅读量1.4k 收藏 10
点赞数 2
分类专栏： Data Strutures and Algorithm 文章标签： C Linklist one-dimensional polynomial
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengran_mark/article/details/79774653
版权

问题描述：
从键盘读入一元多项式中每一项的系数和指数，编写算法和建立文本菜单实现： 
建立带表头结点的单链表存放一元多项式（按照指数升序排列）； 
输出一元多项式的所有数据元素(按照指数升序输出每一系数非0项的系数和指数)； 
将单链表存放的一元多项式就地逆置，变成按照指数降序排列； 
输入自变量的值，计算一元多项式的值（设计高效算法）； 
求2个一元多项式的和多项式；

程序使用说明：

1.       在选择1未建表的情况下，选择2-5会提示无法执行，此时可在选择1或选择6进行A表的建立。

2.       若在选择1建表后，选择6将直接进入B表的建立。

3.       选择6执行后产生的新的一元多项式为新表A，可继续对该新表进行操作。

4.       A表存在后，选择1将显示当前操作的表，无法再建立新表。

5.       选择2-5的基本操作默认针对表A进行。

6.       出现“按任意键继续”时，根据提示操作即可。

代码如下： 

#include<stdio.h>
#include<malloc.h>
#include<iostream>
#include<conio.h>
#include<stdlib.h>
#define MAXSIZE 20

typedef struct Node
{
	int coef;
	int exp;
	struct Node *next;
}Node, *LinkList;

void LinkList_Screen();                                         //进入页面显示函数
int LinkList_TailCreate(LinkList &L);				//尾插法建表
int LinkList_ExpInscending(LinkList &L, int len);		//指数升序排序函数
int LinkList_ExpInscendingElementPrint(LinkList &L, int len);	//指数升序输出所有元素
int LinkList_Reverse(LinkList &L);			        //就地逆置函数
int LinkList_Cuculate(LinkList &L);				//计算输入的x的值
int LinkList_Add(LinkList &A, LinkList &B);		        //两个一元多项式相加
int LinkList_Print(LinkList &L);				//输出函数
int LinkList_MergeSame(LinkList &L);				//合并同类项函数

int main()
{
	LinkList A,B;
	int len[MAXSIZE], i=0;					//储存建立的表的长度
	memset(len, 0, sizeof(len));
	while (1)
	{
		LinkList_Screen();
		switch (_getch())
		{
			case '1': 
			{ 
				system("cls");
				if (len[i] != 0)
				{
					printf("已存在以下一元多项式，请选择需要的操作!\n");
					LinkList_Print(A);
					system("pause");
					break;
				}
				printf("现在建立第1个一元多项式\n");
				len[++i]=LinkList_TailCreate(A); 
				break; 
			}
			case '2': 
			{ 
				if (len[i] == 0)
				{
					printf("没有可操作的表!请先建表!\n");
					system("pause");
					break;
				}
				system("cls");
				LinkList_ExpInscending(A,len[i]); 
				break; 
			}
			case '3': 
			{ 
				if (len[i] == 0)
				{
					printf("没有可操作的表!请先建表!\n");
					system("pause");
					break;
				}
				system("cls");
				LinkList_ExpInscendingElementPrint(A,len[i]); 
				break; 
			}
			case '4': 
			{ 
				if (len[i] == 0)
				{
					printf("没有可操作的表!请先建表!\n");
					system("pause");
					break;
				}
				system("cls");
				LinkList_Reverse(A); 
				break; 
			}
			case '5': 
			{ 
				if (len[i] == 0)
				{
					printf("没有可操作的表!请先建表!\n");
					system("pause");
					break;
				}
				system("cls");
				LinkList_Cuculate(A); 
				break;
			}
			case '6': 
			{ 
				system("cls");
				if (len[i] == 0)
				{
					printf("现在建立第%d个一元多项式\n",i+1);
					len[++i] = LinkList_TailCreate(A);
				}
				printf("第%d个一元多项式",i);
				LinkList_ExpInscending(A, len[i]);
				printf("现在建立第%d个一元多项式\n",i+1);
				len[++i] = LinkList_TailCreate(B);
				printf("第%d个一元多项式",i);
				LinkList_ExpInscending(B, len[i]); 
				len[++i] = LinkList_Add(A, B);
				break; 
			}
			case '7': { exit(0); break; }
		}
		LinkList_Screen();
	}
	system("pause");
}

void LinkList_Screen()
{
	system("cls");
	printf("请输入要进行的操作\n");
	printf("*************************************\n");
	printf("\t 1.建立一元多项式\n");
	printf("\t 2.对一元多项式进行指数升序排列\n");
	printf("\t 3.按指数升序输出一元多项式系数与指数\n");
	printf("\t 4.逆置一元多项式\n");
	printf("\t 5.输入x,计算一元多项式的值\n");
	printf("\t 6.求两个一元多项式的和多项式\n");
	printf("\t 7.退出\n");
	printf("*************************************\n");
	printf("请输入选择:\n");
}

int LinkList_TailCreate(LinkList &L)//输入每一项系数与指数
{
	LinkList p, s;
	int coef, exp, i, length, len;
	L = (LinkList)malloc(sizeof(Node));
	L->next = NULL;
	p = L;
	printf("请输入该一元多项式的项数:");
	scanf_s("%d", &length);
	for (i = 0; i < length; i++)
	{
		printf("请输入第%d项系数:", i + 1);
		scanf_s("%d", &coef);
		printf("请输入第%d项指数:", i + 1);
		scanf_s("%d", &exp);
		while (coef == 0)
		{
			printf("无效项!请重新输入!\n");
			printf("请输入第%d项系数:", i + 1);
			scanf_s("%d", &coef);
			printf("请输入第%d项指数:", i + 1);
			scanf_s("%d", &exp);
		}
		s = (LinkList)malloc(sizeof(Node));
		s->coef = coef;
		s->exp = exp;
		s->next = NULL;
		p->next = s;
		p = p->next;
	}
	len = LinkList_MergeSame(L);
	length -= len;
	printf("新建的一元多项式为:");
	LinkList_Print(L);
	system("pause");
	return length;
}

int LinkList_ExpInscending(LinkList &L, int len)//指数exp升序排列
{
	LinkList p, q, r;
	int i, j, done=1;
	p = L->next;
	if (p == NULL || p->next == NULL)
	{
		printf("无需排列!\n");
		return 0;
	}
	for (i = 1; i <= len - 1 && done; i++)//冒泡排序
	{
		done = 0;
		r = L;
		p = r->next;
		q = p->next;
		for (j = 0; j < len - i; j++)
		{
			if (p->exp > q->exp)
			{
				p->next = q->next;
				q->next = p;
				r->next = q;
				q = p->next;
				r = r->next;
				done = 1;
			}
			else
			{
				r = p; 
				p = q;
				q = q->next;
			}
		}
	}
	printf("指数升序排列后为:");
	LinkList_Print(L);
	system("pause");
	return 1;
}

int LinkList_ExpInscendingElementPrint(LinkList &L, int len)//指数升序输出系数与指数
{
	LinkList p,q,r;
	int k = 1, i, j, done = 1;
	p = L->next;
	if (p == NULL)
	{
		printf("Empty List!");
		return 0;
	}
	for (i = 1; i <= len - 1 && done; i++)//冒泡排序
	{
		done = 0;
		r = L;
		p = r->next;
		q = p->next;
		for (j = 0; j < len - i; j++)
		{
			if (p->exp > q->exp)
			{
				p->next = q->next;
				q->next = p;
				r->next = q;
				q = p->next;
				r = r->next;
				done = 1;
			}
			else
			{
				r = p;
				p = q;
				q = q->next;
			}
		}
	}
	printf("指数升序输出所有元素为:\n");
	p = L->next;
	while (p)
	{
		printf("第%d项系数为%d,第%d项指数为%d\n", k, p->coef, k, p->exp);
		p = p->next;
		k++;
	}
	system("pause");
	return 1;
}

int LinkList_Reverse(LinkList &L)//就地逆置变为指数降序
{
	LinkList p, q;
	p = L->next;
	L->next = NULL;
	if (p == NULL)
	{
		printf("Empty List!");
		return 0;
	}
	while (p)
	{
		q = p->next;
		p->next = L->next;
		L->next = p;
		p = q;
	}
	printf("逆置后为:");
	LinkList_Print(L);
	system("pause");
	return 1;
}

int LinkList_Cuculate(LinkList &L)//高效算法：输入自变量x求一元多项式的值
{
	LinkList p, q;
	int sum = 0, result = 0, q_expresult = 1, x;
	printf("请输入自变量x:");
	scanf_s("%d", &x);
	p = L->next;
	q = L;
	q->exp = 0;
	if (p == NULL)
	{
		printf("Epmty List!");
		return 0;
	}
	while (p)
	{
		result = pow(x, p->exp - q->exp)*q_expresult;//利用前一项已算出的x次幂
		q_expresult = result;
		sum = sum + p->coef*result;
		q = p;
		p = p->next;
	}
	printf("x=%d时,多项式值y=%d\n", x, sum);
	system("pause");
	return sum;
}

int LinkList_Add(LinkList &A, LinkList &B)//求两个一元多项式的和多项式
{
	LinkList pa, pb, r, s;
	int len = 0;
	pa = A->next;
	pb = B->next;
	s = A;
	free(B);
	while (pa != NULL && pb != NULL)
	{
		if (pa->exp < pb->exp)
		{
			r = pa;
			pa = pa->next;
			s->next = r;
			s = r;
		}
		else if (pa->exp > pb->exp)
		{
			r = pb;
			pb = pb->next;
			s->next = r;
			s = r;
		}
		else if (pa->exp == pb->exp)
		{
			pa->coef = pa->coef + pb->coef;
			r = pb->next;
			free(pb);
			pb = r;
			if (pa->coef == 0)
			{
				r = pa->next;
				free(pa);
				pa = r;
			}
			else
			{
				r = pa;
				pa = pa->next;
				s->next = r;
				s = r;
			}
		}
	}
	if (pa == NULL)
		s->next = pb;
	if (pb == NULL)
		s->next = pa;
	printf("相加后当前新的一元多项式为:");
	LinkList_Print(A);
	r = A->next;
	while (r)
	{
		len++;
		r = r->next;
	}
	system("pause");
	return len;
}

int LinkList_Print(LinkList &L)
{
	LinkList p;
	p = L->next;
	if (p == NULL)
	{
		printf("Epmty List!");
		return 0;
	}
	printf("y = ");
	while (p != NULL)
	{
		if (p->exp == 0)
			printf("%d", p->coef);
		else
			printf("%dx^%d", p->coef, p->exp);
		p = p->next;
		if (p != NULL)
			printf(" + ");
	}
	printf("\n");
	return 1;
}

int LinkList_MergeSame(LinkList &L)
{
	LinkList p, q;
	int len = 0;
	p = L->next;
	if (p == NULL || p->next == NULL)
		return 0;
	while (p->next)
	{
		if (p->exp == p->next->exp)
		{
			q = p->next;
			p->coef += q->coef;
			p->next = q->next;
			free(q);
			len++;
		}
		else
			p = p->next;
	}
	return len;
}
编译环境： Visual Studio
fengranmo
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表的操作---带菜单
smallgyy的专栏
03-21 1898
#include using namespace std; enum operation{create_List=1,print_List,insert_Node,delete_Node,delete_List,quit};//枚举类型，用于菜单选择结果 struct node //结点结构 { int data ; node * next; }; operation
C语言--动态链表菜单--实现建、输、增、删、逆序
weixin_44039872的博客
12-11 1048
C语言–动态链表菜单–实现建、输、增、删、逆序 第一篇CSDN博客，就先简单点了… 对应应用：学生信息管理系统. 代码如下： C语言–动态链表菜单–实现建、输、增、删、逆序。 #define _CRT_SECURE_NO_DEPRECATE #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; #de...
链表练习（一元多项式）：一元多项式采用带表头结点的单链表存放，用类C语言设计算法求一元多项式的值。
qq_51777949的博客
03-31 2988
注意嗷：这里的一元多项式输入时，指数exp不一定是按照递增顺序输入的，但是最终我们想获得一个指数递增的链表形式，所以在插入新结点时，需要进行判断，把他放在合适的位置。 #include<stdio.h> #include<stdlib.h> #include<math.h> //结构体定义 typedef struct node { int cofe,exp; struct node *next; }Lnode,*Linklist; //建立系数递增链表 并输
链表形式 菜单效果
05-05
以链表形式定义的菜单对象，及其进行菜单切换等效果的实现，非原著，感觉写的不错。
数据结构——创建一个带头节点的单链表(C语言)
weixin_73849400的博客
01-20 6825
基础的单链表的构建，以及前插法、后插法在输入数据时的应用。还有一些细小的不同引发的非法访问及其解决方法。
一元多项式_单链表实现一元多项式求和_signa67_pleasekzo_
10-03
本文将深入探讨如何使用单链表来实现一元多项式的求和操作。单链表是一种基本的数据结构，它能有效地存储和处理多项式中的各项系数。 一元多项式通常表示为 $P(x) = a_nx^n + a_{n-1}x^{n-1} + \ldots + a_1x + a_0...
基于C++与链表的两个一元多项式的基本运算（加法、减法、 乘法和求导运算）
04-15
在计算机科学中，一元多项式的基本运算，如加法、减法、乘法和求导，是数学问题在编程中的典型应用。本项目聚焦于使用C++编程语言和链表数据结构实现这些运算，这对于理解和掌握数据结构、算法以及C++编程技巧具有...
Create-a-list.rar_Create a List_菜单 链表
09-24
在编程领域，链表是一种非常基础且重要...以上就是关于创建链表及使用菜单实现链表操作的详细介绍。这些基本操作是理解链表和设计更复杂数据结构的基础。通过熟练掌握这些，你可以解决许多与数据存储和处理相关的问题。
顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。.docx
11-05
本文档是关于一元多项式加法、减法和乘法实现的课程设计报告，主要关注在顺序结构和动态链表结构下的实现方法。设计目标是加深对数据结构的理解，尤其是如何选择合适的数据结构来解决问题，并能编写相关算法。设计...
require-the-use-of-a-linked-.zip_Void_ The
09-22
　要求采用链表形式，求两个一元多项式的乘积：h3 = h1*h2。函数原型为：void multiplication( NODE * h1, NODE * h2, NODE * h3 )。 输入： 　输入数据为两行，分别表示两个一元多项式。每个一元多项式以指数...
链表实现多级菜单
05-04
本例实现单片机的多级菜单，过程是用链表实现的。
STM32用链表实现多级菜单
10-02
用链表实现多级菜单，STM32彩屏显示多级菜单
一元多项式运算C语言
05-23
一元多项式求和实质上是合并同类项的过程，其运算规则为： （1）若两项的指数相等，则系数相加； （2）若两项的指数不等，则将两项加在结果中。
C语言一元多项式简单计算
07-06
此程序的数据结构是选择用带表头结点的单链表存储多项式。虽然一元多项式可以用顺序和链式两种存储结构表示，但顺序结构的最大长度很难确定。比如当多项式的系数较大时，此时就会浪费了巨大的存储空间，所以应该选择用链式存储结构来存储一元多项式。单链表的结构体可以用来存储多项式的系数，指数，下一个指针3个元属，这样便于实现任意多项式的加法，减法运算。
数据结构：单链表的基本操作，含菜单（C/C++）
weixin_46601559的博客
11-13 1978
C语言： #include <stdio.h> #include <stdlib.h> #define ERROR 1 #define OK 0 /* 单链表结点定义 */ typedef struct LNode { int data; //data中存放结点数据域（默认是int型） struct LNode *next; //指向后继结点的指针 }LNode; //操作函数的声明 LNode *HeadCreateList(int len);
双向带头循环链表的基本操作(含菜单)
zfly_sea的博客
08-13 356
操作完整含菜单 每一个接口的定义都有完整的注释，看完即会保熟。
数据结构——单链表多链表基本操作菜单实现(c语言)
weth的存档室
07-19 5507
本文将单链表与双向链表的基本操作在同一个程序中实现。其中单链表头文件中的函数与双向链表头文件中的函数可以分离出来单独使用。菜单程序的实现的程序较为复杂，变量多且作用范围不同，如果修改代码需要对代码非常熟悉，没有很好的做到函数的可分离。见谅！ 一、菜单功能及从属关系 注意： 1.程序设置了两个单链表节点指针和两个双向链表节点指针，但是表现给使用者的链表数同时间内最多两条，最少0条。(我写了一个函数来提示使用者创建链表的情况) 2.进行每一项操作前，程序都需要确认进行操作的是哪一条链表，本质是确认该链表的.
带环相交链表及其UI菜单
m0_66601317的博客
07-21 476
掌握链表的基本操作。掌握带环链表的相关操作算法。掌握基于easyx的UI图形界面
C语言菜单构建（动态链表的创建并运用菜单实现选择功能）
最新发布
ddddas_a的博客
01-07 818
printf("第%d个节点的数据是：字符数据为%s 数字数据为%d\n",n, p->name,p->data);//调用文件数据保存函数。NOD* getfromfile(NOD* head, char* filename)//文件读取函数。void savetofile(NOD* head, char* filename)//文件保存函数。if (p1->name[0]=='\n')//如果字符串为空，结束链表创建。
c语言的链表实现一元多项式,链表基本操作的实现-----一元多项式简单计算器设计...
10-10
要实现一元多项式的链表表示，我们可以定义一个结构体来表示多项式的每一项，包括系数和指数，并使用指针来连接每一项。示例代码如下： ``` #include #include // 定义多项式项的结构体 typedef struct Node { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值