[数据结构]第二章--线性表(读书笔记4)

LinkList.h

#include "c1.h"

/*具有实用意义的线性链表,一个带头结点的线性链表*/
typedef struct LNode{/*结点类型*/
	ElemType data;
	struct LNode *next;
}*Link,*Position;

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

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 DestroyList(LinkList *L)
{ /* 销毁线性链表L，L不再存在 */
	ClearList(L); /* 清空链表 */
	FreeNode(&(*L).head);
	(*L).tail = NULL;
	(*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 */
	//if ((*L).head == (*L).tail || (*L) == NULL || h == NULL){
	//	*q = NULL;
	//	return FALSE;
	//}
	*q = h->next;
	h->next = h->next->next;
	if( !h->next ){ /* 删除尾结点 */
		(*L).tail = h; /* 修改尾指针 */
	}
	(*L).len--;
	return TRUE;
}
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 = L.head->next;
	if(q == p){ /* 无前驱 */
		return NULL;
	}
	else{
		/* q不是p的直接前驱 */
		while (q->next != p){
			q = q->next;
		}
		return q;
	}
}
Status Remove(LinkList *L,Link *q)
{ /* 删除线性链表L中的尾结点并以q返回，改变链表L的尾指针指向新的尾结点 */
	Link p=(*L).head;
	if((*L).len == 0) /* 空表 */
	{
		*q=NULL;
		return FALSE;
	}
	while(p->next != (*L).tail){
		p = p->next;
	}
	*q = (*L).tail;
	p->next = NULL;
	(*L).tail = p;
	(*L).len--;
	return OK;
}
Status InsBefore(LinkList *L, Link *p, Link s)
{	/* 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前， */
	/* 并修改指针p指向新插入的结点 */
	Link q;
	q = PriorPos(*L,*p); /* q是p的前驱 */
	if(!q){ /* p无前驱 */
		q=(*L).head;
	}
	s->next = *p;
	q->next = s;
	*p = s;
	(*L).len++;
	return OK;
}
Status InsAfter(LinkList *L, Link *p, Link s)
{	/* 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之后， */
	/* 并修改指针p指向新插入的结点 */
	if( *p == (*L).tail ){ /* 修改尾指针 */
		(*L).tail = s;
	}
	s->next = (*p)->next;
	(*p)->next = s;
	*p = s;
	(*L).len++;
	return OK;
}
Status SetCurElem(Link p,ElemType e)
{ /* 已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值 */
   p->data=e;
   return OK;
}
ElemType GetCurElem(Link p)
{ /* 已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值 */
	return p->data;
}
Status ListEmpty(LinkList L)
{	/* 若线性链表L为空表，则返回TRUE，否则返回FALSE */
	if(L.len){
		return FALSE;
	}
	else{
		return TRUE;
	}
}
int ListLength(LinkList L)
{ /* 返回线性链表L中元素个数 */
	return L.len;
}
Position GetHead(LinkList L)
{ /* 返回线性链表L中头结点的位置 */
	return L.head;
}
Position GetLast(LinkList L)
{ /* 返回线性链表L中最后一个结点的位置 */
	return L.tail;
}
Position NextPos(Link p)
{	/* 已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置 */
	/* 若无后继，则返回NULL */
	return p->next;
}
Status LocatePos(LinkList L, int i, Link *p)
{ /* 返回p指示线性链表L中第i个结点的位置，并返回OK，i值不合法时返回ERROR */
	int count = 0;
	if( i < 0 || i > L.len){
		return ERROR;
	}
	*p = L.head;
	for(count = 0; count < i; count++){
		*p = (*p)->next;
	}
	return OK;
}
Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType))
{	/* 返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置， */
	/* 若不存在这样的元素，则返回NULL */
	Link p = L.head;
	do{
		p = p->next;
	}while (p && !compare(p->data, e) );
	return p;
}
Status ListTraverse(LinkList L, void(*visit)(ElemType))
{ /* 依次对L的每个数据元素调用函数visit()。一旦visit()失败，则操作失败 */
	Link p=L.head->next;
	int j;
	for(j=1;j<=L.len;j++){
		visit(p->data);
		p = p->next;
	}
	printf("\n");
	return OK;
}
Status OrderInsert(LinkList *L, ElemType e, int (*comp)(ElemType,ElemType))
{ /* 已知L为有序线性链表，将元素e按非降序插入在L中。（用于一元多项式） */
	Link o,p,q;
	q = (*L).head;
	p = q->next;
	/* p不是表尾且元素值小于e */
	while (p != NULL && comp(e, p->data) < 0){
		q = p;
		p = p->next;		
	}
	o = (Link)malloc(sizeof(LNode)); /* 生成结点 */
	o->data = e; /* 赋值 */
	q->next = o;
	o->next = p;
	(*L).len++;
	if(!p){ /* 插在表尾 */
		(*L).tail = o; /* 修改尾结点 */
	}
	return OK;
}
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;
   }
}

多项式表示：

typedef LinkList polynomial;
#define DestroyPolyn DestroyList

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;
		}
	}
}
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);
	}
}
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(!LocateElemP(*P, e, &q, cmp)){ /* 当前链表中不存在该指数项,cmp是实参 */
			if( MakeNode(&s,e) ){ /* 生成结点并插入链表 */
				InsFirst(P, q, s);
			}
		}
	}
}
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;
	}
}
void AddPolyn(polynomial *Pa,polynomial *Pb) /* 算法2.23 */
{ /* 多项式加法:Pa=Pa+Pb,并销毁一元多项式Pb */
/*
1.指针qa所指结点的指数值 < 指针qb所指结点的指数值
  则应摘取qa指针所指结点插入到"和多项式"链表中去
2.指针qa所指结点的指数值 == 指针qb所指结点的指数值
  则将两个结点中的系数相加，若和数不为零则修改qa所指结点的系数值，同时释放qb结点
3.指针qa所指结点的指数值 〉指针qb所指结点的指数值
  则应摘取指针qb所指结点插入到"和多项式"链表中去
*/
	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(!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均向后移一个结点 */
			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 = NextPos(ha);
			qb = NextPos(hb);
		}
	}
	if(!ListEmpty(*Pb)){
		(*Pb).tail = hb;
		Append(Pa, qb); /* 链接Pb中剩余结点 */
	}
	DestroyPolyn(Pb); /* 销毁Pb */
}
void Opposite(polynomial Pa)
{ /* 一元多项式系数取反 */
	Position p;
	p = Pa.head;
	while(p->next){
		p = p->next;
		p->data.coef *= -1;
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	polynomial p,q;
	int m;

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