【数据结构】线性表之栈、队列

news2024/10/5 15:30:23

在这里插入图片描述

前言

前面两篇文章讲述了关于线性表中的顺序表与链表，这篇文章继续讲述线性表中的栈和队列。
这里讲述的两种线性表与前面的线性表不同，只允许在一端入数据，一段出数据，详细内容请看下面的文章。
顺序表与链表两篇文章的链接：
线性表之顺序表
线性表之链表

注意： 本文提到的效率全部为空间复杂度！！！！

一、栈

1. 栈的概念

栈:一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO (Last ln FirstOut)的原则.
入栈:栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈:栈的删除操作叫做出栈。出数据也在栈顶。

2. 栈的结构

栈的结构决定了栈只能在栈顶入数据，栈顶出数据，并且遵循着后进先出的原则。

2.1 选择数据结构完成栈（数组 or 链表)

2.1.1 数组

前面学习过顺序表就能知道，数组只有尾插和尾删的效率高为 O(1) , 而靠近头的位置的插入删除的效率比较低为O(N)。
而对于栈这种只能在栈顶插入、删除的数据结构可谓是完美契合数组的优点。
在这里插入图片描述

2.1.2 链表

前面学习过链表就可以知道，对于单链表的头插、头删的效率非常高为 O(1) , 而它的尾插、尾删需要找尾，效率比较低为 O(N)。

若以单链表的头为栈底，尾为栈顶，则入栈、出栈相当于单链表的尾插、尾删效率并不高。
显然这不是我们的最佳选项，但是若用一个变量记录尾的情况下，尾插、尾删的效率也可以达到O(1)。

在这里插入图片描述

若以单链表的头为栈顶，尾为栈底，则入栈、出栈相当于单链表的头插、头删效率非常高为O(1)。
这里与前面的数组差不多，也是栈的操作完全契合单链表的优点。

在这里插入图片描述
栈能够使用单链表实现，当然也可以用带头双向循环链表实现，但是我认为这里使用带头双向循环链表有点大炮打蚊子，大材小用的感觉。

2.1.3 我选择用数组完成栈

为什么这里选择数组完成栈呢？
明明数组容量不足时扩容需要消耗，而链表没有这个消耗，为什么不用链表？
原因有以下几点：

  1. 由于数组物理结构上是连续的，缓存命中率高，访问效率高。
  2. 相比链表，数组只需要存储数据，而链表每一个节点还需要存下一个节点的地址。
  3. 虽然数组扩容有消耗，但是链表每次申请节点的时候也会有消耗。

2.2 栈的操作

在这里插入图片描述

3. 栈的实现

Stack.h头文件的实现

#pragma once

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

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

Stack.c文件的实现

3.1 初始化栈

栈的初始化将传入函数的结构体进行初始化：
a. 栈顶初始化的时候注意有两种情况:
1. top指向栈顶元素
2. top指向栈顶元素的后面一个位置
当然都可以，我选择 1 仅仅方便我自己理解

b. 是否在初始化的时候给栈申请部分空间
当然都可以，我这里选择不申请空间，在后面用realloc函数申请和扩容空间。

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->capacity = 0;
	//ps->top = -1;    //top指向栈顶
	ps->top = 0;     //top指向栈顶的后面一个元素
	ps->a = NULL;
}

3.2 入栈

当数据入栈时需要判断栈是否为满，若为满则需要扩容，这里的StackFull函数其实并没有必要，由于栈只有尾插这一个插入操作不需要复用扩容操作，所以可以直接写在入栈操作中。
注意：
当realloc()函数的参数为NULL时，其作用与malloc()函数的作用一样。

void StackFull(Stack* ps)
{
	assert(ps);
	int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
	if (tmp == NULL)
	{
		perror("realloc");
		return;
	}
	ps->a = tmp;
	ps->capacity = newcapacity;
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);

	if (ps->capacity == ps->top)
		StackFull(ps);
	ps->a[ps->top] = data;
	ps->top++;
}

3.3 判空

前面假设了top是指向栈顶元素后面一个位置，所以当 top 指向 0 的时候栈是空的。

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

3.4 出栈

执行出栈操作时，栈不能为空，且只需要 top-- ， 不需要将其数据抹除。

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//栈为空，则不能继续出栈
	ps->top--;
}

3.5 取栈顶元素

与出栈操作一样，取栈顶元素时，栈不能为空。
且top是指向栈顶元素后面一个位置，所以取栈顶元素时取的是 top - 1 指向的元素。

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//栈为空，则无栈顶元素
	return ps->a[ps->top - 1];
}

3.6 获取栈中有效元素个数

由于top是指向栈顶元素的下一个位置，而元素个数正好是下标 + 1 ，也就是top。

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;   //由于top是指向栈顶元素的下一个位置		
					  //而元素个数正好是下标 + 1 ，也就是top
}

3.7 销毁栈

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;

	ps->capacity = 0;
	ps->top = 0;
}

4. 整体代码的实现

#include "Stack.h"
// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->capacity = 0;
	ps->top = 0;     //top指向栈顶的后面一个元素
	ps->a = NULL;
}

void StackFull(Stack* ps)
{
	assert(ps);
	int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
	if (tmp == NULL)
	{
		perror("realloc");
		return;
	}
	ps->a = tmp;
	ps->capacity = newcapacity;
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);

	if (ps->capacity == ps->top)
		StackFull(ps);
	ps->a[ps->top] = data;
	ps->top++;
}

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//栈为空，则不能继续出栈
	ps->top--;
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//栈为空，则无栈顶元素
	return ps->a[ps->top - 1];
}

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;   //由于top是指向栈顶元素的下一个位置		
					  //而元素个数正好是下标 + 1 ，也就是top
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;

	ps->capacity = 0;
	ps->top = 0;
}

二、队列

1. 队列的概念

队列:只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有 先进先出 FIFO(First In First Out) 的原则。
入队列:进行插入操作的一端称为队尾
出队列:进行删除操作的一端称为队头

2. 队列的结构

在这里插入图片描述

2.1 选择数据结构完成队列（数组 or 链表)

2.1.1 数组

前面学习过顺序表就能知道，数组只有尾插和尾删的效率高为 O(1) , 而靠近头的位置的插入删除的效率比较低为O(N)。
而对于队列这种只能在队尾插入、对头删除的数据结构，无论队头和队尾定义在哪，使用数组完成必定会有头删或头插，会使得队列的效率降低，所以不建议使用数组完成。

在这里插入图片描述

2.1.2 链表

前面学习过链表就可以知道，对于单链表的头插、头删的效率非常高为 O(1) , 而它的尾插、尾删需要找尾，效率比较低为 O(N)。

(1)若以单链表的头为队头，尾为队尾，则入队列、出队列相当于单链表的尾插、头删效率并不高。
(2)若以单链表的头为队尾，尾为队头，则入队列、出队列相当于单链表的头插、尾删效率并不高。
虽然两种情况都有一种操作效率为O(N) , 但是这两种情况都是与尾有关的操作，
所以只要在结构体中定一个记录尾的成员，那么尾插、尾删的效率就能达到O(1).

在这里插入图片描述

2.1.3 我选择用链表完成队列

为什么这里选择链表完成队列？
通过上面的讲述原因已经显而易见了。
原因如下：
由于无论怎么改造数组都会有一个操作效率为 O(N),而链表只需要改变结构体，使其多一个指向尾的成员，就能使队列的插入、删除的操作效率为O(1).

3. 队列的实现

Queue.h头文件的实现

#pragma once

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

typedef int QDataType;

// 链式结构：表示队列 
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* front;
	QNode* rear;  //指向队列最后一个元素的后面
	int size;
}Queue;

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

Queue.c文件的实现

3.1 初始化队列

这里队列的front指向队头，rear指向队尾。
当队列为空的时候，那么front和rear 都是指向 NULL。

// 初始化队列 
void QueueInit(Queue* q)
{
	q->front = NULL;
	q->rear = NULL;
	q->size = 0;
}

在这里插入图片描述

3.2 队尾入队列

由于使用链表实现队列，插入时需要申请一个节点。
入队列分为两种情况：

  1. 队列为空时，需要改变队头、队尾的指针。
  2. 队列不为空时，只需要将新节点接到队尾，并将尾指针向后移动即可。
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->next = NULL;
	newnode->data = data;

	if (q->front == NULL)      //分队列是否有元素两种情况
	{						   //队列为空
		assert(q->rear == NULL);
		q->front = newnode;
		q->rear = newnode;
	}
	else
	{						   //队列不为空
		q->rear->next = newnode;
		q->rear = newnode;
	}

	q->size++;//入队列，队列长度加一
}

3.3 判空

当队列中的头、尾指针都指向NULL的时候为队列为空。

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->front == NULL && q->rear == NULL;
}

在这里插入图片描述

3.4 队头出队列

出队列分为两种情况：

  1. 队列中只有一个元素时：删除最后一个节点，并将 front 和 rear 指向 NULL。
  2. 队列中有多个元素时：删除 front 指向的节点，并将 front 向后移动。
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	//出队列时，队列不能为空
	assert(!QueueEmpty(q));

	//当队列中只有一个元素的时候，不仅仅头指针需要改变，尾指针也需要改变
	//因为当删除最后一个元素时，首指针释放当前节点，并向后移动，而尾指针并没有移动
	//当释放后若在插入元素时，尾指针会造成野指针的情况
	if (q->front->next == NULL)
	{
		QNode* del = q->front;
		q->front = NULL;
		q->rear = NULL;
		free(del);
	}
	else
	{
		QNode* del = q->front;
		q->front = q->front->next;
		free(del);
	}
	q->size--;
}

3.5 获取队列头部元素

front 指向的节点存储着头部元素。

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	//获取队列头部元素时，队列不能为空
	assert(!QueueEmpty(q));

	return q->front->data;
}

3.6 获取队列队尾元素

rear 指向的节点存储着尾元素。

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	//获取队列头部元素时，队列不能为空
	assert(!QueueEmpty(q));

	return q->rear->data;
}

3.7 获取队列中有效元素个数

结构体中的 size 存储着队列中的有效元素个数

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	//结构体中定义了一个size
	//而这里遍历链表得到个数，效率低O(N)
	/*int size = 0;  不要用
	QNode* cur = q->front;
	while (cur != q->rear)
	{
		size++;
		q->front = q->front->next;
	}*/
	return q->size;
}

3.8 销毁队列

销毁队列与前面销毁单链表相同，需要将每一个节点都释放。

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

4. 整体代码的实现

// 初始化队列 
void QueueInit(Queue* q)
{
	q->front = NULL;
	q->rear = NULL;
	q->size = 0;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->next = NULL;
	newnode->data = data;

	if (q->front == NULL)      //分队列是否有元素两种情况
	{
		assert(q->rear == NULL);
		q->front = newnode;
		q->rear = newnode;
	}
	else
	{
		q->rear->next = newnode;
		q->rear = newnode;
	}

	q->size++;//入队列，队列长度加一
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->front == NULL && q->rear == NULL;
}

// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	//出队列时，队列不能为空
	assert(!QueueEmpty(q));

	//当队列中只有一个元素的时候，不仅仅头指针需要改变，尾指针也需要改变
	//因为当删除最后一个元素时，首指针释放当前节点，并向后移动，而尾指针并没有移动
	//当释放后若在插入元素时，尾指针会造成野指针的情况
	if (q->front->next == NULL)
	{
		QNode* del = q->front;
		q->front = NULL;
		q->rear = NULL;
		free(del);
	}
	else
	{
		QNode* del = q->front;
		q->front = q->front->next;
		free(del);
	}
	q->size--;
}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	//获取队列头部元素时，队列不能为空
	assert(!QueueEmpty(q));

	return q->front->data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	//获取队列头部元素时，队列不能为空
	assert(!QueueEmpty(q));

	return q->rear->data;
}


// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);

	//结构体中定义了一个size
	//而这里遍历链表得到个数，效率低
	/*int size = 0;    不要用
	QNode* cur = q->front;
	while (cur != q->rear)
	{
		size++;
		q->front = q->front->next;
	}*/
	return q->size;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

结尾

注意： 本文提到的效率全部为空间复杂度！！！！
如果有什么建议和疑问，或是有什么错误，大家可以在评论区中提出。
希望大家以后也能和我一起进步！！🌹🌹
如果这篇文章对你有用的话，希望大家给一个三连！！🌹🌹

在这里插入图片描述

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

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

相关文章

最新社区论坛小程序源码 含流量主功能+前后端+部署搭建教程

最新社区论坛小程序源码 含流量主功能+前后端+部署搭建教程

分享一个社区论坛小程序源码&#xff0c;含完整前后端代码包和详细的部署搭建教程&#xff0c;做地方运营很适合&#xff0c;集成了流量主功能&#xff0c;一键轻松开启。 系统功能一览&#xff1a; 广场管理&#xff1a;广场列表&#xff0c;圈子列表&#xff0c;圈子审核 帖…
阅读更多...
CE作业(4)

CE作业(4)

一、准备前提 服务端 客户端 ; 关闭防火墙systemctl stop firewalld 关闭selinux setenforce 0 提供DNS服务的软件叫bind&#xff0c;服务名是named 一、正向解析&#xff1a; 1.装包 yum install bind -y 2.配置服务 vim /etc/named.conf #监听53号端口 #访问的是本…
阅读更多...
​数据库原理及应用上机（实验三 SQL数据查询）

​数据库原理及应用上机（实验三 SQL数据查询）

✨作者&#xff1a;命运之光 ✨专栏&#xff1a;数据库原理及应用上机实验 ​ 目录 ✨一、实验目的和要求 ✨二、实验内容及步骤 ✨三、实验结果 ✨四、附加练习 ✨五、实验总结 &#x1f353;&#x1f353;前言&#xff1a; 数据库原理及应用上机实验报告的一个简单整理…
阅读更多...
用别人的钱创咖啡的业，戴威与陆正耀殊途同归？

用别人的钱创咖啡的业，戴威与陆正耀殊途同归？

文 | 新熔财经 作者 | 和花 近四年来&#xff0c;ofo退押一事没有出现任何明显的转机&#xff0c;但ofo创始人戴威却已经在海外大张旗鼓地开启了名为About Time Coffee的新创业项目。 当“ofo创始人戴威再次创业”的消息登上微博热搜&#xff0c;收获的几乎都是“还钱”的征…
阅读更多...
字符串按规则生成字典

字符串按规则生成字典

带数字的字符串以数字为key倒序生成字典&#xff0c;字符串列表按其元素索引为key倒序生成字典。 【学习的细节是欢悦的历程】 Python 官网&#xff1a;https://www.python.org/ Free&#xff1a;大咖免费“圣经”教程《 python 完全自学教程》&#xff0c;不仅仅是基础那么简…
阅读更多...
实验室云检验信息系统(云LIS源码)

实验室云检验信息系统(云LIS源码)

一、区域云LIS系统概述&#xff1a; 区域云LIS平台源码&#xff0c;系统完全采用B/S架构模式&#xff0c;扩展性强。整个系统的运行基于WEB层面&#xff0c;只需要在对应的工作台安装一个浏览器软件有外网即可访问。 云LIS系统为实验室服务对象提供检验申请、采集标本、结果查…
阅读更多...
【IDEA使用码云教程】

【IDEA使用码云教程】

IDEA使用码云教程 一、下载、安装git二、配置Gitee插件三、克隆项目四、上传项目五、推送项目六、更新项目 一、下载、安装git 1.打开git官网&#xff0c;选择你的操作系统 官网下载地址&#xff1a;https://git-scm.com/downloads 2.根据你的系统位数选择相应的版本下载 系统…
阅读更多...
frp+nginx+xposed搭建xp模块集群

frp+nginx+xposed搭建xp模块集群

frpcnginxxposed搭建xp模块集群 前言实现逻辑配置内网穿透实现负载均衡 前言 为了能够稳定的采集一些app的详情页数据&#xff0c;就得借助xposed&#xff0c;xposed跟NanoHTTPD配合使用就可以在手机端开启接口服务&#xff0c;直接调用手机端的接口就能获取我们想要的数据&am…
阅读更多...
【机器学习】线性模型

【机器学习】线性模型

文章目录 第三章&#xff1a;线性模型一、线性回归模型1.1、线性回归模型1.2、求解线性回归模型&#xff08;时刻要分清维度&#xff09;1.3、多输出线性回归模型 二、线性分类模型2.1、判别函数2.2、概率判别模型2.3、概率生成模型 第三章&#xff1a;线性模型 一、线性回归模…
阅读更多...
怎么把视频压缩到500m以下？

怎么把视频压缩到500m以下？

如何把视频压缩到500m以下&#xff1f;视频文件通常是非常大的&#xff0c;特别是高清视频或超高清视频&#xff0c;因此压缩可以帮助将视频文件大小减小&#xff0c;在有限的存储空间中存储更多的视频文件。较大的视频文件在上传和下载时需要较长时间&#xff0c;而压缩视频文…
阅读更多...
Flink学习——Flink中的时间语义和窗口

Flink学习——Flink中的时间语义和窗口

一、时间语义 1.1 为什么会出现时间语义&#xff1f; flink是一个大数据处理引擎&#xff0c;它的最大特点就是分布式。每一个机器都有自己的时间&#xff0c;那么集群当中的时间应该以什么为准呢&#xff1f; 比如&#xff1a;我们希望统计8-9点的数据时&#xff0c;对并行任…
阅读更多...
使用RSD从DEM数据创建用户高程数据层

使用RSD从DEM数据创建用户高程数据层

李国春 SRTM90和Aster DEM的V2/V3是比较常用的免费共享高程数据。用户下载好以后应用到自己的项目时&#xff0c;经常会需要进行拼接合成和投影重采样等。RSD提供了一种创建自己项目的高程数据的方法。 一. 高程图像生成方法 在自己的项目中&#xff0c;选择图1的菜单。 图1…
阅读更多...
使用LabVIEW AI视觉工具包快速实现SIFT特征检测（含源码）

使用LabVIEW AI视觉工具包快速实现SIFT特征检测（含源码）

‍‍&#x1f3e1;博客主页&#xff1a; virobotics的CSDN博客&#xff1a;LabVIEW深度学习、人工智能博主 &#x1f384;所属专栏&#xff1a;『LabVIEW深度学习实战』 &#x1f37b;上期文章&#xff1a; 使用LabVIEW AI视觉工具包快速实现霍夫圆和霍夫直线检测&#xff08;含…
阅读更多...
Jmeter事务控制器聚合报告

Jmeter事务控制器聚合报告

Jmeter 事务控制器。 在Jmeter中&#xff0c;默认一个取样器就是一个事务事务控制器控制其子集取样器&#xff0c;合并为一个事务 添加&#xff1a;逻辑控制器/Logic Controller -> 事务控制器/Transaction Controller TPS: 服务器每秒处理的事务数在事务控制器下添加多个…
阅读更多...
海康威视iVMS综合安防系统任意文件上传漏洞复现（0day）

海康威视iVMS综合安防系统任意文件上传漏洞复现（0day）

0x01 产品简介 海康威视iVMS集中监控应用管理平台&#xff0c;是以安全防范业务应用为导向&#xff0c;以视频图像应用为基础手段&#xff0c;综合视频监控、联网报警、智能分析、运维管理等多种安全防范应用系统&#xff0c;构建的多业务应用综合管理平台。 0x02 漏洞概述 海…
阅读更多...
利用CX-ONE搭建omron PLC仿真环境

利用CX-ONE搭建omron PLC仿真环境

目录 1 安装参考 2 CX-Simulator 2.1 打开软件 2.2 选择PLC配置文件存放位置 2.3 选择PLC类型 2.4 PLC Unit全部选择 2.5 设置FINS通讯 2.6 设置串口通讯 2.7 建立连接 3 CX-Programmer 3.1 新建工程 3.2 设置PLC型号 3.3 设置网络类型 3.4 设置串口通讯 3.5 设…
阅读更多...
chatgpt在哪用？详谈一下gpt的各方面

chatgpt在哪用？详谈一下gpt的各方面

ChatGPT是一种人工智能技术&#xff0c;它可以通过自然语言交互回答各种问题。这种技术已经被广泛应用于各个领域和场景中&#xff0c;帮助人们更好地获取知识和信息。那么&#xff0c;ChatGPT在哪里使用呢&#xff1f;下面我们来探讨一下。 一.chatgpt在哪用 打开任意的浏览器…
阅读更多...
MSP 现场服务管理

MSP 现场服务管理

什么是现场服务管理 现场服务管理 &#xff08;FSM&#xff09; 是确保有效规划、安排和执行现场服务活动所遵循的做法。它涉及有效利用资源&#xff0c;如人员、技术和材料&#xff0c;以满足客户的服务期限和标准。FSM还涉及现场技术人员&#xff0c;服务交付经理和其他利益…
阅读更多...
救命稻草！阿里P8耗时5月打造的架构师速成手册，千金难求

救命稻草！阿里P8耗时5月打造的架构师速成手册，千金难求

前言 软件行业技术开发从业人员众多&#xff0c;很多程序员朋友在从业2-3年后都会进入一个迷茫期&#xff0c;面对个人发展的瓶颈。即如何从普通开发人员转型成高层次的系统架构师和技术管理人员。对程序员来说&#xff0c;架构师的薪资比较充满诱惑&#xff0c;年薪四五十万对…
阅读更多...
Spring——Spring_XML实现DI

Spring——Spring_XML实现DI

1.实现DI1 1.1DI给对象属性赋值 【1】通过set方法给对象属性赋值 <bean id"user2" class"org.example.User" ><property name"userId" value"1"></property><property name"uname" value"漳卅…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023