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

已于 2024-04-21 15:22:08 修改
阅读量253 收藏 1
点赞数 2
分类专栏： 《严蔚敏 数据结构（C语言版）第二版》 文章标签： 数据结构 c语言版
于 2024-04-05 23:06:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44883214/article/details/137411954
版权

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);
}

在这里插入图片描述

各算法时间复杂度和空间复杂度

在这里插入图片描述

Flerken101
关注
专栏目录
数据结构和算法教程（C语言版）
数据结构和算法教程（C语言版）
11-04 1114
数据结构研究的是数据之间的关系，再进一步说，它研究的是多份数据之间的分布、排列和勾连的关系，以及在此基础之上如何进行高效的增删改查操作。数据结构是计算机专业的基础课程，也是所有程序员的内功心法；不懂数据结构就是写代码的农民，了解数据结构才能成为行业专家。六年创作，三次迭代，千般打磨，成就了现在这套精品的数据结构和算法教程。为了降低阅读门槛，本教程所有代码都基于C语言编写。
第二章.线性表（严版教材相关代码）
ljz2015301785的博客
04-09 335
线性结构：线性表，栈和队列，串。        线性结构特点：1、存在唯一的一个第一个数据元素。2、存在唯一的一个最后一个数据结构。3、除开头结尾元素外，每个元素只有一个前驱，一个后继。顺序表相关代码：例2-1.将所有在线性表Lb中但不在La中的数据元素插入到La中 void union(list &amp;La,list Lb){    La_len=listLength(La),Lb_len=...
一元多项式建立相加（17计科班教学用）
智慧源
04-04 633
#include<iostream> using namespace std; #define MAXSIZE 100 #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int ElemType; typedef int Status; typedef struct PNode{ float coef;//系数 in...
数据结构与算法——第二章 线性表（5）
清园暖歌的博客
03-25 1167
2.7 线性表的应用 2.7.1 线性表的合并 算法思想：依次取出Lb中的每个元素，执行以下操作： 1. 在La中查找该元素； 2. 如果找不到，则将其插入La的最后。 void union(List &La, List Lb){ La_len = ListLength(La); Lb_len = ListLength(Lb); for(i=1; i<=Lb_len; i++) { GetElem(Lb, i, e);
《数据结构（C语言版）第二版》第二章-线性表（2.1-2.5）
qq_44883214的博客
03-18 1078
这里写目录标题
数据结构(C语言版）-第二章线性表
qq_43071699的博客
07-12 1428
ADT List操作结果：构造一个空的线性表L初始条件：线性表L已存在。操作结果，销毁线性表L。初始条件：线性表L巳存在。操作结果：将L重置为空表。初始条件：线性表L已存在。操作结果：若L为空表，则返回 TRUE, 否则返回 FALSE。初始条件：线性表L已存在。操作结果：返回L中数据元素个数。初始条件：线性表 已存在， 1i操作结果：用e返回L中第i个数据元素的值。初始条件：线性表L已存在， compare() 是数据元素判定函数。
C语言数据结构【手抄版】第二章 线性表
难拳的博客
04-07 1139
数据结构线性表结构，动态数组实现原理，链表实现原理！
线性表-第2章-《数据结构习题集》答案解析-严蔚敏吴伟民版
热门推荐
StrayedKing-245176013
12-26 8万+
严蔚敏吴伟民版《数据结构习题集》第2章线性表部分答案+习题解析。
数据结构-c语言读书报告,数据结构读书笔记（一）（C语言）
weixin_36275231的博客
05-19 438
第一章 关于数据结构1.数据结构研究什么？(计算机加工的对象由数值——>非数值)将现实生活中大量而复杂的问题(非数值问题)以特定的数据类型(逻辑结构)和特定的存储结构(物理结构)保存到主存储器中，以及在此基础上为实现某个功能(删除、排序)相对应的操作。重点理解：1. 包含的数据元素2.元素之间的关系3.这些数据元素在计算机上如何存储4.建立在这种数据结构上的操作2.数据的逻辑结构： 3....
数据结构(第二版)习题.docx
10-10
#### 第二章 线性表 **2.1 描述以下三个概念的区别：头指针，头结点，首元素结点。** - **头指针**：指向链表第一个结点的指针。 - **头结点**：在链表的第一个实际数据元素结点之前附加的一个结点。 - **首元素...
数据结构（java版）习题解答
10-14
### 数据结构（Java版）习题解答概览 #### 第0章 Java程序设计基础 **实验0.1：哥德巴赫猜想** - **题目**：实现哥德巴赫猜想，即任何大于2的偶数都可以表示为两个质数之和。 - **解答**：通过编写一个函数来检测...
【数据结构】手写单链表【纯C语言版】
weixin_43113381的博客
10-30 679
摘要：本章主要讲述线性表的链式表示和用C语言实现单链表 目录1. 链表1.1 什么是单链表1.2 单链表的逻辑图1.3 顺序表和单链表物理结构的对比2.单链表的代码实现2.1 定义单链表的存储结构2.2 单链表结点的空间开辟2.3 单链表查尾2.4 单链表尾插法2.5 打印链表2.6 单链表头插法2.7 单链表头删法2.8 单链表的查找2.9 单链表的修改2.10 单链表的插入2.11 单链表的删除2.12 计算链表长度2.13 销毁单链表3. 源码链接后记 正文开始 1. 链表 1.1 什么是单链表
数据结构，问题 F: 括弧匹配检验
nick_912912的博客
11-02 226
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
python数据类型-8-数据结构-Queue (队列)
Lookontime的博客
10-30 314
在python数据类型系列文章中已经介绍了 python的各种数据类型，队列（Queue）是一种非常重要的数据结构，但并不是python的数据类型，队列遵循先进先出（FIFO）的原则，即先插入的元素先被移除，主要的用途是为了支持线程安全和高效的队列操作而设计的！
代码随想录：从中后/中前遍历序列构造二叉树
qq_74924951的博客
10-30 314
两种遍历生成二叉树
数据结构(8.7_1)——外部排序
最新发布
m0_65240792的博客
11-03 93
输出缓冲区1空了用归并段1的下一块元素补上 ..... 顺序的两个归并段方法一样..... 由于文件总块数无法改变，所以只能对归并趟数进行改变 注意：k不能无限增大、若k太大了也会增加内部归并所需时间在缓冲区内直接排序
数据结构之树
x6886_57的博客
11-03 412
树的定义，树的逻辑表示方法，树的基本术语，树的性质，树的存储结构
[数据结构]堆
2401_83816455的博客
10-29 279
堆，本质是一颗完全二叉树。代码实现可参考树的代码。
数据结构初阶排序全解
枫の大一分享
11-03 709
排序顾名思义，就是将一组乱序的数，按从大到小或者从小到大进行排列的操作。常见的排序如下可以看到排序也是有分类的，既然有分类，那么这边给出宝子们一个思考，在最后测试的时候给出答案，思考1：排序方法这么多，哪个最好呢？最差的有什么用呢？那么废话不多说，今天的重点内容就是理解并写出一个个排序算法，现在直接上高速，带着宝子们攻破一个个排序算法！这边给出各个排序算法的声明，会在对应内容进行解释，宝子们先有个印象即可~~今天讲解了各种类型的排序算法，最常用的还是时间复杂度最小的堆排序、快排、归并排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值