【数据结构】顺序表和链表

news2024/10/6 10:27:35

顺序表和链表

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

在这里插入图片描述

2.顺序表

2.1概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存

储。在数组上完成数据的增删查改。

顺序表一般可以分为：

\1. 静态顺序表：使用定长数组存储元素。

在这里插入图片描述

\2. 动态顺序表：使用动态开辟的数组存储。

在这里插入图片描述

2.2 接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

typedef int SLDataType;
// 顺序表的动态存储
typedef struct SeqList
{
  SLDataType* array;  // 指向动态开辟的数组
  size_t size ;       // 有效数据个数
  size_t capicity ;   // 容量空间的大小
}SeqList;
// 基本增删查改接口
// 顺序表初始化

void SeqListInit(SeqList* psl);
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* psl);
// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x);
// 顺序表尾删
void SeqListPopBack(SeqList* psl);
// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x);
// 顺序表头删
void SeqListPopFront(SeqList* psl);
// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x); 
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos);
// 顺序表销毁
void SeqListDestory(SeqList* psl);
// 顺序表打印
void SeqListPrint(SeqList* psl);

头插实现：

头插的实现需要先将顺序表中的数据逐个往后挪动，再将数据插入下标为0的位置。

在这里插入图片描述

头删实现：

头删只要将顺序表中的数据逐个往前覆盖即可，注意后面需要将顺序表中的有效个数减1，即ps->size-1。

在这里插入图片描述

顺序表在pos位置插入x：

在这里插入图片描述

顺序表删除pos位置的值：

在这里插入图片描述

2.3 顺序表的扩容

顺序表在用realloc扩容时有两种情况：

  1. 后面内存空间足够：原地扩容，扩容后起始地址不变。
  2. 后面空间不够扩容：异地扩容，扩容后起始地址改变。

在这里插入图片描述

2.4 顺序表的问题及思考

问题：

优点：

  1. 尾插尾删足够快
  2. 下标的随机访问和修改

缺点：

  1. 中间/头部的插入删除效率太低，时间复杂度为O(N)
  2. 扩容（尤其是异地扩容）需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 扩容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后扩容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

思考：如何解决以上问题中的缺点呢？下面给出了链表的结构来看看。

3.链表

3.1 链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

在这里插入图片描述

物理结构：

在这里插入图片描述

注意:

  1. 从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续。
  2. 现实中的结点一般都是从堆上申请出来的。
  3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。

假设在32位系统上，结点中值域为int类型，则一个节点的大小为8个字节，则也可能有下述链表:

在这里插入图片描述

3.2 链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

\1. 单向或者双向

在这里插入图片描述

\2. 带头或者不带头

在这里插入图片描述

\3. 循环或者非循环

在这里插入图片描述

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

在这里插入图片描述

原因

  1. 无头单向非循环链表∶结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
  2. 带头双向循环链表:结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

3.3 单向链表的实现

// 1、无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
 SLTDateType data;
 struct SListNode* next;
}SListNode;
// 动态申请一个结点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos);

3.4单向链表的接口实现

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"


//打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	//while (cur != NULL)
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

	return newnode;

}

尾插  phead是plist的形参   //开始就有链表
//void SLTPushBack(SLTNode* phead, SLTDataType x)
//{
//	SLTNode* newnode = BuySListNode(x);
//	SLTNode* tail = phead;
//	while (tail->next != NULL)
//	{
//		tail = tail->next;
//	}
//	tail->next = newnode;
//}

//尾插  //包括一开始没有链表
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);

	SLTNode* newnode = BuySListNode(x);
	if (*pphead == NULL)
	{
		//改变结构体的指针，所以要用二级指针
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		//改变的结构体，用结构体的指针即可
		tail->next = newnode;
	}
}

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);

	SLTNode* newnode = BuySListNode(x);

	newnode->next = *pphead;
	*pphead = newnode;
}

//尾删
void SLTPopBack(SLTNode** pphead)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);

	//1.空
	assert(*pphead);
	//2、一个节点
	//3、一个以上节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//方法1.
		SLTNode* tailPrev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tailPrev = tail;
			tail = tail->next;
		}
		free(tail);
		tailPrev->next = NULL;
		
		方法2.
		//SLTNode* tail = *pphead;
		//while (tail->next->next)
		//{
		//	tail = tail->next;
		//}
		//free(tail->next);
		//tail->next = NULL;
	}
}

//头删
void SLTPopFront(SLTNode** pphead)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);

	//空
	assert(*pphead);

	//非空
	SLTNode* newhead = (*pphead)->next;
	free(*pphead);
	*pphead = newhead;
}

//查找是否有x这个数,找到返回指向该数的指针
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

//在pos位置前插
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);
	assert(pos);

	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

//在pos位置后插
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = BuySListNode(x);
	
	//下面两句不能交换位置，否则会成环
	newnode->next = pos->next;
	pos->next = newnode;
}

//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	//else if (pos->next == NULL)
	//{
	//	SLTPopBack(pphead);
	//}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}		
		//free(prev->next);//不要free，不然这个节点后面全没了
		prev->next = pos->next;		
	}
}

//删除pos后一个位置
void SLTEraseAfter(SLTNode* pos)
{
	//
	assert(pos);

	//检测pos是否是尾节点
	//assert(pos->next);//暴力检测
	if (pos->next == NULL)//温和检测
	{
		return NULL;
	}

	SLTNode* posNext = pos->next;
	pos->next = posNext->next;
	free(posNext);
	posNext = NULL;

}


//不给头，删除pos位置
void SLTEraseNoFront(SLTNode* pos)
{
	//检测pos是否是尾节点
	//assert(pos->next);//暴力检测
	if (pos->next == NULL)//温和检测
	{
		return NULL;
	}

	SLTNode* posNext = pos->next;
	pos->data = posNext->data;
	pos->next = posNext->next;
	free(posNext);
	posNext = NULL;
}

void SLTDestroy(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);

		cur = next;
	}
	*pphead = NULL;
}

3.5双向链表的实现

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

// 2、带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
 LTDataType _data;
 struct ListNode* next;
 struct ListNode* prev;
}ListNode;
// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* plist);
// 双向链表打印
void ListPrint(ListNode* plist);
// 双向链表尾插
void ListPushBack(ListNode* plist, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* plist);
// 双向链表头插
void ListPushFront(ListNode* plist, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* plist);
// 双向链表查找
ListNode* ListFind(ListNode* plist, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的结点
void ListErase(ListNode* pos);  
//链表大小
int LTSize(LTNode* phead);
//找pos位置
LTNode* LTFind (LTNode* phead, LTDataType x);
//销毁
LTNode* LTDetory(LTNode* phead);

3.6双向链表的接口实现

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->data = x;
	node->next = NULL;
	node->prev = NULL;

	return node;
}

LTNode* LTInit()
{
	LTNode* phead = BuyLTNode(0);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}
//打印
void LTPrint(LTNode* phead)
{
	assert(phead);

	printf("phead<=>");
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	//LTNode* tail = phead->prev;
	//LTNode* newnode = BuyLTNode(x);

	//newnode->prev = tail;
	//tail->next = newnode;

	//newnode->next = phead;
	//phead->prev = newnode;

	//插入phead位置的前面(即链表结尾位置)，相当于尾插
	LTInsert(phead, x);
}
//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	/*LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	free(tail);

	tailPrev->next = phead;
	phead->prev = tailPrev;*/

	//删除phead->prev位置的节点相当于尾删
	LTErase(phead->prev);
}
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	//LTNode* newnode = BuyLTNode(x);
	//newnode->next = phead->next;
	//phead->next->prev = newnode;

	//phead->next = newnode;
	//newnode->prev = phead;

	//LTNode* newnode = BuyLTNode(x);
	//LTNode* first = phead->next;

	 phead newnode first
	//phead->next = newnode;
	//newnode->prev = phead;
	//newnode->next = first;
	//first->prev = newnode;

	//插入phead->next位置的前面，相当于头插
	LTInsert(phead->next, x);
}
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	//LTNode* first = phead->next;
	//LTNode* second = first->next;

	//free(first);

	//phead->next = second;
	//second->prev = phead;


	//删除phead->next位置的节点，相当于头删
	LTErase(phead->next);
}

int LTSize(LTNode* phead)
{
	assert(phead);

	int size = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		++size;
		cur = cur->next;
	}

	return size;
}

// 从pos位置前插
void LTInsert(LTNode* pos, LTDataType x)
{
	
	assert(pos);

	LTNode* posPrev = pos->prev;
	LTNode* newnode = BuyLTNode(x);

	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
	
}

// 从pos位置删除
void LTErase(LTNode* pos)
{

	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;

	free(pos);

	posPrev->next = posNext;
	posNext->prev = posPrev;
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur!=phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

//销毁
LTNode* LTDetory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;	

	while (cur != phead)
	{
		//next = cur->next;
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}

	free(phead);
}

4.顺序表和链表的区别

在这里插入图片描述

备注：缓存利用率参考存储体系结构以及局部原理性。
扩展知识：《与程序员相关的CPU缓存知识》 https://coolshell.cn/articles/20793.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1178691.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

火山引擎云原生存储加速实践

火山引擎云原生存储加速实践

在火山引擎相关的业务中绝大部分的机器学习和数据湖的算力都运行在云原生 K8s 平台上。云原生架构下存算分离和弹性伸缩的计算场景&#xff0c;极大的推动了存储加速这个领域的发展&#xff0c;目前业界也衍生出了多种存储加速服务。但是面对计算和客户场景的多样性&#xff0c…
阅读更多...
MYSQL：主从复制简述

MYSQL：主从复制简述

&#xff08;图片来自于马士兵教育&#xff09; 从节点的I/O线程会请求主节点的Binlog&#xff0c;并且将得到的Binlog写入到本地relay_log&#xff08;中继日志&#xff09;中&#xff0c;SQL线程会读取realy_log中的日志文件&#xff0c;并且解析成SQL逐行执行。 主库会生成…
阅读更多...
小程序制作（超详解！！！）第十三节 随机数求和

小程序制作（超详解！！！）第十三节 随机数求和

1.题目 设计一个小程序&#xff0c;运行后产生一列100以内的随机数(保留小数点后2位) &#xff0c;并显示这些随机数的和;当点击按钮时&#xff0c;产生一列新的随机数&#xff0c;并显示这些随机数的和。 2.index.wxml <view class"box"> <view class&q…
阅读更多...
千兆光模块和万兆光模块在数据中心中的应用

千兆光模块和万兆光模块在数据中心中的应用

在现代的数据中心中&#xff0c;网络速度和带宽需求越来越高&#xff0c;对于数据传输的速度和容量提出了更高的要求。千兆光模块和万兆光模块作为常见的光模块类型&#xff0c;在数据中心中发挥着重要的作用。那么&#xff0c;千兆光模块和万兆光模块的特性、应用场合以及优劣…
阅读更多...
基于8086简易洗衣机控制仿真设计

基于8086简易洗衣机控制仿真设计

**单片机设计介绍&#xff0c;基于8086简易洗衣机控制仿真设计 文章目录 一 概要二、功能设计设计思路 三、 软件设计原理图 五、 程序六、 文章目录 一 概要 基于 8086 的简易洗衣机控制仿真设计主要包括以下几个方面&#xff1a; 硬件平台设计&#xff1a;需要确定微处理器、…
阅读更多...
虚拟列表方案实现

虚拟列表方案实现

虚拟列表 长列表优化的2种思路&#xff1a; 分片渲染只渲染可视区域 基本概念 进程&#xff1a;这个概念比较大。每开一个应用程序都会分配一个独立的进程&#xff0c;等于每个应用都是一个进程(当然也有一个应用有很多进程)&#xff0c;进程是一个更大的概念&#xff0c;一个进…
阅读更多...
反序列化 [网鼎杯 2020 青龙组]AreUSerialz 1

反序列化 [网鼎杯 2020 青龙组]AreUSerialz 1

打开题目 <?phpinclude("flag.php");highlight_file(__FILE__);class FileHandler {protected $op;protected $filename;protected $content;function __construct() {$op "1";$filename "/tmp/tmpfile";$content "Hello World!&qu…
阅读更多...
Mysql学习文档笔记

Mysql学习文档笔记

文章目录 基础篇通用语法及分类DDL&#xff08;数据定义语言&#xff09;数据库操作注意事项 表操作 DML&#xff08;数据操作语言&#xff09;添加数据注意事项 更新和删除数据 DQL&#xff08;数据查询语言&#xff09;基础查询条件查询聚合查询&#xff08;聚合函数&#xf…
阅读更多...
内网穿透的应用-无公网IP环境下使用内网穿透实现远程访问本地GeoServe Web管理界面

内网穿透的应用-无公网IP环境下使用内网穿透实现远程访问本地GeoServe Web管理界面

文章目录 前言1.安装GeoServer2. windows 安装 cpolar3. 创建公网访问地址4. 公网访问Geo Servcer服务5. 固定公网HTTP地址 前言 GeoServer是OGC Web服务器规范的J2EE实现&#xff0c;利用GeoServer可以方便地发布地图数据&#xff0c;允许用户对要素数据进行更新、删除、插入…
阅读更多...
Java中对date数据做加减时间运算——Calendar类

Java中对date数据做加减时间运算——Calendar类

JAVA DATE加小时实现 参考&#xff1a;JAVA DATE加小时 简介 在日常开发中&#xff0c;我们经常会遇到需要对日期进行加减操作的场景&#xff0c;比如在某个时间点上加上指定的小时数。本文将介绍如何使用JAVA的Date类来实现对日期加小时的操作&#xff0c;并提供具体的步骤和…
阅读更多...
Odoo｜“视图”和“模型”之间的数据传输

Odoo｜“视图”和“模型”之间的数据传输

01前言 今天带领大家学习Odoo系统中“视图”与“模型”之间的数据传输。看题目我们可以知道&#xff0c;这篇文章是面向的是Odoo的初学者。Odoo作为当前最普遍的二开ERP系统&#xff0c;其开源&#xff0c;模块化&#xff0c;灵活开发的属性使得它在ERP相关领域十分受青睐。 …
阅读更多...
动作捕捉系统通过SDK与MATLAB/Simulink通信

动作捕捉系统通过SDK与MATLAB/Simulink通信

NOKOV度量动作捕捉系统支持通过SDK与MATLAB/Simulink通信&#xff0c;将动作数据传入MATLAB/Simulink进行实时解算。 一、形影软件设置 1、在形影软件中加载数据 2、选择网卡地址 3、勾选“使用SDK” 4、点击播放按钮。这时候SDK的数据就已经向外发送了 二、MATLAB接收数据…
阅读更多...
pytest中的pytest.ini

pytest中的pytest.ini

[pytest] filterwarnings ignore::DeprecationWarning addopts -v -s markers uat:1 smok:2 log_cli1 xfail_strict True filterwarnings ignore::DeprecationWarning 这个的功能就是 test_login.py::Test_login::test_login_correct_password PASSEDwarnings summary …
阅读更多...
elasticsearch下载和安装（linux）看这一篇就够了

elasticsearch下载和安装（linux）看这一篇就够了

配置java环境&#xff08;11版本以上&#xff09; 1.下载安装包 我是放在usr下的java里了 2.解压 tar -zxvf jdk-17_linux-x64_bin.tar.gz3.配置环境变量 vim /etc/profile在文件的最下面添加 JAVA_HOME/usr/java/jdk-17.0.9 #你自己的安装路径 JRE_HOME$JAVA_HOME/jre C…
阅读更多...
superset study day01 (本地启动superset项目)

superset study day01 (本地启动superset项目)

文章目录 什么是superset?superset文档 superset开发环境搭建superset后端环境1. 新建数据库2. 环境配置3. 修改py文件4. 迁移数据库5. 启动项目 superset 前端代码打包搭建完成,效果页面 什么是superset? Apache Superset™ 是一个开源的现代数据探索和可视化平台。 Super…
阅读更多...
CBAM：Convolutional Block Attention Module

CBAM：Convolutional Block Attention Module

CBAM&#xff08;Convolutional Block Attention Module&#xff09;是一种深度学习领域的注意力机制&#xff0c;旨在增强卷积神经网络对图像特征的建模和表示能力。CBAM引入了通道和空间两种不同的注意力机制&#xff0c;使模型能够动态调整特征图的权重&#xff0c;以适应不…
阅读更多...
Python 文件处理指南：打开、读取、写入、追加、创建和删除文件

Python 文件处理指南：打开、读取、写入、追加、创建和删除文件

文件处理是任何Web应用程序的重要部分。Python有多个用于创建、读取、更新和删除文件的函数。 文件处理 在Python中处理文件的关键函数是open()函数。open()函数接受两个参数&#xff1a;文件名和模式。 有四种不同的方法&#xff08;模式&#xff09;可以打开文件&#xff…
阅读更多...
[直播自学]-[汇川easy320]搞起来（2）看文档

[直播自学]-[汇川easy320]搞起来（2）看文档

2023.11.06.NIGHT 一 、读 《Easy320可编程逻辑控制器用户手册-CN-A02.PDF》 21&#xff1a;30 好现在看文档 里面提到 I/O滤波可设置&#xff1a; I/O支持短路保护&#xff0c;I/O指示灯程序控制 热量是向上走的&#xff0c;而PLC是大脑&#xff0c;所以放到最下面&am…
阅读更多...
Qt 继承QAbstractTableModel实现自定义TableModel

Qt 继承QAbstractTableModel实现自定义TableModel

1.简介 QAbstractTableModel为将数据表示为二维项数组的模型提供了一个标准接口。它不直接使用&#xff0c;但必须进行子类化。 由于该模型提供了比QAbstractItemModel更专业的接口&#xff0c;因此它不适合与树视图一起使用&#xff0c;尽管它可以用于向QListView提供数据。…
阅读更多...
Ansible playbook自动化运维工具详解

Ansible playbook自动化运维工具详解

Ansible playbook自动化运维工具详解 一、playbook的相关知识1.1、playbook 的简介1.2、playbook的 各部分组成 二、基础的playbook剧本编写实例三、 playbook的定义、引用变量3.1、基础变量的定义与引用3.2、引用fact信息中的变量 四、playbook中的when条件判断和变量循环使用…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023