《数据结构（C语言版）第二版》第二章-线性表（2.8-2.10）

Flerken101

已于 2024-04-21 15:22:08 修改

阅读量200

点赞数 1

分类专栏：《数据结构（C语言版）第二版》文章标签：数据结构 c语言版

于 2024-04-05 23:06:11 首次发布

本文链接：https://blog.csdn.net/qq_44883214/article/details/137411954

版权

《数据结构（C语言版）第二版》专栏收录该内容

7 篇文章 1 订阅

订阅专栏

2.8 案例分析与实现

2.8.1 多项式的创建

//一元稀疏多项式线性链表的定义

typedef struct PNode
{
	float coef;//系数
	int expn; //指数
	struct PNode * next; //指针域
}PNode, * Polynomial;

//算法2.18 多项式的创建

void Createpolyn(Polynomial &P,int n)
{
	//输人m项的系数和指数，建立表示多项式的有序链表P
	P=new PNode;
	P->next=NULL; //先建立一个带头结点的单链表
	
	for(i=1;i<=n;++i) //依次输人n个非零项
	{
		s=new PNode; //生成新结点
		cin>>s->coef>>s->expn; //输人系数和指数
		
		pre=P; //pre用于保存q的前驱，初值为头结点
		q=P->next; //q初始化，指向首元结点
		
		while(q&&q->expn<s->expn)  
		//通过比较指数找到第一个大于输人项指数的项*q
		{
			pre=q;
			q=q->next;
		} //while
		
		s->next=q;	//将输人项s插人到q和其前驱结点pre之间
		pre->next=s;
	} //for
}

单链表C语言实现

#include<stdio.h>
#include<stdlib.h>

struct Lnode {
	float coef;       //系数 
	int expn;         //指数
	struct Lnode* next;
};

struct Lnode* Create(struct Lnode* L, int n);
void printPolyn(struct Lnode* L);
void printPolynTerm(struct Lnode* L);

int main()
{
	struct Lnode* LNODE = NULL;
	struct Lnode* list = Create(LNODE, 5);
	printPolyn(list);
	printPolynTerm(list);

	return 0;
}

//建立多项式单链表 
struct Lnode* Create(struct Lnode* L, int n)
{
	struct Lnode* s;  //申请的新结点

	L = (struct Lnode*)malloc(sizeof(struct Lnode));     //申请头结点 
	L->next = NULL;                          //初始链表置空 

	float c;   //取系数 
	int e;

	struct Lnode* pre = L; //用来遍历现有结点的前驱结点
	struct Lnode* p = L->next; //用来遍历现有节点的结点

	for (int i = 1; i <= n; i++)
	{
		s = (struct Lnode*)malloc(sizeof(struct Lnode));  //申请新结点s
		printf("请输入第%d项的系数：", i);
		scanf_s("%f", &c);
		printf("请输入第%d项的指数：", i);
		scanf_s("%d", &e);
		s->coef = c;                      
		s->expn = e;

		struct Lnode* pre = L; //用来遍历现有结点的前驱结点
		struct Lnode* p = L->next; //用来遍历现有节点的结点
		//每次遍历都要从头开始遍历到尾

		while (p && p->expn < s->expn)
		{
			pre = p;
			p = p->next;
		} //不交换，往后走

		//跳出while循环之后
		s->next = p;
		pre->next = s;
	}
	printf("创建成功！\n");
	return L;
}

//打印多项式
void printPolyn(struct Lnode* L)
{
	struct Lnode* pMove = L->next;
	int i = 0;

	for (i = 1; pMove != NULL; i++)
	{
		printf("第%d个系数：%f\n", i, pMove->coef);
		printf("第%d个指数：%d\n", i, pMove->expn);
		pMove = pMove->next;
	}

	printf("\nList_length : %d\n\n", i);
}

//按多项式表达式打印
void printPolynTerm(struct Lnode* L)
{
	struct Lnode* pMove = L->next;

	while(pMove != NULL)
	{

		if ( pMove->coef != 0)
		{
			if (pMove->coef > 0 && pMove != L->next )
			{
				printf("+");
			}

			if (pMove->expn == 0)
			{
				printf("%.2f", pMove->coef);
			}
			else
			{
				printf("%.2fx^%d", pMove->coef, pMove->expn);
			}
		}
		pMove = pMove->next;
	}
	printf("\n");
}

在这里插入图片描述

顺序表C语言实现

#include <stdio.h>
#include <stdlib.h>

struct PolynomialTerm
{
	float coef;
	int expn;
};

int main()
{
	int numTerms;
	printf("请输入一元多项式的项数：");
	scanf_s("%d", &numTerms);

	struct PolynomialTerm* polynomial = (struct PolynomialTerm*)malloc(numTerms * sizeof(struct PolynomialTerm));
	//polynomial是一个数组的名称，里面的每个元素都是一个struct PolynomialTerm类型的数据。
	//数组的名称也是一个指针，此处为数组申请存储空间时，申请的存储空间大小同顺序表中使用的一维数组一样。
	//经过该动态分配之后，数组名指针polynomial指示顺序表的基地址，数组空间大小为numTerms.

	//读取每个项的系数和指数
	for (int i = 0; i < numTerms; i++)
	{
		printf("请输入第%d项的系数：", i + 1);
		scanf_s("%f", &polynomial[i].coef);  
	
		printf("请输入第%d项的指数：", i + 1);
		scanf_s("%d", &polynomial[i].expn);
	}

	/*
	for (int i = 1; i <= numTerms; i++)
	{
		printf("请输入第%d项的系数：", i);
		scanf_s("%f", &polynomial[i-1].coef);
		printf("请输入第%d项的指数：", i);
		scanf_s("%d", &polynomial[i-1].expn);
	}
	*/


	//根据输入，对指数进行从小到大的排序（相应的系数也要跟着交换）
	//冒泡排序法（从后向前/从前向后，依次比较相邻的元素，如果前面一个数比后面的数大，就交换他们两个的位置。）
	//第二个与第一个数比较；
	//第三个与第二个比较，第二个再与第一个比较；
	//第四个与第三个比较，第三个与第二个比较，第二个再与第一个比较。依次类推。
	//m的最大值为numTerms-1,n的最大值为numTerms-2,n+1可达到最大的下标numTerms-1
	int m = 0;
	int n = 0; 
	int temp1=0;
	float temp2 = 0;

	for (m = 1; m < numTerms; m++)
	{ 
		for (n = m - 1; n >= 0 && polynomial[n].expn > polynomial[n+1].expn; n--)
		{
			temp1 = polynomial[n].expn;
			temp2 = polynomial[n].coef;

			polynomial[n].expn = polynomial[n + 1].expn;
			polynomial[n].coef = polynomial[n + 1].coef;

			polynomial[n + 1].expn = temp1;
			polynomial[n + 1].coef = temp2;
		}
	}


	//打印一元多项式表达式
	printf("一元多项式的表达式为：");

	for (int i = 0; i < numTerms; i++)
	{
		if(polynomial[i].coef != 0)
		{
			//第一次for循环时，i= 0，不执行第一个if判断的语句
			if (i != 0 && polynomial[i].coef > 0)
			{
					printf("+");
			}
	
			if (polynomial[i].expn == 0)
			{
				printf("%.2f", polynomial[i].coef);//宽度.精度
			}
			else
			{
				printf("%.2fx^%d", polynomial[i].coef, polynomial[i].expn);
			}
		}
	}

	printf("\n");

	//释放动态分配的内存
	free(polynomial);

	return 0;
}

在这里插入图片描述

2.8.2 多项式的相加

单链表C语言实现

#include<stdio.h>
#include<stdlib.h>

struct Lnode {
	float coef;       //系数 
	int expn;         //指数
	struct Lnode* next;
};

struct Lnode* Create(struct Lnode* L, int n);
void printPolyn(struct Lnode* L);
void printPolynTerm(struct Lnode* L);
void AddPolyn(struct Lnode* Pa, struct Lnode* Pb);

int main()
{
	struct Lnode* LNODE1 = NULL;
	struct Lnode* LNODE2 = NULL;

	struct Lnode* list1 = Create(LNODE1, 5);
	printPolyn(list1);
	printf("y1 = ");
	printPolynTerm(list1);

	struct Lnode* list2 = Create(LNODE2, 5);
	printPolyn(list2);
	printf("y2 = ");
	printPolynTerm(list2);

	AddPolyn(list1, list2);
	printf("y3 = y1 + y2 = ");
	printPolynTerm(list1);

	return 0;
}

//尾插法建立多项式单链表 
struct Lnode* Create(struct Lnode* L, int n)
{
	struct Lnode* rear = L;  //尾插法的尾指针 
	struct Lnode* s;  //申请的新结点


	L = (struct Lnode*)malloc(sizeof(struct Lnode));     //申请头结点 
	L->next = NULL;                          //初始链表置空 

	float c;   //取系数 
	int e;

	struct Lnode* pre = L; //用来遍历现有结点的前驱结点
	struct Lnode* p = L->next; //用来遍历现有节点的结点

	for (int i = 1; i <= n; i++)
	{
		s = (struct Lnode*)malloc(sizeof(struct Lnode));  //申请新结点s
		printf("请输入第%d项的系数：", i);
		scanf_s("%f", &c);
		printf("请输入第%d项的指数：", i);
		scanf_s("%d", &e);
		s->coef = c;                         //以下是尾插步骤 
		s->expn = e;

		struct Lnode* pre = L; //用来遍历现有结点的前驱结点
		struct Lnode* p = L->next; //用来遍历现有节点的结点
		//每次遍历都要从头开始遍历到尾

		while (p && p->expn < s->expn)
		{
			pre = p;
			p = p->next;
		} //不交换，往后走

		//跳出while循环之后
		s->next = p;
		pre->next = s;

	}
	printf("创建成功！\n");
	return L;
}

//打印多项式
void printPolyn(struct Lnode* L)
{
	struct Lnode* pMove = L->next;
	int i = 0;

	for (i = 1; pMove != NULL; i++)
	{
		printf("第%d个系数：%f\n", i, pMove->coef);
		printf("第%d个指数：%d\n", i, pMove->expn);
		pMove = pMove->next;
	}

	printf("\nList_length : %d\n\n", i);
}

//按多项式表达式打印
void printPolynTerm(struct Lnode* L)
{
	struct Lnode* pMove = L->next;
	int i = 0;

	while(pMove != NULL)
	{

		if ( pMove->coef != 0)
		{
			if (pMove->coef > 0 && pMove != L->next)
			{
				printf("+");
			}

			if (pMove->expn == 0)
			{
				printf("%.2f", pMove->coef);
			}
			else
			{
				printf("%.2fx^%d", pMove->coef, pMove->expn);
			}
		}

		pMove = pMove->next;

	}

	printf("\n");
}

void AddPolyn(struct Lnode* Pa, struct Lnode* Pb)
{	
	//多项式加法：Pa = Pa + Pb, 利用两个多项式的结点构成“和多项式”
	struct Lnode* p1 = Pa->next;
	struct Lnode* p2 = Pb->next;  //pl和p2初值分别指向Pa和Pb的首元结点
	struct Lnode* p3 = Pa;   //p3指向和多项式的当前结点， 初值为Pa
	struct Lnode* r = p2;
	int sum = 0;

	while(p1 && p2)  //pl和p2 均非空
	{
		if (p1->expn == p2->expn)  //指数相等
		{
			sum = p1->coef + p2->coef; //sum保存两项的系数和 

			if (sum != 0)   //系数和不为0
			{
				p1->coef = sum;   //修改Pa当前结点的系数值为两项系数的和
				p3->next = p1; //将修改后的Pa 当前结点链在p3之后， p3指向pl
				p3 = p1;   
				p1 = p1->next;   //pl指向后一项
				
				r = p2;
				p2 = p2->next;
				free(r); //删除Pb当前结点， p2指向后一项
			}
			else //系数和为0
			{
				r = p1;
				p1 = p1->next;
				free(r); //删除Pa当前结点，pl指向后一项

				r = p2;
				p2 = p2->next;
				free(r); //删除Pb当前结点，p2指向后一项
			}
		}
		else if (p1->expn < p2->expn)
		{
			p3->next = p1;
			p3 = p1;
			p1 = p1->next;
		}
		else
		{
			p3->next = p2;
			p3 = p2;
			p2 = p2->next;
		}
	}

	if (p1)
	{
		p3->next = p1;
		p3 = p1;
		p1 = p1->next;
	}
	else
	{
		p3->next = p2;
		p3 = p2;
		p2 = p2->next;
	}

	//另一种写法：p3->next = p1 ? p1 : p2;
	free(Pb);
}