数据结构——线性关系

最新推荐文章于 2024-07-07 15:50:59 发布
最新推荐文章于 2024-07-07 15:50:59 发布
阅读量1k 收藏 28
点赞数 29
文章标签： 数据结构 linux c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72168217/article/details/136504108
版权

数据结构——线性关系

🍃线性关系

两个变量之间存在一次方函数关系，就称它们之间存在线性关系。

🌿线性关系的顺序存储

顺序表：（以学生管理系统为例子）
特点：

  1. 元素是一对一的
  2. 在逻辑上相邻的元素，在物理空间上也相邻
  3. 大小固定
  4. 对于静态顺序表：表满不能存、表空不能取

🍀顺序表的定义

typedef struct student
{
	char name[20];
	char add[20];
}data_type;

typedef struct list
{
	data_type (*Data)[]; //指向数组的指针,存储空间
	int size； //当前顺序表的存储能力
	int count; //表示当前表实际有效元素的个数
}List;

🍀创建动态顺序表

//函数功能：创建顺序表
//函数形式参数的作用：传递信息
//函数参数：void
//函数返回值：地址，指向创建的顺序表
//定义函数：函数返回值数据类型 函数名(形参列表)

List *CreatList(void)
{
	int mysize = 0;
	List *pList = NULL;
	puts("请输入要创建的大小:");
	scanf("%d", &mysize);
	//1。创建顺序表
	pList = (List *)malloc(sizeof(List));
	if(NULL == pList)
	{
		perror("Creat error");
		return NULL;
	}
	memset(pList, 0, sizeof(List));
	//2。创建顺序表的存储空间
	pList->Data = (data_type *)malloc(mysize * sizeof(data_type)); //void *malloc(size);
	if(NULL == pList->Data)
	{
		perror("Creat error");
		return NULL;
	}
	memset(pList->Data, 0, mysize * sizeof(data_type));
	//给大小赋值
	pList->size = mysize;
	return pList;
}

🍀插入元素

//函数功能：插入元素
//函数参数1：被插入的表
//函数参数2：插入元素的位置
//函数参数3：插入的值
//函数返回值：成功返回OK，失败返回原因

int InserItem(List *pList, int pos, date_type item)
{
	//入参判断
	if(!pList)
	{
		return LIST_NULL;
	}
	//位置判断
	if(pos < 0 || pos > pList->count)
	{
		return POS_ERROR;
	}
	//空满判断
	if(pList->count == pList->size)
	{
		return LIST_FULL;
	}
	//移出插入空间
	for(int i=pList->count; i>pos; i--)
	{
		//将当前位置的元素后移
		pList->Data[i] = pList->Data[i-1];
	}
	//插入元素
	pList->Data[pos] = item;
	//总数增加
	pList->count++;
	return OK;
}

🍀显示元素

//函数功能：显示元素
//函数参数：要显示的表
//函数返回值：成功返回OK，失败返回原因

int ShowList(List *pList)
{
	//入参判断
	if(!pList)
	{
		return LIST_NULL;
	}
	//空表判断
	if(pList->count == 0)
	{
		return LIST_EMPTY;
	}
	//打印元素
	for(int i=0; i<pList->count; i++)
	{
		printf("%d ",pList->Data[i]);
	}
	printf("\n");
	return OK;
}

🍀删除元素

//函数功能：删除元素
//函数参数1：要删除元素的表
//函数参数2：删除的位置
//函数参数3：删除的值
//函数返回值：成功返回OK，失败返回原因

int DeleteItem(List *pList, int pos, data_type *item)
{
	//入参判断
	if(!pList)
	{
		return LIST_NULL;
	}
	//空表判断
	if(pList->count == 0)
	{
		return LIST_EMPTY;
	}
	//位置判断
	if(pos < 0 || pos >= pList->count)
	{
		return POS_ERROR;
	}
	//移动元素
	for(int i=pos; i<pList->count-1; i++)
	{
		pList->Data[i] = pList->Data[i+1];
	}
	//总数减少
	pList->count--;
	return OK;
}

🍀销毁顺序表

//函数功能：销毁顺序表
//函数参数：要销毁的表
//函数返回值：成功返回OK，失败返回原因

int Destory(List **pList)
{
	//入参判断
	if(!pList)
	{
		return LIST_NULL;
	}
	//销毁存储空间
	free((*pList)->Data);
	//销毁表
	free(*pList);
	//重置
	*pList = NULL;
	return OK;
}

🍀导入导出

使用 read 导入

1.打开文件
2.read
3.关闭文件

使用 write 导出

1.打开文件
2.wirte
3.关闭文件

关于read，write详见《关于linux下c语言的文件IO》←”点我直达“中对文件的读和写案例

🌿线性关系的链式存储

🍀单链表

  1. 单链表的每个节点包含两个部分：数据域和指针域。
  2. 数据域存储节点的值或数据。
  3. 指针域存储指向下一个节点的指针，即单链表的指针指向下一个节点。
  4. 单链表只能从头节点开始顺序访问，通过指针域进行节点之间的连接。
  5. 单链表只能单向遍历，即只能从头节点开始，沿着指针域逐个访问下一个节点。
  6. 无法逆向检索，有时候不太方便
☘️单链表的定义
typedef struct student
{
	char name[20];
	char add[20];
}data_type;

//定义单链表节点
typedef struct link_node
{
	data_type Data; //存放数据的数据域
	struct link_node *Next;//存放指向下一个节点的地址的指针域
}LNode;
☘️单链表的创建

//函数功能：创建表节点
//函数参数：void
//函数返回值：成功返回地址，失败返回NULL

LNode *CreatNode(void)
{
	LNode *pHead = NULL;
	//申请空间
	pHead = (LNode *)malloc(sizeof(LNode));
	//判断是否成功
	if(!pHead)
	{
		perror("malloc error");
		return NULL;
	}
	//空间清零
	memset(pHead, 0, sizeof(LNode));
	//返回创建的地址
	return pHead;
}
☘️插入元素

在这里插入图片描述
头插法：

顾名思义，头插法是将新的元素插入到头结点的后面。先将头结点与首节点联系断开，将首节点的地址（存放在头结点的指针域）赋给要插入的新节点的指针域，这样子新节点就和后面的所有节点连接了起来，起到了保护后面所有节点的作用
然后将新节点的地址赋值给头结点的指针域，覆盖掉原本存放的首节点的地址，这样操作就完成了对链表的头结点插入元素

尾插法

顾名思义，尾插法就是将新的节点插入到链表的的最后面，也就是尾节点之后。它的做法和头插法一样，只是要如何才能找到尾结点首先，我们定义一个指针变量，并将其初始化为头结点;然后我们可以发现，只有尾结点的指针域为NULL，则可以执行循环，每当我们所定义的指向头节点的指针变量的指针域不为NULL的时候，就让其后移一位，直到循环结束，找到了指针域为NULL的尾结点，然后将新节点插入到之后，并将新节点的指针域置为NULL

中间插入法

中间插入就是将数据元素插入到链表的中间位置
首先，定义一个指针变量，初始化为头结点，需要找到插入节点的前一个节点因为，要插入的位置的前一个节点保存了要插入位置的后一个节点的地址知道了后面节点的地址才能对其进行操作

//函数功能：插入元素
//函数参数1：要插入的表
//函数参数2：要插入的位置

TATL表示尾插
HEAD表示头插
直接输入位置则是中间插入

//函数参数3：要插入的值
//函数返回值：成功返回OK，失败返回原因

int InstertItem(LNode *pHead, int pos, data_type item)
{
	LNode *pNew = NULL;
	LNode *pTmp = pHead;
	int i = 0;
	//入参判断
	if(!pHead)
	{
		return LINK_NULL;
	}
	//创建节点
	pNew = CreatNode();
	//赋值
	pNew->Data = item;
	//插入位置判断
	switch(pos)
	{
		case TATL://尾插
			//找尾节点
			while(pTmp->Next != NULL)
			{
				pTmp = pTmp->Next;
			}
			//插入
			pTmp->Next = pNew;
			return OK;
		case HEAD://头插
			//保护后续节点
			pNew->Next = pHead->Next;
			//插入
			pHead->Next = pNew;
			return OK;
		default://中间插入
			//找插入位置
			while(i < pos && pTmp ！= NULL)
			{
				pTmp = pTmp->Next;
				i++
			}
			//错误判断
			if(!pTmp)
			{
				return POS_ERROR;
			}
			//保护后续节点
			pNew->Next = pHead->Next;
			//插入
			pTmp->Next = pNew;
			return OK;
	}
}
☘️显示元素

//函数功能：显示元素
//函数参数：要显示的元素
//函数返回值：成功返回OK，失败返回原因

int ShowLink(LNode *pHead)
{
	LNode *pTmp = NULL;
	//入参判断
	if(!pHead)
	{
		return LINK_NULL;
	}
	//空表判断
	if(!pHead->Next)
	{
		return LINK_EMPTY;
	}
	pTmp = pHead->Next;
	//显示链表
	while(pTmp)
	{
		printf("%d",pTmp->Data);
		pTmp = pTmp->Next;
	}
	printf("\n");
	return OK;
}
☘️删除元素

//函数功能：删除元素
//函数参数1：被删除节点的表
//函数参数2：删除的位置
//函数参数3：删除的值
//函数返回值：成功返回OK，失败返回原因

int DeleteNode(LNode *pHead, int pos, data_type item)
{
	LNode *pDel_Pre = NULL;
	LNode *pDel = NULL;
	int i = 0;
	//入参判断
	if(!pHead)
	{
		return LINK_NULL;
	}
	//空表判断
	if(!pHead->Next)
	{
		return LINK_EMPTY;
	}
	//将pDel_Pre设置成头节点
	pDel_Pre = pHead;
	//将pDel设置成首节点
	pDel = pHead->Next;
	//位置判断
	switch(pos)
	{
		case TATL://尾删
			//找尾节点
			while(pDel->Next != NULL)
			{
				pDel_Pre = pDel_Pre->Next;
				pDel = pDel->Next;
			}
			//保存元素
			*item = pDel->Data;
			//删除节点
			pDel_Pre->Next = pDel->Next;
			//释放空间
			free(pDel);
			return OK;
		case HEAD://头删
			//保存元素
			*item = pDel->Data;
			//删除节点
			pDel_Pre->Next = pDel->Next;
			//释放空间
			free(pDel);
			return OK;
		default://中间删
			//寻找删除位置
			while(i < pos && pDel != NULL)
			{
				pDel_Pre = pDel_Pre->Next;
				pDel = pDel->Next;
				i++;
			}
			//错误判断
			if(!pDel)
			{
				return POS_ERROR;
			}
			//保存元素
			*item = pDel->Data;
			//删除节点
			pDel_Pre->Next = pDel->Next;
			//释放空间
			free(pDel);
			return OK;
	}
}
☘️销毁单链表

采用头删法删除所有的数据节点，之后再free头节点。

🍀双链表

  1. 双链表的每个节点包含三个部分：数据域、指向前一个节点的指针和指向下一个节点的指针。
  2. 数据域存储节点的值或数据。
  3. 前驱指针指向前一个节点，后继指针指向下一个节点。
  4. 双链表可以双向遍历，既能从头节点顺序遍历，也可以从尾节点逆序遍历。
  5. 双链表相较于单链表需要额外存储指向前一个节点的指针，因此会在空间上占用更多的内存。
  6. 可进可退，存储密度更低一点
☘️双链表的定义
typedef struct student
{
	char name[20];
	char add[20];
}data_type;

typedef struct doublelinknode
{
	struct doublelinknode *Pre;//前驱指针
	data_type Data;//存放数据的数据域
	struct doublelinknode *Next;//后继指针
}DbNode;
☘️双链表的其他操作

双链表的其他操作与单链表类似不多赘述

🌿顺序表、链表、线性表的区别

线性表是一种逻辑结构，表示的是1对1的线性关系
顺序表和链表是线性表在不同的存储下的不同体现
顺序表：

  1. 逻辑上相邻的元素，在物理空间上也相邻
  2. 插入删除不方便，查询方便
  3. 空间的存储效率最大可达到1
  4. 对于静态的顺序表来说，表满不能存，表空不能取
  5. 顺序表对空间的要求比较高
  6. 容易有空间碎片的产生

链表：

  1. 逻辑上相邻的元素，在物理空间上不一定相邻
  2. 插入删除方便，查询不方便
  3. 空间的存储效率<1
  4. 表的长度较为灵活
  5. 对空间的要求没有那么大
  6. 对编译环境有要求，必须要求编译环境支持指针类型操作

如何选择顺序表还是链表：

  1. 基于操作分析：
    如果更多的是插入、删除操作，优先选择链表，如果更多的是查询操作，优先选择顺序表
  2. 基于空间的要求：
    如果对空间的存储密度有要求，优先选择顺序表，否则选择链表，因为链表对空间的包容性比较大，链表 不容易出现碎片
  3. 基于编译环境的要求：
    如果编译环境不支持指针类型操作，只能使用顺序表。
不编程的鑫心
关注
  • 29
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
数据结构——线性表
楚兴
01-24 1088
1 线性表的特性是数据元素之间在逻辑结构上存在着线性关系，在计算机中表示这种关系的两类不同的存储结构是顺序存储结构和链式存储结构。用前者表示的线性表简称为顺序表，用后者表示的线性表简称为链表。 2 当线性表的长度n=0时，为一个空表。当n>0时，序列中必存在唯一的一个“第一个元素”，也必存在唯一的一个“最后一个元素”。除第一个元素外，每一个元素均有唯一的前驱；除最后一个元素外，每一个元素
数据结构--线性关系
l_heeee的博客
03-29 268
已知一个单项链表的某个节点p,其他未知. 请你在p节点之前插入q节点.已知一个单向链表,pthead.，请你找出中间节点,要求一次遍历.链表 按需分配，不连续，浪费一点点 删除插入简单，不支持随机访问。链表最重要的是头部，已知头部，可以获取每个元素（千万不要丢）已知一个单项链表的某个节点p,其他未知. 请删除掉p 节点.只在 链表头部进行插入和删除操作,即可以实现先进后出。单向链表逆序输出：！数组 一次分配 删除插入很麻烦、支持随机访问。栈只能允许在一端进行插入和删除的线性表。特点：空间要求一次分配。
数据结构——线性数据结构
SilentLand的博客
05-11 4251
线性数据结构：栈、对列
数据结构，线性表与线性结构关系，顺序表与顺序结构关系，线性表与顺序表关系
qq_52119661的博客
08-19 955
数据结构中存在线性表与线性结构关系，顺序表与顺序结构关系
数据结构——线型关系
qq_56434030的博客
09-15 416
​ 一、定义： 逻辑关系：首元素没有直接前驱，尾元素没有直接后继，其余元素有且只是一个直接前驱和直接后继。 具体分类：表，栈（先进后出），队列（先进先出）。 存储关系：顺序表，链表，顺序栈，链式栈，顺序队列，链式队列。 二、顺序表和链表： 顺序表：以数组形式保存的线性表。以下标进行引用。 链表：链式存储，以节点方式链接，节点中保存当前节点的数据和下一节点的位置。 增加：分为头插和尾插两种方式 头插：从头部插入，头插可以在
数据结构之线性结构和非线性结构
weixin_43520450的博客
06-29 3304
线性结构和非线性结构一、线性结构1.1 基本概念1.2 部分实现（1）顺序表（顺序存储）（2）链表（链式存储）（3）栈（4）队列二、非线性结构2.1 相关概念（1）二叉树（2）满二叉树（3）完全二叉树2.2 二叉树存储结构（1）顺序存储（2）链式存储2.3 树与二叉树的转换（1）树转二叉树（2）二叉树转树2.4 树的遍历代码实现 一、线性结构 1.1 基本概念 （1）线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 （2）线性结构拥有两种不同的存储结构，即顺序存储结构和链式存储结构。
数据结构——图论
02-06
在这个“数据结构——图论”的压缩包中，我们很显然会探讨图的相关概念以及一种重要的算法——Dijkstra算法，特别是在邻接表的实现上。 首先，让我们了解什么是图。在计算机科学中，图是由一组顶点（或节点）和连接...
数据结构——单链表.zip
09-16
本资料包"数据结构——单链表.zip"专注于单链表的实现，特别针对严蔚敏教授的数据结构教材内容进行了完整的编程实现。下面，我们将深入探讨单链表及其相关操作。 单链表是一种线性数据结构，每个元素称为节点，每个...
算法和数据结构——左程云.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构——导图.rar
04-30
这份“数据结构——导图.rar”压缩包包含了关于数据结构的详细思维导图，一共分为7个章节，涵盖了数据结构的基础到高级主题。 1. **线性表**：线性表是最基础的数据结构之一，它是由n（n>=0）个相同类型元素构成的...
数据结构实验——串子系统
07-31
数据结构实验——串子系统是计算机科学中关于数据组织的一个重要课题，主要涉及字符串的处理和操作。在C语言中，字符串是由字符序列组成的，它在内存中以字符数组的形式存在。本实验的目的是深入理解和掌握字符串...
数据结构的线性关系
风翼随心的博客
10-21 2643
数据结构的线性关系 线性关系：里面的每一个元素都是平等的，每个节点至多有一个前驱和一个后继。头部没有前驱，尾部没有后继。其结构类似于一维数组的结构。 如下图所示： 顺序存储结构 删除操作：对某一元素进行删除，其后面的元素都要往前移动一个单位。浪费CPU资源 插入操作：对数组中某一单元进行插入，后面的元素都要往后移动一个单位。操作麻烦。 缺点：一次空间分配，大小恒定，如果空间不够，无解；如果没有用...
数据结构——线性结构
weixin_35016347的博客
09-03 1836
线性结构区别于非线性结构，通常这种数据结构中的数据元素呈现一种线性关系。 主要包括数组、链表、栈和队列这四种。数组数组是一组有序定长的元素集合。 如int array[] = {0,1,2,3,4,5,6}; 由于数组的元素在内存中的地址是连续的，因此它的特点是随机访问速度快。多维数组多维数组可以多下标表示类似平面甚至空间这种概念，其本质也是一维数组来实现。 如int array[2][3]
线性回归相关系数c语言,线性回归方程和线性相关系数计算实例
weixin_30934229的博客
05-20 3639
回归分析是一种统计分析方法，用于研究多个统计量之间的关系，并利用关系进行预测。线性回归模型是最简单的回归分析模型，下面我们应用线性回归来预测票房。图8-5是计算机模拟生成的500个数据点，每个点表示一部电影，横坐标是预告片搜索量，纵坐标是票房。图8-5称为散点图，是统计分析中最简单、最常用的图，用于对数据的规律做初步观察。观察图8-5可以发现，这些数据点大多分布在一条直线附近，这条直线代表了这些数...
数据结构—线性结构—线性及其实现
这里是博客~
08-23 1660
2.1线性及其实现一、如何表示多项式方法1：顺序存储结构直接表示 这个方法用了一个数组，把数组的对应系数存了起来。这个方法的优点是：多项式相加比较好算，缺点是：下面要表示2000次的时候，要一个2001大的数组，显然是巨大的浪费。方法2：顺序存储结构表示非零项特点，只表示非零向量。每个非零向量有两个信息，系数和指数，所以可以将一个多项式看成是一个（ai, i ）二元组的集合。 用结构数组表示：数
数据结构（一）线性存储结构
在路上
06-13 9502
线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 线性结构拥有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的，链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。 线性结构中存在两种操作受限的使用场景，即队列和栈。栈的操作只能在线性表的一端进行，...
数据结构中的 线性结构和非线性结构
做笔记\记录遇到的程序bug
08-17 2243
数据结构中的 线性结构和非线性结构 线性结构： 1、最常用的数据结构、元素之间存在一对一的线性关系 2、两种不同的存储方式，顺序存储结构，链式存储结构。 3、顺序存储结构称为顺序表，顺序表中的存储元素是连续的。 4、链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点存放数据元素以及相邻元素的地址信息 5、线性结构常见的有：数组、队列、链表、栈 单链表 ：https://blog.csdn.net/weixin_43304253/article/details/119758276 双向链表
6、Redis系统-数据结构-06-跳表
最新发布
qq_29434541的博客
07-07 350
在 Redis 中，跳表通过高效的多级链表结构，实现了有序集合的快速插入、删除和查询操作，适用于需要有序数据存储的场景。跳表通过多级链表的形式实现，每一级链表都跳过一些元素，从而在查询时能够快速跳过不必要的元素。跳表的每个节点包含一个或多个前进指针，这些前进指针指向不同级别的节点，使得跳表具有高效的查询性能。删除节点时，通过查找操作确定节点位置，然后在每一级链表中移除该节点，并调整相关节点的前进指针和跨度。插入新节点时，首先确定新节点的级别，然后在每一级链表中找到插入位置，将新节点插入到相应的位置。
r语言线性关系假设检验
05-31
在R语言中，线性关系假设检验通常使用线性回归模型来实现。线性回归模型假设自变量和因变量之间存在线性关系，可以用来预测因变量的取值。 在进行线性关系假设检验时，我们需要对线性回归模型的系数进行显著性检验，以确定自变量对因变量是否有显著的影响。通常情况下，我们使用t检验或F检验来进行显著性检验。 具体来说，我们需要检验以下两个假设： H0：自变量对因变量没有显著影响，即模型中的某些系数为0； H1：自变量对因变量有显著影响，即模型中的某些系数不为0。 在R语言中，可以使用lm()函数来拟合线性回归模型，并使用summary()函数查看模型的显著性检验结果。例如： ``` # 生成随机数据 set.seed(123) x <- rnorm(100) y <- 2 * x + rnorm(100) # 拟合线性回归模型 model <- lm(y ~ x) # 查看模型的显著性检验结果 summary(model) ``` 输出结果中的"Pr(>|t|)"列给出了每个自变量的t检验p值。如果p值小于显著性水平（通常是0.05），则可以拒绝H0假设，认为该自变量对因变量有显著影响。 另外，在多个自变量存在的情况下，我们还可以使用F检验来判断整个模型是否显著。在R语言中，可以使用anova()函数进行F检验。例如： ``` # 拟合包含两个自变量的线性回归模型 model <- lm(y ~ x1 + x2) # 进行F检验 anova(model) ``` 输出结果中的"F value"列给出了F检验统计量和p值。如果p值小于显著性水平，则可以拒绝H0假设，认为整个模型显著。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值