学习笔记------数据结构(C语言版)链表应用~一元多项式求和

原创 2016年01月15日 19:27:59

//Polynomial.cpp

#include"predefined.h"
#include"Polynomial.h"
#include"ExtenLinkedList.h"

void CreatPolyn(polynomial *P,int m)
//算法2.22:输入m项的系数和指数,建立表示一元多项式的有序链表。
{
	Position h;
	Link q;
	int i;
	ElemType e;
	InitList_E(P);
	h=GetHead_E(*P);
	e.coef=0.0;
	e.expn=-1;
	SetCurElem_E(&h,e);
	(*h).next=NULL;
	for(i=1;i<=m;i++)
	{
		printf("▲请输入第%d组元素:",i);
		scanf("%f,%d",&(e.coef),&(e.expn));
		MakeNode_E(&q,e);
		InsFirst_E(P,h,q);
		h=(*h).next;
	}
}

void DestroyPolyn(polynomial *P)
//销毁一元多项式P
{
	DestroyList_E(P);
}

void PrintPolyn(polynomial P)
//打印输出一元多项式P
{
	int i;
	Link q;
	q=(*P.head).next;
	for(i=1;i<=P.len;i++)
	{
		if(i==1)
			printf("%g",(*q).data.coef);
		else
		{
			if((*q).data.coef>0)
			{
				printf("+");
				printf("%g",(*q).data.coef);
			}
			else
			{
				printf("-");
				printf("%g",-(*q).data.coef);
			}
		}
		if((*q).data.expn)
		{
			printf("X");
			if((*q).data.expn!=1)
				printf("^%d",(*q).data.expn);
		}
		q=(*q).next;
	}
}

int PolyLength(polynomial P)
//返回一元多项式P中的项数
{
	return ListLength_E(P);
}

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

void AddPolyn(polynomial *Pa,polynomial *Pb)
//算法2.23:多项式加法:Pa=Pa+Pb,利用两个多项式的结点构成“和多项式”
{
	term a,b;
	float sum;
	Position ha,hb,qa,qb;
	ha=GetHead_E(*Pa);
	hb=GetHead_E(*Pb);
	qa=NextPos_E(*Pa,ha);
	qb=NextPos_E(*Pb,hb);
	while(qa&&qb)
	{
		a=GetCurElem_E(qa);
		b=GetCurElem_E(qb);
		switch(cmp(a,b))
		{
		case -1:ha=qa;qa=NextPos_E(*Pa,ha);break;
		case 0:
			sum=a.coef+b.coef;
			if(sum!=0)
			{
				a.coef=sum;
				SetCurElem_E(&qa,a);
				ha=qa;
			}
			else
			{
				DelFirst_E(Pa,ha,&qa);
				FreeNode_E(&qa);
			}
			DelFirst_E(Pb,hb,&qb);
			FreeNode_E(&qb);
			qa=NextPos_E(*Pa,ha);
			qb=NextPos_E(*Pb,hb);
			break;
		case 1:
			DelFirst_E(Pb,hb,&qb);
			InsFirst_E(Pa,ha,qb);
			qb=NextPos_E(*Pb,hb);
			ha=NextPos_E(*Pa,ha);
			break;
		}
	}
	if(qb) Append_E(Pa,qb);
	FreeNode_E(&hb);
}

//main.cpp

#include"predefined.h"
#include"Polynomial.h"
#include"ExtenLinkedList.h"
void CreatPolyn(polynomial *P,int m);
void DestroyPolyn(polynomial *P);
void PrintPolyn(polynomial P);
int PolyLength(polynomial P);
void AddPolyn(polynomial *Pa,polynomial *Pb);
int cmp(term a,term b);


int main()
{
	polynomial Pa,Pb;
	int m,n,i;
	m=6;
	n=5;
	printf("Function 1\n★函数CreatPolyn(polynomial *P,int m)测试...\n");
	printf("▲请输入一元多项式Pa的元素...\n");
	CreatPolyn(&Pa,m);
	printf("\n");
	printf("▲请输入一元多项式Pb的元素...\n");
	CreatPolyn(&Pb,n);
	printf("\n");
	printf("Function 2\n★函数PrintPolyn(polynomial P)测试...\n");
	printf("▲一元多项式Pa=");
	PrintPolyn(Pa);
	printf("\n");
	printf("▲一元多项式Pb=");
	PrintPolyn(Pb);
	printf("\n\n");
	printf("Function 3\n★函数PolyLength(polynomial P)测试...\n");
	n=PolyLength(Pa);
	printf("▲一元多项式Pa的项数为:%d\n",n);
	n=PolyLength(Pb);
	printf("▲一元多项式Pb的项数为:%d\n\n",n);
	printf("Function 4\n★函数AddPolyn(polynomial *Pa,polynomial *Pb)测试...\n");
	printf("▲Pa=Pa+Pb=");
	AddPolyn(&Pa,&Pb);
	PrintPolyn(Pa);
	printf("\n");
	printf("Function 5\n★函数DestroyPolyn(polynomial *P)测试...\n");
	printf("▲销毁Pa前:");
	(Pa.head&&Pa.tail&&Pa.len)?printf("Pa存  在!!!\n"):printf("Pa不存在!!!\n");
	DestroyPolyn(&Pa);
	printf("▲销毁Pa后:");
	(Pa.head&&Pa.tail&&Pa.len)?printf("Pa存  在!!!\n\n"):printf("Pa不存在!!!\n\n");
}

//Function realization.cpp

#include"predefined.h"
#include"Polynomial.h"
#include"ExtenLinkedList.h"
Status MakeNode_E(Link *p,ElemType e)//
//分配由p指向的值为e的结点,并返回OK;
//若分配失败,则返回ERROE。
{
	(*p)=(Link)malloc(sizeof(LNode));
	if(!(*p)) exit(OVERFLOW);
	(**p).data=e;
	(**p).next=NULL;
	return OK;
}

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

Status InitList_E(LinkList *L)//
//构造一个空的线性链表L。
{
	Link p;
	p=(Link)malloc(sizeof(LNode));
	if(!p) exit(OVERFLOW);
	(*p).next=NULL;
	(*L).head=(*L).tail=p;
	(*L).len=0;
	return OK;
}

Status DestroyList_E(LinkList *L)//
//销毁线性链表L,L不再存在。
{
	Link p,q;  
	p=(*L).head;  
    while(p)  
    {  
        q=p;
  		p=(*p).next;
		free(q); 
    }
	(*L).head=(*L).tail=NULL;
	(*L).len=0;
    return OK;
}


Status InsFirst_E(LinkList *L,Link h,Link s)//
//已知h指向线性链表的头结点,将s所指结点插入在第一个结点之前。
{
	(*s).next=(*h).next;
	(*h).next=s;
	(*L).len++;
	if((*L).tail==h) (*L).tail=s;
	return OK;
}

Status DelFirst_E(LinkList *L,Link h,Link *q)//
//已知h指向线性链表的头结点,删除链表中的第一个结点并以q返回。
{
	if(!((*h).next)) return ERROR;
	if(!(*(*h).next).next) (*L).tail=(*L).head;
	*q=(*h).next;
	(*h).next=(*(*h).next).next;
	(*L).len--;
	return OK;
}

Status Append_E(LinkList *L,Link s)//
//将指针s所指(彼此以指针相连)的一串结点链接在线性表L的最后一个结点
//之后,并改变链表L的尾指针指向新的尾结点。
{
	Link p,q;
	int count=0;
	p=(*L).tail;
	(*p).next=s;
	while(s)
	{
		q=s;
		s=(*s).next;
		count++;
	}
	(*L).tail=q;
	(*L).len+=count;
	return OK;
}



Status SetCurElem_E(Link *p,ElemType e)//
//已知p指向线性链表中的一个结点,用e更新p所指结点中数据元素的值。
{
	if(!(*p)) return ERROR;
	(**p).data=e;
	return OK;
}

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

int ListLength_E(LinkList L)//
//返回线性链表L中元素的个数。
{
	return L.len;
}

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


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

//Polynomial.h

typedef struct
{
	float coef;
	int   expn;
}term,ElemType;

//ExtenLinkedList.h

typedef struct LNode//结点类型
{
	ElemType data;
	struct LNode *next;
}LNode,*Link,*Position;
typedef struct//链表类型
{
	Link head,tail;
	int len;
}LinkList;
typedef LinkList polynomial;
Status MakeNode_E(Link *p,ElemType e);
void FreeNode_E(Link *p);
Status InitList_E(LinkList *L);
Status DestroyList_E(LinkList *L);
Status InsFirst_E(LinkList *L,Link h,Link s);
Status DelFirst_E(LinkList *L,Link h,Link *q);
Status Append_E(LinkList *L,Link s);
Status SetCurElem_E(Link *p,ElemType e);
ElemType GetCurElem_E(Link p);
int ListLength_E(LinkList L);
Position GetHead_E(LinkList L);
Position NextPos_E(LinkList L,Link p);

//predefined.h

#include "stdio.h"
#include "stdlib.h"
#define   TRUE           1
#define   FALSE          0
#define   OK             1
#define   ERROR          0
#define   INFEASIBLE    -1
#define   OVERFLOW      -2
typedef   int Status;


版权声明:本文为博主原创文章,未经博主允许不得转载。

C语言:用链表实现一元多项式的加法

/* 一元多多项式的加法 1.先创建链表,存储多项式 2.输出多项式 3.两个多项式相加 4.输出多项式 */ # include # include typedef struct ...

一元多项式求和算法(单链表实现)

/* 单链表的应用举例; 采用单链表存储,则每一个非零项对应单链表中的一个节点, 且单链表应按指数递增序列排列。为了节省空间只存储非零项。 其中: eof为系数域,存放非零项的系数 exp...

(链表实现)写出两个一元多项式相加的算法

/*实验2 3. 试写出两个一元多项式相加的算法。 用链表来存储一元多项式,并且要在程序中验证其功能实现。 此题的源程序保存为2_e1.cpp */ #include using namespace ...
  • wwj_748
  • wwj_748
  • 2011年10月22日 10:06
  • 5910

【c++版数据结构】之用带头节点的单链表实现一元多项式(C语言版)

所实现的一元多项式的结构如下图所示: 若只对多项式进行“求值”等不改变多项式系数和指数的运算,采用类似顺序表的顺序存储结构即可,否则应采用链式存储结构,本文因为要进行一元多项式的加法,加法,乘...

c语言版数据结构(奇迹冬瓜)-链表实战(3)解升序排列的一元多项式相加

//c语言版数据结构(奇迹冬瓜)-链表实战(3)解升序排列的一元多项式相加 /* 主要函数思想: 初始化一元多项式A 初始化一元多项式B 初始化一元多项式C 给一元多项式A赋入数据 给一元多项式B赋...

c语言版数据结构(奇迹冬瓜)-链表实战(4)双链表解一元多项式相乘

//c语言版数据结构(奇迹冬瓜)-链表实战(4)双链表解一元多项式相乘 /* 主要函数思想: 初始化一元多项式A 初始化一元多项式B 初始化一元多项式C 给一元多项式A赋入数据 给一元多项式B赋入数...

学习笔记------数据结构(C语言版)数组之十字链表

//CrossList.cpp #include"predefined.h" #include"CrossList.h" Status InitSMatrix(CrossList *M) ...
  • CYTCHAN
  • CYTCHAN
  • 2016年02月19日 11:36
  • 378

学习笔记------数据结构(C语言版) 静态链表

//Function realization.cpp #include"predefined.h" #include"StaticLinkedList.h" extern SLinkList spa...
  • CYTCHAN
  • CYTCHAN
  • 2016年01月11日 15:09
  • 670

数据结构学习笔记之链表(C语言版)

链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表 由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分...
  • kimg_bo
  • kimg_bo
  • 2015年01月04日 18:34
  • 956

学习笔记------数据结构(C语言版)栈应用 表达式求值

//main.cpp #include "predefined.h" #include "SqStack.h" SElemType EvaluateExpression(); SElemType ...
  • CYTCHAN
  • CYTCHAN
  • 2016年02月04日 12:17
  • 578
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:学习笔记------数据结构(C语言版)链表应用~一元多项式求和
举报原因:
原因补充:

(最多只允许输入30个字)