栈和队列高频面试题（必刷）： 用队列实现栈 用栈实现队列 实现循环队列 括号匹配

news2024/10/6 2:25:15

文章目录

  • 用队列实现栈
  • 用栈实现队列
  • 实现循环队列
  • 括号匹配

用队列实现栈

题目描述：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通队列的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：
 void push(int x) 将元素 x 压入栈顶。
 int pop() 移除并返回栈顶元素。
 int top() 返回栈顶元素。
 boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

思路：
 使用两个队列，始终保持一个队列为空。当我们需要进行压栈操作时，将数据压入不为空的队列中（若两个都为空，则随便压入一个队列）。当需要进行出栈操作时，将不为空的队列中的数据导入空队列，仅留下一个数据，这时将这个数据返回并且删除即可。判断栈是否为空，即判断两个队列是否同时为空。

在这里插入图片描述

代码示例：

typedef int QDataType;//队列中存储的元素类型

typedef struct QListNode
{
	struct QListNode* next;//指针域
	QDataType data;//数据域
}QListNode;

typedef struct Queue
{
	QListNode* head;//队头
	QListNode* tail;//队尾
}Queue;
//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	//起始时队列为空
	pq->head = NULL;
	pq->tail = NULL;
}

//销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);

	QListNode* cur = pq->head;//接收队头
	//遍历链表，逐个释放结点
	while (cur)
	{
		QListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = NULL;//队头置空
	pq->tail = NULL;//队尾置空
}

//队尾入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QListNode* newnode = (QListNode*)malloc(sizeof(QListNode));//申请新结点
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;//新结点赋值
	newnode->next = NULL;//新结点指针域置空
	if (pq->head == NULL)//队列中原本无结点
	{
		pq->head = pq->tail = newnode;//队头、队尾直接指向新结点
	}
	else//队列中原本有结点
	{
		pq->tail->next = newnode;//最后一个结点指向新结点
		pq->tail = newnode;//改变队尾指针指向
	}
}

//检测队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL;
}

//队头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//检测队列是否为空

	if (pq->head->next == NULL)//队列中只有一个结点
	{
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
	else//队列中有多个结点
	{
		QListNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;//改变队头指针指向
	}
}

//获取队列头部元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//检测队列是否为空

	return pq->head->data;//返回队头指针指向的数据
}

//获取队列尾部元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//检测队列是否为空

	return pq->tail->data;//返回队尾指针指向的数据
}

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

	QListNode* cur = pq->head;//接收队头
	int count = 0;//记录结点个数
	while (cur)//遍历队列
	{
		count++;
		cur = cur->next;
	}
	return count;//返回队列中的结点数
}
/*---以上代码是队列的基本功能实现，以下代码是题解主体部分---*/
typedef struct {
	Queue q1;//第一个队列
	Queue q2;//第二个队列
} MyStack;

/** Initialize your data structure here. */
MyStack* myStackCreate() {
	MyStack* pst = (MyStack*)malloc(sizeof(MyStack));//申请一个MyStack类型的栈
	QueueInit(&pst->q1);//初始化第一个队列
	QueueInit(&pst->q2);//初始化第二个队列

	return pst;
}

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
	//数据压入非空的那个队列
	if (!QueueEmpty(&obj->q1))
	{
		QueuePush(&obj->q1, x);
	}
	else
	{
		QueuePush(&obj->q2, x);
	}
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
	Queue* pEmpty = &obj->q1;//记录空队列
	Queue* pNoEmpty = &obj->q2;//记录非空队列
	if (!QueueEmpty(&obj->q1))
	{
		pEmpty = &obj->q2;
		pNoEmpty = &obj->q1;
	}
	while (QueueSize(pNoEmpty) > 1)
	{
		QueuePush(pEmpty, QueueFront(pNoEmpty));
		QueuePop(pNoEmpty);
	}//将非空队列中的数据放入空队列中，只留下一个数据
	int front = QueueFront(pNoEmpty);//获取目标数据
	QueuePop(pNoEmpty);//删除目标数据
	return front;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
	//获取非空队列的队尾数据
	if (!QueueEmpty(&obj->q1))
	{
		return QueueBack(&obj->q1);
	}
	else
	{
		return QueueBack(&obj->q2);
	}
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
	//两个队列均为空，则MyStack为空
	return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
	QueueDestroy(&obj->q1);//释放第一个队列
	QueueDestroy(&obj->q2);//释放第二个队列
	free(obj);//释放MyStack
}

用栈实现队列

题目描述：

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）。

实现 MyQueue 类：
 void push(int x) 将元素 x 推到队列的末尾。
 int pop() 从队列的开头移除并返回元素。
 int peek() 返回队列开头的元素。
 boolean empty() 如果队列为空，返回 true ；否则，返回 false。

思路：
 使用两个栈，第一个栈只用于数据的输入，第二个栈只用于数据的输出。当需要输出数据，但第二个栈为空时，先将第一个栈中的数据一个一个导入到第二个栈，然后第二个栈再输出数据即可。这样就能够模拟实现一个队列了，即先输入的数据先输出。

在这里插入图片描述

代码示例：

typedef int STDataType;//栈中存储的元素类型

typedef struct Stack
{
	STDataType* a;//栈
	int top;//栈顶
	int capacity;//容量，方便增容
}Stack;

//初始化栈
void StackInit(Stack* pst)
{
	assert(pst);

	pst->a = (STDataType*)malloc(sizeof(STDataType)* 4);//初始化栈可存储4个元素
	pst->top = 0;//初始时栈中无元素，栈顶为0
	pst->capacity = 4;//容量为4
}

//销毁栈
void StackDestroy(Stack* pst)
{
	assert(pst);

	free(pst->a);//释放栈
	pst->a = NULL;//及时置空
	pst->top = 0;//栈顶置0
	pst->capacity = 0;//容量置0
}

//入栈
void StackPush(Stack* pst, STDataType x)
{
	assert(pst);

	if (pst->top == pst->capacity)//栈已满，需扩容
	{
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType)*pst->capacity * 2);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		pst->a = tmp;
		pst->capacity *= 2;//栈容量扩大为原来的两倍
	}
	pst->a[pst->top] = x;//栈顶位置存放元素x
	pst->top++;//栈顶上移
}

//检测栈是否为空
bool StackEmpty(Stack* pst)
{
	assert(pst);

	return pst->top == 0;
}

//出栈
void StackPop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));//检测栈是否为空

	pst->top--;//栈顶下移
}

//获取栈顶元素
STDataType StackTop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));//检测栈是否为空

	return pst->a[pst->top - 1];//返回栈顶元素
}

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

	return pst->top;//top的值便是栈中有效元素的个数
}
/*---以上代码是栈的基本功能实现，以下代码是题解主体部分---*/
typedef struct {
    Stack pushST;//插入数据时用的栈
    Stack popST;//删除数据时用的栈
} MyQueue;

/** Initialize your data structure here. */

MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));//申请一个队列类型
    StackInit(&obj->pushST);//初始化pushST
    StackInit(&obj->popST);//初始化popST

    return obj;
}

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushST, x);//插入数据，向pushST插入
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popST))//popST为空时，需先将pushST中数据导入popST
    {
        while(!StackEmpty(&obj->pushST))//将pushST数据全部导入popST
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    return StackTop(&obj->popST);//返回popST栈顶的元素
}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
    int top = myQueuePeek(obj);
    StackPop(&obj->popST);//删除数据，删除popST中栈顶的元素
    return top;
}

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST)&&StackEmpty(&obj->popST);//两个栈均为空，则“队列”为空
}

void myQueueFree(MyQueue* obj) {
    //先释放两个栈，再释放队列的结构体类型
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
}

实现循环队列

题目描述：

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

实现 MyCircularQueue 类：
 MyCircularQueue(k): 构造器，设置队列长度为 k 。
 Front: 从队首获取元素。如果队列为空，返回 -1 。
 Rear: 获取队尾元素。如果队列为空，返回 -1 。
 enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
 deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
 isEmpty(): 检查循环队列是否为空。
 isFull(): 检查循环队列是否已满。

思路：
 在环形队列中，队列为空时，队头队尾指向同一个位置。当队列不为空时，队头指向插入的第一个数据，队尾指向最后一个数据的下一个位置。当tail+1等于front时，说明环形队列已满。
 注意：环形队列的队尾不能像常规队列中队尾一样指向最后一个数据，如果这样的话，我们将不能区别环形队列的状态是空还是满，因为此时队头和队尾都指向同一个位置。这就意味着，我们必须留出一个空间，这个空间不能存放数据，这样我们才能很好的区别环形队列的状态是空还是满。

在这里插入图片描述

我们如果用一个数组来实现这个环形队列的话，上面这三种状态就对应于以下三种状态：
在这里插入图片描述

可以看出，此时这个数组和环形完全扯不上关系，这其实很简单，我们只需注意判断两个地方：
 1.当指针指向整个数组的后方的时候，让该指针重新指向数组的第一个元素。
 2.当指针指向整个数组的前方的时候，让该指针直接指向数组最后一个有效元素的后面。

这样就使得该数组在逻辑上是“环形”的了。

在这里插入图片描述

代码示例：

typedef struct {
    int* a;//数组模拟环形队列
    int k;//队列可存储的有效数据总数
    int front;//队头
    int tail;//队尾的后一个位置
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));//申请一个环形队列
    obj->a = (int*)malloc(sizeof(int)*(k+1));//开辟队列空间
    //初始时，队头和队尾均为0
    obj->front = 0;
    obj->tail = 0;
    obj->k = k;//设置队列可存储的有效数据个数
    
    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->tail;//当front和tail指向同一位置时，队列为空
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    int tailNext = obj->tail+1;
    if(tailNext == obj->k+1)//当指针指到队列末尾时，指针返回队列开头，使队列循环
    {
        tailNext = 0;
    }
    return tailNext == obj->front;//当tail+1指向的位置与front相同时，队列满
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))//队列已满，不能再插入数据
    {
        return false;
    }
    else//插入数据
    {
        obj->a[obj->tail] = value;
        obj->tail++;

        if(obj->tail == obj->k+1)//使队列循环
            obj->tail = 0;

        return true;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))//当队列为空时，无法再删除数据
    {
        return false;
    }
    else//删除数据
    {
        obj->front++;

        if(obj->front == obj->k+1)//使队列循环
            obj->front = 0;
        
        return true;
    }
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))//当队列为空时，无数据可返回
    {
        return -1;
    }
    else
    {
        return obj->a[obj->front];//返回队头指向的数据
    }
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))//当队列为空时，无数据返回
    {
        return -1;
    }
    else//返回tail-1指向位置的数据
    {
        int tailPrev = obj->tail-1;

        if(tailPrev == -1)//使队列循环
            tailPrev = obj->k;
        
        return obj->a[tailPrev];
    }
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);//先释放动态开辟的数组
    free(obj);//再释放动态开辟的结构体
}

括号匹配

题目描述：

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
 1.左括号必须用相同类型的右括号闭合。
 2.左括号必须以正确的顺序闭合。

要求：
 时间复杂度：O(n)

思路：
 该题是栈的典型应用，满足后进先出的规则（后入栈的前括号将优先与先出现的后括号相匹配）。
 遍历字符串，遇到前括号直接入栈。遇到后括号，判断该后括号与栈顶的前括号是否匹配（若此时栈为空，则字符串无效），若不匹配则字符串无效；若匹配则删除栈顶元素，继续遍历字符串，直到字符串遍历完毕。当字符串遍历完后，检测栈是否为空，若为空，则字符串有效，若不为空，说明有前括号未匹配，字符串无效。

代码示例：

typedef char STDataType;//栈中存储的元素类型

typedef struct Stack
{
	STDataType* a;//栈
	int top;//栈顶
	int capacity;//容量，方便增容
}Stack;

//初始化栈
void StackInit(Stack* pst)
{
	assert(pst);

	pst->a = (STDataType*)malloc(sizeof(STDataType)* 4);//初始化栈可存储4个元素
	pst->top = 0;//初始时栈中无元素，栈顶为0
	pst->capacity = 4;//容量为4
}

//销毁栈
void StackDestroy(Stack* pst)
{
	assert(pst);

	free(pst->a);//释放栈
	pst->a = NULL;//及时置空
	pst->top = 0;//栈顶置0
	pst->capacity = 0;//容量置0
}

//入栈
void StackPush(Stack* pst, STDataType x)
{
	assert(pst);

	if (pst->top == pst->capacity)//栈已满，需扩容
	{
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType)*pst->capacity * 2);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		pst->a = tmp;
		pst->capacity *= 2;//栈容量扩大为原来的两倍
	}
	pst->a[pst->top] = x;//栈顶位置存放元素x
	pst->top++;//栈顶上移
}

//检测栈是否为空
bool StackEmpty(Stack* pst)
{
	assert(pst);

	return pst->top == 0;
}

//出栈
void StackPop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));//检测栈是否为空

	pst->top--;//栈顶下移
}

//获取栈顶元素
STDataType StackTop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));//检测栈是否为空

	return pst->a[pst->top - 1];//返回栈顶元素
}

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

	return pst->top;//top的值便是栈中有效元素的个数
}
/*---以上代码是栈的基本功能实现，以下代码是题解主体部分---*/
bool isValid(char * s){
    Stack st;//创建一个栈
    StackInit(&st);//初始化栈
    char* cur = s;//cur用于遍历字符串
    while(*cur)
    {
        if(*cur == '('||*cur == '{'||*cur == '[')//前括号统一入栈
        {
            StackPush(&st, *cur);
            cur++;
        }
        else
        {
            if(StackEmpty(&st))//若遇到后括号，且栈为空，则字符串无效
            {
                StackDestroy(&st);
                return false;
            }
            char top = StackTop(&st);//获取栈顶元素
            if((top == '('&&*cur != ')')
            ||(top == '{'&&*cur != '}')
            ||(top == '['&&*cur != ']'))//后括号与栈顶的前括号不匹配
            {
                StackDestroy(&st);
                return false;
            }
            else//匹配
            {
                StackPop(&st);
                cur++;
            }
        }
    }
    bool ret = StackEmpty(&st);//检测栈是否为空
    StackDestroy(&st);
    return ret;//栈为空返回true，栈不为空返回false
}

如此明了清晰的详解过程，希望各位看官能够一键三连哦💕

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

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

相关文章

新项目 使用 IDEA 搭建后端环境 及 搭建是可能遇到的 问题 及解决方法

新项目 使用 IDEA 搭建后端环境 及 搭建是可能遇到的 问题 及解决方法

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 新项目 使用 IDEA 搭建后端环境 及 搭建是可能遇到的 问题 及解决方法 前言 提示：这里可以添加本文要记录的大概内容： 新项目 使用 IDEA 搭建后端环…
阅读更多...
【群智能算法改进】一种改进的沙丘猫群优化算法 改进沙丘猫群算法 改进SCSO[2]【Matlab代码#36】

【群智能算法改进】一种改进的沙丘猫群优化算法 改进沙丘猫群算法 改进SCSO[2]【Matlab代码#36】

文章目录 【获取资源请见文章第5节：资源获取】1. 原始沙丘猫群优化算法2. 改进沙丘猫群算法2.1 非线性自适应参数2.2 Cauchy变异策略2.3 最优邻域扰动策略 3. 部分代码展示4. 仿真结果展示5. 资源获取6. 参考文献 【获取资源请见文章第5节：资源获取】 1.…
阅读更多...
华为OD机试真题B卷 Java 实现【光伏场地建设规划】，附详细解题思路

华为OD机试真题B卷 Java 实现【光伏场地建设规划】，附详细解题思路

一、题目描述 祖国西北部有一片大片荒地，其中零星的分布着一些湖泊，保护区，矿区；整体上常年光照良好，但是也有一些地区光照不太好。某电力公司希望在这里建设多个光伏电站，生产清洁能源。对每平方公里的土…
阅读更多...
主动打包、高效管理的主题工具：逐浪HMS主题大师1.5-即速推送、华为小组件缓存优化、锁屏提取、资源审计、技术秘笈，移动主题设计利器

主动打包、高效管理的主题工具：逐浪HMS主题大师1.5-即速推送、华为小组件缓存优化、锁屏提取、资源审计、技术秘笈，移动主题设计利器

主动打包、高效管理的主题工具：逐浪HMS主题大师1.5-即速推送、华为小组件缓存优化、锁屏提取、资源审计、技术秘笈，移动主题设计利器 主动打包：逐浪HMS主题大师1.3-即速推送、华为小组件缓存优化、锁屏提取、资源审计、技术秘笈，移…
阅读更多...
【经验分享】uniapp项目GIT如何忽略unpackage文件

【经验分享】uniapp项目GIT如何忽略unpackage文件

最近的uniapp项目踩了个坑，就是建完项目，提交代码后，运行发布微信小程序，生成了unpackage里的build文件，这个时候提交总是提交一堆编译后的文件，甚至造成冲突。即使在.gitignore文件中写入忽略unpackage目录…
阅读更多...
C++ 小区物业管理系统（QT图形界面）

C++ 小区物业管理系统（QT图形界面）

目录 一、项目介绍 二、项目展示 三、源码分享 一、项目介绍 小区物业管理系统 (一)课题内客 该系统要求建立某小区物业管理系绕，并具有排序﹑查找﹒计算﹑显示等功能，通过此课题，熟练掌握文件﹐指针的各种操作，以及一些算法思…
阅读更多...
某内Java课程（整套视频+课件）

某内Java课程（整套视频+课件）

某内Java课程 需要整套视频文件（视频课件）：(V: t_shopnet) 1 FUNDAMENTALO1 01: 对象和类(上)(6 am.mp4 01: 对象和类(上) (6 pm.mp4 02: 对象和类(下) (3) am .mp4 02: 对象和类(下) (3) pm.mp4 引用类型数组、继承的意义 (上) (3) am.mp403…
阅读更多...
SOLIDWORKS流程模拟： 需要多少个CPU核心？

SOLIDWORKS流程模拟： 需要多少个CPU核心？

客户经常会问，他们应该为SOLIDWORKS Flow Simulation购买什么工作站，以尽可能快地解决他们的计算流体力学（CFD）问题。遗憾的是，这个问题后面往往有一个无法实现的期望，如 "一切都需要在10分钟内解决&q…
阅读更多...
十分钟读懂Stable Diffusion运行原理

十分钟读懂Stable Diffusion运行原理

AIGC 热潮正猛烈地席卷开来，可以说 Stable Diffusion 开源发布把 AI 图像生成提高了全新高度，特别是 ControlNet 和 T2I-Adapter 控制模块的提出进一步提高生成可控性，也在逐渐改变一部分行业的生产模式。惊艳其出色表现，也不禁好…
阅读更多...
逆向python窃密软件

逆向python窃密软件

python发布的软件包一般逆向方法是，先使用pyinstxtractor获取到关键性pyc文件，再使用pycdc（又叫Decompyle++）将pyc文件反汇编成py源代码文件。 pyinstxtractor使用方法 将反编译的 Python 源打印到标准输出 python pyinstxtractor.py <filename>pycdc使用方法 对照…
阅读更多...
BBC Studios 和 Reality+ 联手将节目《疯狂汽车秀》和《异世奇人》带入 The Sandbox 元宇宙

BBC Studios 和 Reality+ 联手将节目《疯狂汽车秀》和《异世奇人》带入 The Sandbox 元宇宙

双方将携手在元宇宙推出一系列基于 BBC 世界著名品牌和节目的沉浸式体验。 今天标志着一个 The Sandbox 元宇宙的历史性时刻&#xff01;我们非常高兴地宣布&#xff0c;通过与 BBC Studios 和 web3 专家 Reality 的合作在 The Sandbox 平台带来全新体验&#xff0c;玩家可以与…
阅读更多...
Franklin-Reiter相关消息攻击

Franklin-Reiter相关消息攻击

文章目录 知识导入&#xff1a;题一题目描述&#xff1a;题目分析&#xff1a; 题二题目描述&#xff1a;题目分析&#xff1a; 题三题目描述&#xff1a;题目分析&#xff1a; 收获与体会&#xff1a; 知识导入&#xff1a; 总结&#xff1a; Franklin-Reiter相关消息攻击(Fra…
阅读更多...
数据库管理-第七十九期 儿童节惊魂（20230601）

数据库管理-第七十九期 儿童节惊魂（20230601）

数据库管理 2023-06-01 第七十九期 儿童节惊魂1 主板挂了&#xff1f;2 时间同步3 数据库参数4 ACFS5 两个错误总结 第七十九期 儿童节惊魂 6月第一天&#xff0c;又是儿童节&#xff0c;加上客户现场来了不少娃&#xff0c;也有一些客户家里有娃去参加活动了&#xff0c;所以…
阅读更多...
EMC学习笔记（一）PCB电路板层的设置

EMC学习笔记（一）PCB电路板层的设置

EMC学习笔记&#xff08;一&#xff09;PCB电路板层的设置 1.概述2.合理的层数2.1 VCC、GND的层数2.2信号层数 3.单板的性能指标与成本要求4.电源层、地层、信号层的相对位置4.1 VCC\GND平面的阻抗以及电源、地之间的EMC环境问题4.2 VCC、GND作为参考平面&#xff0c;两者的作用…
阅读更多...
OneNav Extend网址导航书签系统源码开源版

OneNav Extend网址导航书签系统源码开源版

简介&#xff1a; OneNav Extend 是一款开源免费的书签&#xff08;导航&#xff09;管理程序&#xff0c;使用PHP SQLite 3开发&#xff0c;界面简洁&#xff0c;安装简单&#xff0c;使用方便。 OneNav可帮助你你将浏览器书签集中式管理&#xff0c;解决跨设备、跨平台、跨…
阅读更多...
10.Ansible Loops介绍

10.Ansible Loops介绍

Ansible Loops是什么&#xff1f;以及实际例子 就是循环语句。让我们看看这个创建Playbook的示例&#xff61;要使用用户模块在系统中创建用户,在本例中, 我们只创建一个用户&#xff61;但是如果我们有多个用户呢? name: Create users hosts: localhost tasks:- user: name g…
阅读更多...
城市二次供水设备远程监控解决方案

城市二次供水设备远程监控解决方案

城市二次供水设备远程监控解决方案 一、项目背景 近年来&#xff0c;随着我国城市日新月异的发展,新建商场和小区高层逐渐的增多&#xff0c;需要二次供水的楼盘也在逐渐增多。二次供水模式成了城市普遍的供水模式&#xff0c;当前普遍采用传统供水方式存在着供水水源、加压供…
阅读更多...
Sentinel怎么使用和控制台讲解

Sentinel怎么使用和控制台讲解

Sentinel 基础 官网 1 Github: https://github.com/alibaba/Sentinel 2 快速开始: https://sentinelguard.io/zh-cn/docs/quick-start.html 3 中文: https://github.com/alibaba/Sentinel/wiki/介绍 4 使用手册: https://spring-cloud-alibaba-group.github.io/github-pag…
阅读更多...
LNMP搭建过程详解，验证搭建论坛

LNMP搭建过程详解，验证搭建论坛

LNMP搭建过程详解&#xff0c;验证搭建论坛 一、安装Nginx服务1、安装依赖包2、创建运行用户3、编译安装4、优化路径5、添加Nginx 系统服务 二、安装MySQL服务1、安装Mysql环境依赖包2、创建运行用户3、编译安装4、修改mysql配置文件5、更改mysql安装目录和配置文件的属主属组6…
阅读更多...
【C/C++】基础知识之输入输出流

【C/C++】基础知识之输入输出流

创作不易&#xff0c;本篇文章如果帮助到了你&#xff0c;还请点赞 关注支持一下♡>&#x16966;<)!! 主页专栏有更多知识&#xff0c;如有疑问欢迎大家指正讨论&#xff0c;共同进步&#xff01; &#x1f525;c系列专栏&#xff1a;C/C零基础到精通 &#x1f525; 给大…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023