抽象数据类型Polynomial 的实现（第二章 P40-43 算法2.22,2.23）

最新推荐文章于 2024-07-25 17:08:19 发布
最新推荐文章于 2024-07-25 17:08:19 发布
阅读量2.3k 收藏 28
点赞数 8
分类专栏： 数据结构 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42185999/article/details/104954983
版权

抽象数据类型Polynomial 的实现，多项式的加法、乘法

 

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */


#include<malloc.h> /* malloc()等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<process.h> /* exit() */

/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
//#define OVERFLOW -2 


/* -----------------------      抽象数据类型Polynomial的实现    ------------------------*/


typedef struct /* 项的表示,多项式的项作为LinkList的数据元素 */
{
	float coef; /* 系数 */
	int expn; /* 指数 */
}term, ElemType;
/* 两个类型名:term用于本ADT,ElemType为LinkList的数据对象名 */


/* -----------------------      带头结点的线性链表类型存储结构    ------------------------*/

typedef struct LNode /* 结点类型 */
{
	ElemType data;
	struct LNode *next;
}LNode, *Link, *Position;

typedef struct LinkList /* 链表类型 */
{
	Link head, tail; /* 分别指向线性链表中的头结点和最后一个结点 */
	int len; /* 指示线性链表中数据元素的个数 */
}LinkList;

typedef LinkList polynomial;
/* -----------------------------------------------------------------------------------------*/



/* --------------------     需要用到的 具有实用意义的线性链表的基本操作  ---------------------------*/


Status MakeNode(Link *p, ElemType e)
{ /* 分配由p指向的值为e的结点，并返回OK；若分配失败。则返回ERROR */
	*p = (Link)malloc(sizeof(LNode));
	if (!*p)
		return ERROR;
	(*p)->data = e;
	return OK;
}

void FreeNode(Link *p)
{ /* 释放p所指结点 */
	free(*p);
	*p = NULL;
}

Status InitList(LinkList *L)
{ /* 构造一个空的线性链表 */
	Link p;
	p = (Link)malloc(sizeof(LNode)); /* 生成头结点 */
	if (p)
	{
		p->next = NULL;
		(*L).head = (*L).tail = p;
		(*L).len = 0;
		return OK;
	}
	else
		return ERROR;
}

Status ClearList(LinkList *L)
{ /* 将线性链表L重置为空表，并释放原链表的结点空间 */
	Link p, q;
	if ((*L).head != (*L).tail)/* 不是空表 */
	{
		p = q = (*L).head->next;
		(*L).head->next = NULL;
		while (p != (*L).tail)
		{
			p = q->next;
			free(q);
			q = p;
		}
		free(q);
		(*L).tail = (*L).head;
		(*L).len = 0;
	}
	return OK;
}

Status InsFirst(LinkList *L, Link h, Link s) /* 形参增加L,因为需修改L */
{ /* h指向L的一个结点，把h当做头结点，将s所指结点插入在第一个结点之前 */
	s->next = h->next;
	h->next = s;
	if (h == (*L).tail) /* h指向尾结点 */
		(*L).tail = h->next; /* 修改尾指针 */
	(*L).len++;
	return OK;
}

Status DelFirst(LinkList *L, Link h, Link *q) /* 形参增加L,因为需修改L */
{ /* h指向L的一个结点，把h当做头结点，删除链表中的第一个结点并以q返回。 */
  /* 若链表为空(h指向尾结点)，q=NULL，返回FALSE */
	*q = h->next;
	if (*q) /* 链表非空 */
	{
		h->next = (*q)->next;
		if (!h->next) /* 删除尾结点 */
			(*L).tail = h; /* 修改尾指针 */
		(*L).len--;
		return OK;
	}
	else
		return FALSE; /* 链表空 */
}

Status Append(LinkList *L, Link s)
{ /* 将指针s(s->data为第一个数据元素)所指(彼此以指针相链,以NULL结尾)的 */
  /* 一串结点链接在线性链表L的最后一个结点之后,并改变链表L的尾指针指向新 */
  /* 的尾结点 */
	int i = 1;
	(*L).tail->next = s;
	while (s->next)
	{
		s = s->next;
		i++;
	}
	(*L).tail = s;
	(*L).len += i;
	return OK;
}

Position PriorPos(LinkList L, Link p)
{ /* 已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置 */
  /* 若无前驱，则返回NULL */
	Link q;
	q = L.head->next;
	if (q == p) /* 无前驱 */
		return NULL;
	else
	{
		while (q->next != p) /* q不是p的直接前驱 */
			q = q->next;
		return q;
	}
}

ElemType GetCurElem(Link p)
{ /* 已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值 */
	return p->data;
}

Status ListEmpty(LinkList L)
{ /* 若线性链表L为空表，则返回TRUE，否则返回FALSE */
	if (L.len)
		return FALSE;
	else
		return TRUE;
}

Position GetHead(LinkList L)
{ /* 返回线性链表L中头结点的位置 */
	return L.head;
}

Position NextPos(Link p)
{ /* 已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置 */
  /* 若无后继，则返回NULL */
	return p->next;
}

Status LocateElemP(LinkList L, ElemType e, Position *q, int(*compare)(ElemType, ElemType))
{ /* 若升序链表L中存在与e满足判定函数compare()取值为0的元素，则q指示L中 */
  /* 第一个值为e的结点的位置，并返回TRUE；否则q指示第一个与e满足判定函数 */
  /* compare()取值>0的元素的前驱的位置。并返回FALSE。（用于一元多项式） */
	Link p = L.head, pp;
	do
	{
		pp = p;
		p = p->next;
	} while (p && (compare(p->data, e) < 0)); /* 没到表尾且p->data.expn<e.expn */
	if (!p || compare(p->data, e) > 0) /* 到表尾或compare(p->data,e)>0 */
	{
		*q = pp;
		return FALSE;
	}
	else /* 找到 */
	{
		*q = p;
		return TRUE;
	}
}

/* ----------------------------------------------------------------------------------------------------------------*/



/* ----------------------   抽象数据类型Polynomial 基本操作的函数原型说明  -----------------------*/

void CreatPolyn(polynomial *P, int m); /* 算法2.22 */
Status DestroyPolyn(polynomial *P);
void PrintPolyn(polynomial P);
int PolynLength(polynomial P);
void AddPolyn(polynomial *Pa, polynomial *Pb);
void AddPolyn1(polynomial *Pa, polynomial *Pb);
void SubtractPolyn(polynomial *Pa, polynomial *Pb);
void MultiplyPolyn(polynomial *Pa, polynomial *Pb);

/* -----------------------------------------------------------------------------------------------*/

int cmp(term a, term b) 
{ /* 依a的指数值<、=或>b的指数值，分别返回-1、0或+1 */
	if (a.expn == b.expn)
		return 0;
	else
		return (a.expn - b.expn) / abs(a.expn - b.expn);
}


/* -----------------------------   抽象数据类型Polynomial 基本操作的实现  -----------------------------*/


void CreatPolyn(polynomial *P, int m) /* 算法2.22 */
{ /* 输入m项的系数和指数，建立表示一元多项式的有序链表P */
	Position q, s;
	term e;
	int i;
	InitList(P);
	printf("请依次输入%d个系数，指数：\n", m);
	for (i = 1; i <= m; ++i)
	{ /* 依次输入m个非零项（可按任意顺序） */
		scanf_s("%f,%d", &e.coef, &e.expn);
		if (!LocateElemP(*P, e, &q, cmp)) /* 当前链表中不存在该指数项,cmp是实参 */
			if (MakeNode(&s, e)) /* 生成结点并插入链表 */
				InsFirst(P, q, s);
	}
}

Status DestroyPolyn(polynomial *P)
{ /* 销毁线性链表L，L不再存在 */
	ClearList(P); /* 清空链表 */
	FreeNode(&(*P).head);
	(*P).tail = NULL;
	(*P).len = 0;
	return OK;
}

void PrintPolyn(polynomial P)
{ /* 打印输出一元多项式P */
	Link q;
	q = P.head->next; /* q指向第一个结点 */
	printf("  系数    指数\n");
	while (q)
	{
		printf("%f  %d\n", q->data.coef, q->data.expn);
		q = q->next;
	}
}

int PolynLength(polynomial P)
{ //返回线性链表L中元素个数 
	return P.len;
}

void AddPolyn(polynomial *Pa, polynomial *Pb) /* 算法2.23 */
{ /* 多项式加法:Pa=Pa+Pb,并销毁一元多项式Pb */
	Position ha, hb, qa, qb;
	term a, b;
	ha = GetHead(*Pa);
	hb = GetHead(*Pb); /* ha和hb分别指向Pa和Pb的头结点 */
	qa = NextPos(ha);
	qb = NextPos(hb); /* qa和qb分别指向Pa和Pb中当前结点（现为第一个结点） */
	while (qa && qb)
	{ /* qa 和 qb 均为非空 */
		a = GetCurElem(qa);
		b = GetCurElem(qb); /* a和b为两表中当前比较元素 */
		switch (cmp(a, b))
		{
		case -1:ha = qa; /* 多项式Pa中当前结点的指数值小 */
			qa = NextPos(ha); /* ha和qa均向后移一个结点 */
			break;
		case 0: qa->data.coef += qb->data.coef;
			/* 两者的指数值相等,修改Pa当前结点的系数值 */
			if (qa->data.coef == 0) /* 删除多项式Pa中当前结点 */
			{
				DelFirst(Pa, ha, &qa);
				FreeNode(&qa);
			}
			else
				ha = qa;
			DelFirst(Pb, hb, &qb);
			FreeNode(&qb);
			qb = NextPos(hb);
			qa = NextPos(ha);
			break;
		case 1: DelFirst(Pb, hb, &qb); /* 多项式Pb中当前结点的指数值小 */
			InsFirst(Pa, ha, qb);
			ha = ha->next;
			qb = NextPos(hb);
		}
	}
	if (!ListEmpty(*Pb))
	{
		Append(Pa, qb); /* 链接Pb中剩余结点 */
	}
	DestroyPolyn(Pb); /* 销毁Pb */
}

void AddPolyn1(polynomial *Pa, polynomial *Pb)
{ /* 另一种多项式加法的算法:Pa=Pa+Pb,并销毁一元多项式Pb */
	Position qb;
	term b;
	qb = GetHead(*Pb); /* qb指向Pb的头结点 */
	qb = qb->next; /* qb指向Pb的第一个结点 */
	while (qb)
	{
		b = GetCurElem(qb);
		OrderInsertMerge(Pa, b, cmp);
		qb = qb->next;
	}
	DestroyPolyn(Pb); /* 销毁Pb */
}


void Opposite(polynomial Pa)
{ /* 一元多项式系数取反 */
	Position p;
	p = Pa.head;
	while (p->next)
	{
		p = p->next;
		p->data.coef *= -1;
	}
}

void SubtractPolyn(polynomial *Pa, polynomial *Pb)
{ /* 多项式减法:Pa=Pa-Pb,并销毁一元多项式Pb */
	Opposite(*Pb);
	AddPolyn(Pa, Pb);
}

void MultiplyPolyn(polynomial *Pa, polynomial *Pb)
{ /* 多项式乘法:Pa=PaPb,并销毁一元多项式Pb */
	polynomial Pc;
	Position qa, qb;
	term a, b, c;
	InitList(&Pc);
	qa = GetHead(*Pa);
	qa = qa->next;
	while (qa)
	{
		a = GetCurElem(qa);
		qb = GetHead(*Pb);
		qb = qb->next;
		while (qb)
		{
			b = GetCurElem(qb);
			c.coef = a.coef*b.coef;
			c.expn = a.expn + b.expn;
			OrderInsertMerge(&Pc, c, cmp);
			qb = qb->next;
		}
		qa = qa->next;
	}
	DestroyPolyn(Pb); /* 销毁Pb */
	ClearList(Pa); /* 将Pa重置为空表 */
	(*Pa).head = Pc.head;
	(*Pa).tail = Pc.tail;
	(*Pa).len = Pc.len;
}


Status OrderInsertMerge(LinkList *L, ElemType e, int(*compare)(term, term))
{ /* 按有序判定函数compare()的约定，将值为e的结点插入或合并到升序链表L的适当位置 */
	Position q, s;
	if (LocateElemP(*L, e, &q, compare)) /* L中存在该指数项 */
	{
		q->data.coef += e.coef; /* 改变当前结点系数的值 */
		if (!q->data.coef) /* 系数为0 */
		{ /* 删除多项式L中当前结点 */
			s = PriorPos(*L, q); /* s为当前结点的前驱 */
			if (!s) /* q无前驱 */
				s = (*L).head;
			DelFirst(L, s, &q);
			FreeNode(&q);
		}
		return OK;
	}
	else /* 生成该指数项并插入链表 */
		if (MakeNode(&s, e)) /* 生成结点成功 */
		{
			InsFirst(L, q, s);
			return OK;
		}
		else /* 生成结点失败 */
			return ERROR;
}



/* -------------------------------------------------------------------------------------------------*/




void main()
{
	polynomial p, q;
	int m;
	printf("请输入第一个一元多项式的非零项的个数：");
	scanf_s("%d", &m);
	CreatPolyn(&p, m);
	printf("请输入第二个一元多项式的非零项的个数：");
	scanf_s("%d", &m);
	CreatPolyn(&q, m);
	AddPolyn(&p, &q);
	printf("两个一元多项式相加的结果：\n");
	PrintPolyn(p);
	printf("请输入第三个一元多项式的非零项的个数：");
	scanf_s("%d", &m);
	CreatPolyn(&q, m);
	AddPolyn1(&p, &q);
	printf("两个一元多项式相加的结果(另一种方法)：\n");
	PrintPolyn(p);
	printf("请输入第四个一元多项式的非零项的个数：");
	scanf_s("%d", &m);
	CreatPolyn(&q, m);
	SubtractPolyn(&p, &q);
	printf("两个一元多项式相减的结果：\n");
	PrintPolyn(p);
	printf("请输入第五个一元多项式的非零项的个数：");
	scanf_s("%d", &m);
	CreatPolyn(&q, m);
	MultiplyPolyn(&p, &q);
	printf("两个一元多项式相乘的结果：\n");
	PrintPolyn(p);
	DestroyPolyn(&p);
}

 

运行结果:

想去的远方
关注
专栏目录
（十一）第 2 章 线性表 （ 具有实用意义的线性链表（带头结点））
墨夜白
09-10 275
算法 2.20、2.21
【数据结构】算法2.22-2.23 一元多项式的表示及相加
Zelda 的博客
10-10 3500
#include<stdio.h> #include<string.h> #include<stdlib.h>#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2typedef int Status; typedef struct { int
数据结构：数据类型与抽象数据类型
最新发布
Weiki的博客
07-25 1827
数据结构：数据类型与抽象数据类型
一元多项式的表示及相加(抽象数据类型Polynomial的实现)
weixin_30859423的博客
08-12 476
// c2-6.h 抽象数据类型Polynomial的实现(见图2.45) typedef struct // 项的表示，多项式的项作为LinkList的数据元素 { float coef; // 系数 int expn; // 指数 }term,ElemType; // 两个类型名：term用于本ADT，ElemType为LinkList的数据对象名 图246 是根据c2-5.h 和c...
<Sicily>Polynomial
晨曦的博客
06-16 502
一、题目描述 Given a polynomial and the value of the variable x, you task is to calculate the value of the polynomial. 二、输入 The first line of the input is a positive integer T. T is the number of test c...
C++ Polynomial类
ysy10599105的博客
05-18 2107
#include<iostream> using namespace std; class P { private: double *co; int n; public: P(double a[],int n); P(){n=0;co=NULL;} P(const P &b); ~P(); void input(doubl...
Polynomial
小红九さんの技術ブログ
09-24 925
single linked list
一元多项式Polynomial的C语言实现
weixin_30341735的博客
10-09 926
1 /* 2 编译器：Dev-c++ 5.4.0 3 文件名：Polynomial.cpp 4 代码版本号：1.0 5 时间：2015年10月9日21:53:26 6 */ 7 8 /* 9 总结： 10 1.结构体指针指向的区域要手动分配内存 11 2.反复使用的代码封装成函数 ...
1th_to_12th_polynomial_ftting_光谱拟合_1-12阶多项式拟合算法对光谱数据拟合_数据预测_反射光谱
10-02
本项目着重于使用1到12阶的多项式拟合算法来处理反射光谱数据，目标是精确预测红边位置以及对应的反射率。 红边位置是植物光谱特性中的一个关键特征，特别是在遥感和生态学研究中。它是光谱曲线中从可见光到近红外...
用线性表实现一个一元多项式Polynomial
11-22
该源程序是数据结构的代码实现：用线性表实现一个一元多项式Polynomial
polynomial.zip
09-15
建立了poly类以实现多项式的相加、相乘和输出功能，涉及到的c++知识有：对象的深层复制、运算符重载、链表的c++实现、指针等。因为自己是初学者，所以注释写的写的比较啰嗦。有什么问题还希望不吝赐教。我直接把整个project包压缩，运行环境为win10 ，visual studio2013.
Hermit多项式在线学习ran算法.rar_F-RAN_hermit-polynomial_ran_在线学习算法
09-21
本程序用资源分配网(Resource_Allocation Network,简称RAN)实现了Hermit多项式在线学习问题。训练样本产生方式如下，样本数400，每个样本输入Xi在区间[-4,4]内随机产生（均匀分布），相关样本输出为F(Xi) = 1.1(1-Xi...
Polynomial ADT
qq_32400119的博客
05-04 505
对于一个多项式，需要处理的数据有每一项的幂级数，以及该项的系数。 1. 数组实现 这是比较简单的一种方法，先看多项式的数据结构： typedef struct _polynomial { int high_power; /* +1 because there is constant term. */ int coff_array[MAX_DEGREE + 1]; } *P...
C Polynomial
kanone0seele的专栏
10-12 499
<br />数据结构题集（C语言版）<br /> <br />P81  1.5<br /> <br /> <br />#include <stdio.h> #include <stdlib.h> typedef struct PolyNode { float c; int n; struct PolyNode *next; }PolyNode; PolyNode *Init(int *m) { PolyNode *p, *r, *temp, *L; int i, n = *
!!!Polynomial ADT
b_end_an的专栏
04-16 815
A simple Polynomial ADT 1. can input each term and display the result 2. can add/multiply two polynomials 3. linked list implementation Main.cpp #include #include"POLY_DEF.h" using namespace std;
c++实现多项式类定义
zyp3295613196的博客
06-12 3945
c++实现多项式类的定义，可进行+、-、*、赋值运算，可显示已存储几个多项式对象，可计算任意x值下多项式的值。
c语言 一元多项式展开括号,一元多项式Polynomial的C语言实现
weixin_39966130的博客
05-21 539
1 /*2 编译器：Dev-c++ 5.4.03 文件名：Polynomial.cpp4 代码版本号：1.05 时间：2015年10月9日21:53:266 */78 /*9 总结：10 1.结构体指针指向的区域要手动分配内存11 2.反复使用的代码封装成函数12 */13 #include 14 #include 1516 #define ERROR 017 #define OK 118 #...
C++实现CRC-8循环冗余校验算法教程
总结而言，给定的资源“CRC.rar_crc-8_crc校验实现C++”涉及到了数据通信中一个重要的概念——CRC校验，并着重介绍了CRC-8这种特定算法的实现方法，以及如何使用C++语言来编写相应的校验代码。这不仅适用于理解CRC...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值