数据结构四：线性表之带头结点的单向循环链表的设计

          前面两篇介绍了线性表的顺序和链式存储结构，其中链式存储结构为单向链表（即一个方向的有限长度、不循环的链表），对于单链表，由于每个节点只存储了向后的结点的地址，到了尾巴结点就停止了向后链的操作。也就是说只能向后走，如果走过了，就回不去了，还得重头开始遍历，所以就衍生出了循环链表。

目录

一、循环链表的产生原因

二、循环链表的基本概念和结构

三、循环与非循环的对比

3.1 特点

3.2 优势

3.3 修改

四、带头结点的单向循环链表的接口函数实现

4.1  单链表结点设计（结构体）

4.2  单循环链表的初始化

4.3 头插 

4.4 尾插

4.5 按位置插入

4.6 头删

4.7 尾删

4.8 按位置删除

4.9 按值删

4.10 查找

4.11 获取有效值个数

4.12 判空

4.13 销毁

4.14 打印

五、总结

一、循环链表的产生原因

       在之前学习单链表的时候，我们使用头结点来代表一个链表，可以用O(1)的时间复杂度便可以访问到第一个节点，但是在访问尾巴节点时，需要通过从头开始向后遍历，因此它的时间复杂度为O(n)，而循环链表则不同，完全可以使用O(1)的时间来访问第一个节点和尾节点。

        相比单链表，循环链表解决了一个很麻烦的问题。 即可以从任意一个结点出发，而不一定是要从头结点出发，就可访问到链表的全部结点，并且访问尾巴结点的时间复杂度也可以达到O(1)。

二、循环链表的基本概念和结构

       循环单链表是首尾相连的一种单链表，即将最后一个结点的空指针改为指向头结点形成一个环型。判断单链表为空的条件是 plist->next == NULL，而判断循环单链表为空的条件是 plist->next==plist。

         从上图可以看出，带头结点的循环链表与单链表的区别在于：最后一个有效结点的指针域指向头结点（保存头结点的地址), 通过这样的一种方式，使得链表构成一个闭环结构，在单链表中，从一已知结点出发，只能访问到该结点及其后续结点，无法找到该结点之前的其它结点。而在单循环链表中，从任一结点出发都可访问到表中所有结点，这是它的一大优点，遍历尾巴结点的时间复杂度也可以达到O(1)。

       上图是带头结点的单向循环链表为空的情况下的结构，即它不存在有效结点，此时，为了保证它是一个循环结构，头结点的指针域指向它自己（即头结点的指针域保存头结点的地址） ，这也是判断带头结点的单向循环链表为空的一个依据即：plist->next==plist。

三、循环与非循环的对比

3.1 特点

  • 若链表为空，则头结点的next结点还是指向其本身，即plist->next==plist；
  • 尾节点的next指针指向plist结点，即头尾相连；
  • 判断是否遍历了完，直接判断p->next==plist即可；
  • 由单链表变化的循环也成为单向循环链表；
  • 循环链表的特点是无须增加存储量，仅对表的链接方式稍作改变，即可使得表处理更加方便灵活；

3.2 优势

       对单向链表中任一个节点的访问都需要从头结点开始；而对单向循环链表从任意节点出发都能遍历整个列表，极大的增强了其灵活性。其实循环链表和单链表的主要差异就在于循环的判断条件上，原本是判断 p->next 是否为空，现在则是 p-> next 不等于头结点，则循环未结束。

3.3 修改

  • 判断是否为空：
    单向链表：如果头结点指向空，那么为空链表（头结点的指针域为NULL）
    单向循环链表：如果头结点指向自身，那么为空链表（头结点的指针域为自身）

  • 判断是否为尾结点
    单向链表：指向空的节点为尾结点（尾结点的指针域为NULL）
    单向循环链表：指向头结点的节点为尾结点（尾结点的指针域为头结点）

四、带头结点的单向循环链表的接口函数实现

      单循环链表的基本操作也同样有：初始化，头插，尾插，按位置插，头删，尾删，按位置删，查找，按值删，获取有效值个数，判空，清空，销毁，打印。这里详细展示这些基本操作的实现思想和画图分析以及代码实现和算法效率分析，

      注意：同样单循环链表与顺序表不同，由于它是按需索取，因此，不需要进行判满和扩容操作；

//引入必要的头文件
#include "SeqList.h"
#include<assert.h>
#include<stdlib.h>
 

//初始化
void Init_circlelist(struct CNode *cls);

//头插
void Insert_head(struct CNode* cls, ELEM_TYPE val);

//尾插
void Insert_tail(struct CNode* cls, ELEM_TYPE val);

//按位置插
void Insert_pos(struct CNode* cls, ELEM_TYPE val, int pos);

//头删
void Del_head(struct CNode* cls);

//尾删
void Del_tail(struct CNode *cls);

//按位置删
void Del_pos(struct CNode *cls, int pos);

//按值删
void Del_val(struct CNode *cls, ELEM_TYPE val);

//查找val值出现的第一次位置
struct CNode *Search(struct CNode *cls, ELEM_TYPE val);

//获取有效长度
int Get_length(struct CNode* cls);

//销毁1
void Destroy1(struct CNode *cls);

//销毁2
void Destroy2(struct CNode *cls);

//判空
bool IsEmpty(struct CNode *cls);

//打印
void Show(PCNode cls);

4.1  单链表结点设计（结构体）

      单循环链表结构体设计非常简单，和单链表有效节点结构体设计一样,只需要一个数据域和指针域。

      每个结点包括两个部分：存储数据的数据域和指针域（指向下一个结点/存储下一个结点地址的指针）构成。因此设计结点主要设计这两个成员变量。

       强调结构体自身引用（自己嵌套自己必须使用struct，即使使用typedef关键字进行重命名）结构体内部不可以定义自身的结构体变量，但是可以定义自身结构体指针变量，因为指针与类型无关，占用内存空间就是4个字节！

typedef int ELEM_TYPE;

//带头结点的单循环链表

//单循环链表结构体设计
typedef struct CNode
{
	ELEM_TYPE data;   //数据域   保存节点有效值
	struct CNode *next;//指针域  保存下一个有效节点的地址
}CNode, *PCNode;


//typedef struct CNode  CNode;
//typedef struct CNode* PCNode;

4.2  单循环链表的初始化

      单循环链表的初始化主要是对其指针域赋值，数据域不使用，不需要操作！并且此时头结点的指针域应该指向自身，而不是空！！！

//初始化
void Init_circlelist(struct CNode *cls)
{
	//头结点的数据域不使用，不用赋值
	cls->next = cls;    //初始化时，链表为空，头结点的指针域指向自身
}

4.3 头插 

循环和非循环单链表的头插法是一样的，不用修改代码。

头插的基本思路如下：

    第0步：assert对传入的指针检测；

    第1步：购买新节点（购买好节点之后，记得将val值赋值进去）；

    第2步：找到合适的插入位置；

    第3步：插入，注意核心代码，先牵右手，再牵左手！！！否则会发生内存泄漏。

//头插
void Insert_head(struct CNode* cls, ELEM_TYPE val)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);
	//1.购买新节点
	struct CNode* pnewnode = (struct CNode*)malloc(sizeof(struct CNode));
	pnewnode->data = val;

	//2.找到合适的插入位置(头插，不需要找)
   //因为是头插函数  所以不需要特意的去合适的位置 直接向cls后面插即可
 

	//3.插入
分两步：先让新购买的节点也指向第一个有效节点，这时，头结点的指针域就可以指向新购买的节点了
	pnewnode->next = cls->next;
	cls->next = pnewnode;

}

4.4 尾插

   尾插的基本思路如下：

    第0步：assert对传入的指针检测；

    第1步：购买新节点（购买好节点之后，记得将val值赋值进去）；

    第2步：找到合适的插入位置，在这里就是找到最后一个有效结点，如何找？因为最后一个有效结点的指针域为头结点，只需要从头开始通过地址，遍历每一个结点，直到遇到最后一个节点，此时指针域指向头结点；与单链表相比，只是尾巴结点的判断条件发生变化。

    第3步：利用插入的通用代码！

//尾插
void Insert_tail(struct CNode* cls, ELEM_TYPE val)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);
	//1.购买新节点
	struct CNode *pnewnode = (struct CNode*)malloc(sizeof(struct CNode));
	pnewnode->data = val;

	//2.找到合适的插入位置(用最后一个有效节点的next域和头结点的地址做判断)
	struct CNode * p = cls;
	for( ; p->next!=cls; p=p->next);  //退出循环时，此时p便指向最后一个有效结点（尾巴结点）
	
	//3.插入
	pnewnode->next = p->next;
	p->next = pnewnode;
}

4.5 按位置插入

 按位置插入的基本思路如下：

    第0步：assert对传入的指针和插入的位置检测；要插入的位置必须大于等于零且小于等于  链表总长度。

    第1步：购买新节点（购买好节点之后，记得将val值赋值进去）；

    第2步：找到合适的插入位置，在这里就是找到插入位置的前一个结点，如何找？用指针p指向(例如pos=2，则让临时指针p，从头结点开始向后走pos步)

    第3步：利用插入的通用代码！

//按位置插
void Insert_pos(struct CNode* cls, ELEM_TYPE val, int pos)
{
	
	//0：assert对传入的指针检测
	assert(cls != NULL);
	assert(pos>=0 && pos<=Get_length(cls));

	//1.购买新节点
	struct CNode *pnewnode = (struct CNode*)malloc(sizeof(struct CNode));
	pnewnode->data = val;

	//2.找到合适的插入位置(pos=几，则让p从头结点开始向后跑pos步)
	struct CNode *p = cls;
	for(int i=0; i<pos; i++)
	{
		p=p->next;
	}

	//3.插入
	pnewnode->next = p->next;
	p->next = pnewnode;


}

4.6 头删

       对于删除操作，则需要对链表进行判空操作！并且删除操作遵循基本同样的4个步骤，需要理解加记忆。删除操作的基本思路如下：

①:用指针q指向待删除节点；
②:用指针p指向待删除节点的前驱节点；(头删的话，这里p可以被plist代替)
③:跨越指向；
④:释放待删除节点。

//头删
void Del_head(struct CNode* cls)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);
	//1.判空
	if(IsEmpty(cls))
	{
		return;
	}

	//2.用q指向待删除节点， 用p指向待删除节点的前一个节点
	struct CNode *q = cls->next;
	//p用cls代替即可

	//3.跨越指向+释放
	cls->next = q->next;
	free(q);
	q = NULL;
}

4.7 尾删

       尾删的基本思路还是那四个步骤，只是具体实现的方式不一样。与单链表相比，只是尾巴节点的判断条件发生变化。

//尾删
void Del_tail(struct CNode *cls)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);
	//1.判空
	if(IsEmpty(cls))
	{
		return;
	}

	//2.用q指向待删除节点， 用p指向待删除节点的前一个节点
	struct CNode *q = cls;
	for(; q->next!=cls; p=p->next);

	struct CNode *p = cls;
	for(; p->next!=q; p=p->next);

	//3.跨越指向+释放
	p->next = q->next;
	free(q);
	q = NULL;
}

4.8 按位置删除

     根据位置删除结点，需要判断结点的合法性，这次的pos需要小于链表长度，基本思路还是那四个步骤，只是具体实现的方式不一样。

//按位置删
void Del_pos(struct CNode *cls, int pos)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);
	//0.5  pos做合法性判断
	assert(pos>=0 && pos<=Get_length(cls)-1);

	//1.判空
	if(IsEmpty(cls))
	{
		return;
	}

	//2.用q指向待删除节点， 用p指向待删除节点的前一个节点
	struct CNode *q = cls;
	for(int i=0; i<=pos; i++)
	{
		q = q->next;
	}

	struct CNode *p = cls;
	for(int i=0; i<pos; i++)
	{
		p = p->next;
	}
	
	//3.跨越指向+释放
	p->next = q->next;
	free(q);
	q = NULL;

}

4.9 按值删

    按值删需要先找到数据域是该值的结点，然后将其删除，基本思路还是那四个步骤，只是具体实现的方式不一样。

//按值删
void Del_val(struct CNode *cls, ELEM_TYPE val)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);

   //1.判空
	if(IsEmpty(cls))
	{
		return;
	}

    //调用函数找该值，返回对应的结点
	struct CNode* q = Search(cls, val);

	//进行判断是否存在该结点
	if(q == NULL)
	{
		return;
	}

	//2.找到合适位置,待删除结点的前一个结点
	struct CNode * p = cls;
	for(; p->next!=q; p=->next);

	//3.跨越指向+释放
	p->next = q->next;
	free(q);
	q = NULL;
}

4.10 查找

      按值查找，返回该值的结点，查找操作只需要定义一个临时结点类型指针变量，让它从第一个有效节点开始遍历，只要结点存在就往后遍历。这里的循环条件：p!=cls，意思是从第一个有效节点遍历到最后一个结点（只要结点存在，就往后走）,与单链表相比，只是尾巴节点的判断条件发生变化。

//查找val值出现的第一次位置
struct CNode *Search(struct CNode *cls, ELEM_TYPE val)
{
    //0：assert对传入的指针检测
	assert(cls != NULL);

   //1.从第一个有效节点开始向后遍历
	struct CNode *p = cls->next;
	for( ; p!=cls; p=p->next)
	{
		if(p->data == val)
		{
			return p;
		}
	}
	return NULL;
}

4.11 获取有效值个数

    只需要定义一个临时结点类型指针变量，让它从第一个有效节点开始遍历，只要没有到最后一个结点就往后遍历。 采用计数器思想，计数器加1，返回计数器变量即是有效结点个数。与单链表相比，只是尾巴节点的判断条件发生变化。

//获取有效长度
int Get_length(struct CNode* cls)
{
    //0：assert对传入的指针检测
	assert(cls != NULL);

    //1.从第一个有效节点开始向后遍历
	struct CNode *p = cls->next;
	int count = 0;

	for( ; p!=cls; p=p->next)
	{
		count++;
	}

	return count;
}

4.12 判空

     在进行删除操作时，需要对链表进行判空操作，如果链表为空，则无法删除！！如何判断链表为空？在链表只有一个头结点时，代表链表为空，此时就是最初始的状态，只有一个头结点，并且头结点的指针域为它自己（指向它自己），因此，只需要判断头结点的指针域是否为自身，便可以知道链表是否为空。与单链表相比，只是空链表的判断条件发生变化。


//判空
bool IsEmpty(struct CNode *cls)
{
     //0：assert对传入的指针检测
	assert(cls != NULL);

	return cls->next==cls;
}

4.13 销毁

第一种：无限头删

       只要链表不为空，一直调用头删函数，直到把所有结点删除完，此时，退出循环。

//销毁1
void Destroy1(struct CNode *cls)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);

    while(!IsEmpty(cls))
	{
		Del_head(cls);
	}
}

第二种：不借助头结点，但是需要两个指针变量p和q(双指针思想)。与单链表相比，只是空链表的判断条件发生变化。 

//销毁2
void Destroy2(struct CNode *cls)
{
	struct CNode *p = cls->next;
	struct CNode *q = NULL;

	cls->next = cls;

	while(p != cls)
	{
		q = p->next;
		free(p);
		p = q;
	}


}

4.14 打印

    只需要定义一个临时结点类型指针变量，让它从第一个有效节点开始遍历，只要没有到最后一个结点就往后遍历，同时打印结构体的数据域成员。

//打印
void Show(PCNode cls)
{
    //0：assert对传入的指针检测
	assert(cls != NULL);

	struct CNode *p = cls->next;
	
	for( ; p!=cls; p=p->next)
	{
		printf("%d ", p->data);
	}

	printf("\n");
}

五、总结

       单向循环链表的插入，删除算法与单链表基本一致，所不同的是若操作在链表的尾部进行，则判断条件发生变化不同，以让单链表继续保持循环的性质。因此，需要记住循环链表判空和判断是否为尾巴结点的条件！即循环链表中没有NULL指针。涉及遍历操作时，其终止条件就不再是像非循环链表那样判别p或p->next是否为空，而是判别它们是否等于某一指定指针，如头指针或尾指针等。

       以上便是我为大家带来的带头结点的单向循环链表设计内容，若有不足，望各位大佬在评论区指出，谢谢大家！可以留下你们点赞、收藏和关注，这是对我极大的鼓励，我也会更加努力创作更优质的作品。再次感谢大家！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

STM32G431RBT6之LCD与LED配置

STM32G431RBT6之LCD与LED配置

首先,配置时钟树,时钟树的配置在我的另外一篇博客里,这里不再赘述. LCD与LED具有共同的IO口,同时创建工程较好. 打开原理图,发现LED的IO口是PC8~PC15,还有一个容易看漏的PD2.LCD的IO口是PC0到PC15. 当然,看产品手册也可以知道,但是还是推荐大家看原理图. 打开cubumx,给PC0~PC…
阅读更多...
如何讲好ppt演讲技巧（4篇）

如何讲好ppt演讲技巧（4篇）

如何讲好ppt演讲技巧&#xff08;4篇&#xff09; 如何讲好PPT演讲技巧&#xff08;四篇&#xff09; **篇&#xff1a;精心准备&#xff0c;奠定演讲基础 一个成功的PPT演讲&#xff0c;离不开精心的准备。首先&#xff0c;要确定演讲的主题和目标&#xff0c;确保演讲内容清…
阅读更多...
应用实战｜只需几步，即可享有外卖订餐小程序

应用实战｜只需几步，即可享有外卖订餐小程序

本示例是一个简单的外卖查看店铺点菜的外卖微信小程序&#xff0c;小程序后端服务使用了MemFire Cloud&#xff0c;其中使用到的MemFire Cloud功能包括&#xff1a; 其中使用到的MemFire Cloud功能包括&#xff1a; 云数据库&#xff1a;存储外卖微信小程序所有数据表的信息。…
阅读更多...
服务端不 listen 可以创建 tcp 连接吗

服务端不 listen 可以创建 tcp 连接吗

这个问题有三类答案。 上来就撸 linux kernel 源码&#xff0c;折腾半天&#xff0c;哦&#xff0c;终于在 tcp_rcv_state_process 里找到了 tcp_rcv_synsent_state_process 调用&#xff0c;后者包含&#xff1a; if (th->syn) {/* We see SYN without ACK. It is attemp…
阅读更多...
前端JS必用工具【js-tool-big-box】，Number数值转换的方法调用学习

前端JS必用工具【js-tool-big-box】，Number数值转换的方法调用学习

这一小节&#xff0c;我们针对前端工具包&#xff08;npm&#xff09;js-tool-big-box的使用做一些讲解&#xff0c;主要是针对Number数值型转换的一些方法使用。 目录 前言 1 安装和引入 2 千位逗号分割 3 判断是否大于0 4 判断是否大于0的整数 5 生成指定范围内的随机数…
阅读更多...
leetcode 循环列表的插入（Python）

leetcode 循环列表的插入（Python）

题目如果不进行思考&#xff0c;巨多坑。 首先我们需要找到列表中的最小值&#xff0c;最大值这个节点&#xff0c;因为找到后可以与我们的新元素进行比较厚插入。 找到最小值&#xff0c;最大值需要循环一遍列表&#xff0c;如果当前cur元素的值<nex元素的值&#xff0c;…
阅读更多...
堆的应用——堆排序

堆的应用——堆排序

堆排序 堆排序是一种基于比较的排序算法&#xff0c;它利用堆这种数据结构所设计。堆是一个近似完全二叉树的结构&#xff0c;并同时满足堆积的性质&#xff1a;即子结点的键值或索引总是小于&#xff08;或者大于&#xff09;它的父结点。 堆排序可以分为两个主要步骤&#…
阅读更多...
smart200 做client,modbus_tcp读取modbus_slave

smart200 做client,modbus_tcp读取modbus_slave

这里还隐藏一个重要的设置&#xff0c;就是站地址。这个在库函数里。不同plc位置会不一样&#xff0c;我这里是vb1651对应modbus的地址为255&#xff0c;这个值我们可以自己更改&#xff0c;范围为1-247. 打开modbus_slave 软件&#xff0c;
阅读更多...
【C#】rdlc报表答应报错：未能加载文件或程序集“Microsoft.SqlServer.Types

【C#】rdlc报表答应报错：未能加载文件或程序集“Microsoft.SqlServer.Types

文章目录 一、报错信息二、解决方式 一、报错信息 Microsoft.Reporting.WinForms.LocalProcessingException: An error occurred during local report processing. —> Microsoft.Reporting.DefinitionInvalidException: The definition of the report ‘’ is invalid. —&…
阅读更多...
sql注入漏洞及其sqlmap工具的使用

sql注入漏洞及其sqlmap工具的使用

一、sql注入的原理 sql注入概念&#xff1a; sql注入主要是将sql语句&#xff0c;插入到web表单提交或者输入域名或者页面请求的查询字符串&#xff0c;最 终 达到一个欺骗服务器执行sql语句的效果。 sql注入的原理&#xff1a;主要分为平台层注入和代码层注入两种原因 …
阅读更多...
stm32的GPIO基本结构

stm32的GPIO基本结构

1.带FT标号的引脚能容忍5V 2.GPIO系统架构 stm32的所有GPIO都是挂载在APB2总线上的 3.GPIO的基本结构 在上图中&#xff0c;左边就是寄存器&#xff0c;右边就是驱动器了 保护二极管的作用&#xff1a;VDD表示3.3V&#xff0c;如果输入的电压的值大于3.3V&#xff0c;那么这个…
阅读更多...
百度网盘某个文件对外开放怎么弄通过密码下载文件对外开放某个文件

百度网盘某个文件对外开放怎么弄通过密码下载文件对外开放某个文件

百度网盘某个文件对外开放怎么弄通过密码下载文件对外开放某个文件 百度云盘分享文件(创建公开连接)的方法&#xff1a; 1、登录网页&#xff0c;打开百度云盘&#xff0c;并登陆自己的帐号。 2、上传后选择自己需要分享的文件。 选择分享的文件 3、将鼠标放在需要分享的文…
阅读更多...
上市企业数字赋能指数数据集-2001到2022年（TF-IDF）

上市企业数字赋能指数数据集-2001到2022年（TF-IDF）

01、数据简介 上市公司数字赋能指数是一个用来衡量上市公司利用数字技术提高业务能力和效率的指标。这个指数反映了上市公司利用大数据、云计算和人工智能等数字技术&#xff0c;高效地利用商业资源和信息&#xff0c;并扩展供应关系的能力。市公司数字赋能指数是一种综合性的…
阅读更多...
【Linux】组管理命令

【Linux】组管理命令

在Linux系统中&#xff0c;组管理是一种重要的权限管理机制&#xff1a; 权限分配的灵活性&#xff1a;通过将用户组织成不同的组&#xff0c;管理员可以更轻松地管理用户的权限。这样&#xff0c;管理员可以根据组的角色或特定任务来分配权限&#xff0c;而不必逐个用户进行设…
阅读更多...
大数据时代的引擎：大数据架构随记

大数据时代的引擎：大数据架构随记

大数据架构通常可以分为以下几层&#xff1a; 一、数据采集层 负责从各种数据源采集、清洗、转换、丰富以及格式化数据&#xff0c;可能包括结构化、半结构化和非结构化的数据。 1.1、常用的技术 在大数据领域&#xff0c;数据采集是一个关键的环节&#xff0c;常用的数据采集…
阅读更多...
Spring框架宝典：彻底理解三级缓存策略

Spring框架宝典：彻底理解三级缓存策略

一、循环依赖概念 在Spring应用中&#xff0c;循环依赖指的是两个或多个Bean之间相互引用&#xff0c;造成了一个环状的依赖关系。举例来说&#xff0c;如果Bean A依赖于Bean B&#xff0c;同时Bean B也依赖于Bean A&#xff0c;就形成了循环依赖。这种情况下&#xff0c;Sprin…
阅读更多...
数据库介绍（Mysql安装）

数据库介绍（Mysql安装）

前言 工程师再在存储数据用文件就可以了&#xff0c;为什么还要弄个数据库? 一、什么是数据库&#xff1f; 文件保存数据有以下几个缺点&#xff1a; 文件的安全性问题文件不利于数据查询和管理文件不利于存储海量数据文件在程序中控制不方便 数据库存储介质&#xff1a; 磁…
阅读更多...
【Canvas与艺术】绘制朝鲜国旗

【Canvas与艺术】绘制朝鲜国旗

【声明】 该国旗的定位和大小是本人与网上照片比对后估算的&#xff0c;不是精确值。 【成图】 【代码】 <!DOCTYPE html> <html lang"utf-8"> <meta http-equiv"Content-Type" content"text/html; charsetutf-8"/> <hea…
阅读更多...
四信智能化感知与控制方案，助推灌区续建配套与现代化改造建设

四信智能化感知与控制方案，助推灌区续建配套与现代化改造建设

“十四五”明确提到推进大中型灌区节水改造和精细化管理&#xff0c;建设节水灌溉骨干工程&#xff0c;同步推进水价综合改革。 灌区是保障国家粮食安全的重要基础性设施&#xff0c;是实施乡村振兴战略的水利支撑。灌区续建配套与现代化改造是实施乡村振兴战略一项重要任务。为…
阅读更多...
一套JAVA语言开发的：危大工程智慧一体化工地系统源码，（后台管理端+APP+可视化大屏端）

一套JAVA语言开发的：危大工程智慧一体化工地系统源码，（后台管理端+APP+可视化大屏端）

智慧工地是指利用移动互联、物联网、智能算法、地理信息系统、大数据挖掘分析等信息技术&#xff0c;提高项目现场的“人•机•料•法•环•安”等施工要素信息化管理水平&#xff0c;实现工程施工可视化智能管理&#xff0c;并逐步实现绿色生态建造。 相关技术&#xff1a;微…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站