数据结构学习笔记 --- 线性表 （一元多项式的表示及相加）

/* 一元多项式的表示和相加 */
#include "ds.h"
using namespace std;

#ifdef TEST_LIST
typedef 	int 	 ElemType;
#else
typedef struct {
float 	coef; 	//系数
int 	expn; 	//指数
}term, ElemType;  	// 两个类型名：term用于本ADT，ElemType为LinkList的数据对象名

#endif

typedef struct LNode{
ElemType 		data;
struct LNode	*next;
}LNode, *Link, *Position;

typedef struct {
Link 		head, tail;
int			len;
}LinkList;

#ifndef TEST_LIST
typedef LinkList polynomial;
#define DestroyPolyn DestroyList // 与bo2-6.cpp中的函数同义不同名
#define PolynLength ListLength // 与bo2-6.cpp中的函数同义不同名
#endif

void MakeNode(Link &p, ElemType e);
void FreeNode(Link &p);
void InitList(LinkList &L);
void ClearList(LinkList &L);
void DestroyList(LinkList &L);
// h指向L的一个结点，把h当做头结点，将s所指结点插入在第一个结点之前, 形参增加L,因为需修改L
void InsFirst(LinkList &L,Link h,Link s);
// h指向L的一个结点，把h当做头结点，删除链表中的第一个结点并以q返回。
// 若链表为空(h指向尾结点)，q=NULL，返回FALSE
Status DelFirst(LinkList &L, Link h, Link &q);

// 将指针s(s->data为第一个数据元素)所指(彼此以指针相链，以NULL结尾)的
// 一串结点链接在线性链表L的最后一个结点之后，并改变链表L的尾指针指向新的尾结点
void Append(LinkList &L, Link s);
// 已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置。若无前驱，则返回NULL
Position PriorPos(LinkList L, Link p);
// 删除线性链表L中的尾结点并以q返回，改变链表L的尾指针指向新的尾结点
Status Remove(LinkList &L, Link &q);
// 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前，
// 并修改指针p指向新插入的结点
void InsBefore(LinkList &L, Link &p, Link s);

// 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之后，
// 并修改指针p指向新插入的结点
void InsAfter(LinkList &L,Link &p,Link s);
// 已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值
void SetCurElem(Link p, ElemType e);
ElemType GetCurElem(Link p);
Status ListEmpty(LinkList L);
int ListLength(LinkList L);
Position NextPos(Link p);
Position GetHead(LinkList L);
Position GetLast(LinkList L);
// 返回p指示线性链表L中第i个结点的位置，并返回OK，i值不合法时返回ERROR。i=0为头结点
Status LocatePos(LinkList L, int i, Link &p);
// 返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置，
// 若不存在这样的元素，则返回NULL
Position LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType));

void ListTraverse(LinkList L, void(*visit)(ElemType) );
// 已知L为有序线性链表，将元素e按非降序插入在L中。
void OrderInsert(LinkList &L, ElemType e, int (*com)(ElemType, ElemType));
// 若升序链表L中存在与e满足判定函数compare()取值为0的元素，则q指示L中
// 第一个值为e的结点的位置，并返回TRUE；否则q指示第一个与e满足判定函数
// compare()取值>0的元素的前驱的位置。并返回FALSE。(用于一元多项式)
Status LocateElem(LinkList L,ElemType e,Position &q,int(*compare)(ElemType,ElemType));

void MakeNode(Link &p, ElemType e)
{
p = (Link)malloc(sizeof(LNode));
if (!p)
exit(ERROR);
memcpy(&(p->data), &e, sizeof(ElemType));
p->next = NULL;
}
void FreeNode(Link &p)
{
free(p);
p = NULL;
}

// 带头结点的单链表
void InitList(LinkList &L)
{
Link 	p;
p = (Link)malloc(sizeof(LNode));  //生成头结点
if (p)
{
L.head = L.tail = p;
L.tail->next = NULL;
L.len = 0;
}
else
exit(ERROR);
}
void ClearList(LinkList &L)
{
Link 	q, p = L.head->next;

if (0 == L.len)
return;

L.head->next = NULL;
while (p)
{
q = p->next;
free(p);
p = q;
}

L.tail = L.head;
L.len = 0;
}
void DestroyList(LinkList &L)
{
ClearList(L);
FreeNode(L.head);
L.tail = NULL;
L.len = 0;
}
// h指向L的一个结点，把h当做头结点，将s所指结点插入在第一个结点之前, 形参增加L,因为需修改L
void InsFirst(LinkList &L,Link h,Link s)
{
s->next = h->next;
h->next = s;
if (h == L.tail)
L.tail = h->next;
L.len++;
}
// h指向L的一个结点，把h当做头结点，删除链表中的第一个结点并以q返回。
// 若链表为空(h指向尾结点)，q=NULL，返回FALSE
Status DelFirst(LinkList &L, Link h, Link &q)
{
#if 0
q = h->next;
if (h == L.tail)
return FALSE;

h->next = q->next;
if (!q->next)
L.tail = h;

L.len--;
return OK;
#endif
q=h->next;
if(q) // 链表非空
{
h->next=q->next;
if(!h->next) // 删除尾结点
L.tail=h; // 修改尾指针
L.len--;
return OK;
}
else
return FALSE; // 链表空
}

// 将指针s(s->data为第一个数据元素)所指(彼此以指针相链，以NULL结尾)的
// 一串结点链接在线性链表L的最后一个结点之后，并改变链表L的尾指针指向新的尾结点
void Append(LinkList &L, Link s)
{
int 	i = 1;

L.tail->next = s;

if (NULL == s)
return;

while (s->next)
{
s = s->next;
i++;
}

L.tail = s;
L.len += i;
}
// 已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置。若无前驱，则返回NULL
Position PriorPos(LinkList L, Link p)
{
Link 	q = L.head->next;

if (!L.len || 1 == L.len)
return NULL;

while (q->next && q->next != p)
{
q = q->next;
}

if (!q->next)
return NULL;

return q;
}

// 删除线性链表L中的尾结点并以q返回，改变链表L的尾指针指向新的尾结点
Status Remove(LinkList &L, Link &q)
{
Link 	p = L.head;
q = L.tail;

if (!L.len)
{
q = NULL;
return ERROR;
}
while (p->next != L.tail)
{
p = p->next;
}

p->next = NULL;
L.tail = p;

L.len--;
return OK;
}
// 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前，
// 并修改指针p指向新插入的结点
void InsBefore(LinkList &L, Link &p, Link s)
{
Link 	pp = L.head;

while (pp->next && pp->next != p)
pp = pp->next;

if (pp->next)
{
s->next = pp->next;
pp->next = s;
}
else
return;
p = s;
L.len++;
}

// 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之后，
// 并修改指针p指向新插入的结点
void InsAfter(LinkList &L,Link &p,Link s)
{
if (p == L.tail)
{
s->next = p->next;
p->next = s;
L.tail = s;
}
else
{
s->next = p->next;
p->next = s;
}

p = s;
L.len++;
}
// 已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值
void SetCurElem(Link p, ElemType e)
{
memcpy(&(p->data), &e, sizeof(ElemType));
}
ElemType GetCurElem(Link p)
{
return p->data;
}
Status ListEmpty(LinkList L)
{
if (L.len)
return FALSE;
else
return TRUE;

}
int ListLength(LinkList L)
{
return L.len;
}
Position GetHead(LinkList L)
{
return L.head;
}
Position GetLast(LinkList L)
{
return L.tail;
}
Position NextPos(Link p)
{
return p->next;
}
// 返回p指示线性链表L中第i个结点的位置，并返回OK，i值不合法时返回ERROR。i=0为头结点
Status LocatePos(LinkList L, int i, Link &p)
{
int 	j = 0;

if (i < 0 || i > L.len)
return ERROR;
p = L.head;
for (; j < i; j++)
p = p->next;

return OK;
}

// 返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置，
// 若不存在这样的元素，则返回NULL
Position LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
Link 		p = L.head->next;

while (p && !compare(e, p->data))
p = p->next;

if (!p)
return NULL;

return p;
}

void ListTraverse(LinkList L, void(*visit)(ElemType) )
{
Link 	p = L.head->next;

while (p)
{
visit(p->data);
p = p->next;
}
printf("\n");
}

// 已知L为有序线性链表，将元素e按非降序插入在L中。
void OrderInsert(LinkList &L, ElemType e, int (*comp)(ElemType, ElemType))
{
#if 1
Link 	q = L.head, s;
Link 	p = q->next;

MakeNode(s, e);

while (p && comp(p->data, e) < 0) // p不是表尾且元素值小于e
{
q = p;
p = p->next;
}

q->next = s;
s->next = p;

if (!p)  // 插在表尾
L.tail = s;  // 修改尾结点

L.len++;
#else
Link o,p,q;
q=L.head;
p=q->next;
while(p!=NULL&&comp(p->data,e)<0) // p不是表尾且元素值小于e
{
q=p;
p=p->next;
}
o=(Link)malloc(sizeof(LNode)); // 生成结点
o->data=e; // 赋值
q->next=o; // 插入
o->next=p;
L.len++; // 表长加1
if(!p) // 插在表尾
L.tail=o; // 修改尾结点
#endif
}
// 若升序链表L中存在与e满足判定函数compare()取值为0的元素，则q指示L中
// 第一个值为e的结点的位置，并返回TRUE；否则q指示第一个与e满足判定函数
// compare()取值>0的元素的前驱的位置。并返回FALSE。(用于一元多项式)
Status LocateElem(LinkList L,ElemType e,Position &q,int(*compare)(ElemType,ElemType))
{
Link 	p = L.head;

do
{
q = p;
p = p->next;
}while (p && compare(p->data, e) < 0);

if (p && compare(p->data, e) == 0)
{
q = p;
return TRUE;
}
else
{
return FALSE;
}
}

#ifdef TEST_LIST
void print(ElemType e)
{
printf("%d ", e);
}

int comp(ElemType a, ElemType b)
{
return a-b;
}

Status equal(ElemType c1,ElemType c2)
{ // 判断是否相等的函数
if(c1==c2)
return TRUE;
else
return FALSE;
}
#else

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

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

#endif

void OrderInsertMerge(LinkList &L,ElemType e,int(* compare)(term,term))
{ // 按有序判定函数compare()的约定，将值为e的结点插入或合并到升序链表L的适当位置
Position q,s;
if(LocateElem(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);
}
}
else // 生成该指数项并插入链表
{
MakeNode(s,e); // 生成结点
InsFirst(L,q,s);
}
}

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("%f,%d",&e.coef,&e.expn);
if(!LocateElem(P,e,q,cmp)) // 当前链表中不存在该指数项，cmp是实参
{
MakeNode(s,e); // 生成结点并插入链表
InsFirst(P,q,s);
}
}
}

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中当前结点(现为第1个结点)
while(!ListEmpty(Pa)&&!ListEmpty(Pb)&&qa)
{ // Pa和Pb均非空且ha没指向尾结点(qa!=0)
a=GetCurElem(qa);
b=GetCurElem(qb); // a和b为两表中当前比较元素
switch(cmp(a,b))
{
case -1:ha=qa; // 多项式Pa中当前结点的指数值小
qa=NextPos(ha); // ha和qa均向后移1个结点
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))
{
qa = qb;
Pb.tail=hb;
Append(Pa,qa); // 链接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的第1个结点
while(qb)
{
b=GetCurElem(qb);
OrderInsertMerge(Pa,b,cmp);
qb=qb->next;
}
DestroyPolyn(Pb); // 销毁Pb
}

void Opposite(polynomial &Pa)
{ // 一元多项式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);
AddPolyn1(Pa,Pb);
}

void MultiplyPolyn(polynomial &Pa,polynomial &Pb)
{ // 多项式乘法：Pa=Pa×Pb，并销毁一元多项式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;
}

#ifdef TEST_LIST
int main()
{
Link p,h;
LinkList L;
Status i;
int j,k;
InitList(L); // 初始化空的线性表L
for(j=1;j<=2;j++)
{
MakeNode(p,j); // 生成由p指向、值为j的结点
InsFirst(L,L.tail,p); // 插在表尾
}
ListTraverse(L,print); // 输出L
cout << "L'length:"<< ListLength(L) << endl;

OrderInsert(L,0,comp); // 按升序插在有序表头

ListTraverse(L,print); // 输出L
cout << "L'length:"<< ListLength(L) << endl;
for(j=0;j<=3;j++)
{
i=LocateElem(L,j,p,comp);
if(i)
printf("链表中有值为%d的元素。\n",p->data);
else
printf("链表中没有值为%d的元素。\n",j);
}
printf("输出链表：");
ListTraverse(L,print); // 输出L
cout << "L'length:"<< ListLength(L) << endl;
for(j=1;j<=4;j++)
{
printf("删除表头结点：");
DelFirst(L,L.head,p); // 删除L的首结点，并以p返回
if(p)
printf("%d\n",GetCurElem(p));
else
printf("表空，无法删除 p=%u\n",p);
}
printf("L中结点个数=%d L是否空 %d(1:空 0:否)\n",ListLength(L),ListEmpty(L));
MakeNode(p,10);
p->next=NULL; // 尾结点
for(j=4;j>=1;j--)
{
MakeNode(h,j*2);
h->next=p;
p=h;
} // h指向一串5个结点，其值依次是2 4 6 8 10
Append(L,h); // 把结点h链接在线性链表L的最后一个结点之后
OrderInsert(L,12,comp); // 按升序插在有序表尾头
OrderInsert(L,7,comp); // 按升序插在有序表中间
printf("输出链表：");
ListTraverse(L,print); // 输出L
for(j=1;j<=2;j++)
{
p=LocateElem(L,j*5,equal);
if(p)
printf("L中存在值为%d的结点。\n",j*5);
else
printf("L中不存在值为%d的结点。\n",j*5);
}
for(j=1;j<=2;j++)
{
LocatePos(L,j,p); // p指向L的第j个结点
h=PriorPos(L,p); // h指向p的前驱
if(h)
printf("%d的前驱是%d。\n",p->data,h->data);
else
printf("%d没前驱。\n",p->data);
}
k=ListLength(L);
for(j=k-1;j<=k;j++)
{
LocatePos(L,j,p); // p指向L的第j个结点
h=NextPos(p); // h指向p的后继
if(h)
printf("%d的后继是%d。\n",p->data,h->data);
else
printf("%d没后继。\n",p->data);
}
printf("L中结点个数=%d L是否空 %d(1:空 0:否)\n",ListLength(L),ListEmpty(L));
p=GetLast(L); // p指向最后一个结点
SetCurElem(p,15); // 将最后一个结点的值变为15
printf("第1个元素为%d 最后1个元素为%d\n",GetCurElem(GetHead(L)->next),GetCurElem(p));
MakeNode(h,10);
InsBefore(L,p,h); // 将10插到尾结点之前，p指向新结点
p=p->next; // p恢复为尾结点
MakeNode(h,20);
InsAfter(L,p,h); // 将20插到尾结点之后
k=ListLength(L);
printf("依次删除表尾结点并输出其值：");
for(j=0;j<=k;j++)
if(!(i=Remove(L,p))) // 删除不成功
printf("删除不成功 p=%u\n",p);
else
printf("%d ",p->data);
MakeNode(p,29); // 重建具有1个结点(29)的链表
InsFirst(L,L.head,p);
DestroyList(L); // 销毁线性链表L
printf("销毁线性链表L之后: L.head=%u L.tail=%u L.len=%d\n",L.head,L.tail,L.len);
}
#else

int main()
{
polynomial p,q;
int m;
printf("请输入第1个一元多项式的非零项的个数：");
scanf("%d",&m);
CreatPolyn(p,m);
printf("请输入第2个一元多项式的非零项的个数：");
scanf("%d",&m);
CreatPolyn(q,m);
AddPolyn(p,q);
//SubtractPolyn(p,q);
printf("2个一元多项式相加的结果：\n");
PrintPolyn(p);

printf("请输入第3个一元多项式的非零项的个数：");
scanf("%d",&m);
CreatPolyn(q,m);
AddPolyn1(p,q);
printf("2个一元多项式相加的结果(另一种方法)：\n");
PrintPolyn(p);
printf("请输入第4个一元多项式的非零项的个数：");
scanf("%d",&m);
CreatPolyn(q,m);
SubtractPolyn(p,q);
printf("2个一元多项式相减的结果：\n");
PrintPolyn(p);
printf("请输入第5个一元多项式的非零项的个数：");
scanf("%d",&m);
CreatPolyn(q,m);
MultiplyPolyn(p,q);
printf("2个一元多项式相乘的结果：\n");
PrintPolyn(p);
DestroyPolyn(p);

}

#endif