【数据结构】数据结构中的隐藏玩法——栈与队列

news2024/11/20 2:22:20

前言：

哈喽大家好，我是野生的编程萌新，首先感谢大家的观看。数据结构的学习者大多有这样的想法：数据结构很重要，一定要学好，但数据结构比较抽象，有些算法理解起来很困难，学的很累。我想让大家知道的是：数据结构非常有趣，很多算法是智慧的结晶，我希望大家在学习数据结构的过程是一种愉悦的心情感受。因此我开创了《数据结构》专栏，在这里我将把数据结构内容以有趣易懂的方式展现给大家。

1.栈

1.1栈的定义

怎么给大家引入队列概念呢？有了，我们在中学学习化学时肯定接触过下面这个实验器材：

胶头滴管是我们在学习化学常使用的一种实验器材，胶头滴管用于精确地滴取液体。它通常由一个透明的玻璃或塑料瓶身和一个连接瓶身和滴液管的胶头组成。 我们使用时一般是将胶头浸入所需液体中，轻轻按压胶头，使其充满液体，将胶头滴管垂直放置到需要滴液的容器中，轻轻松开手指，让液体滴下。后进入胶头滴管的液体将会先滴出，先进入的胶头滴管的液体反而后滴出，像这样的例子反而可以引入数据结构——栈。

在我们软件应用中，栈这种后进先出的数据结构的应用是非常普遍的。比如我们用浏览器上网时不管什么浏览器都有一个“后退键”，当我们点击后可以按访问顺序逆序加载浏览过的网站。比如你正在浏览一篇介绍C语言相关内容的博客，你在看博主分享的代码，突然发现一个函数博主没详细介绍，你也不了解这个函数的功能，打开了CPlusPlus网站搜索它的功能，找到之后你又想返回去接着阅读，这时候单击左上角的“后退键”。如下图：

很多软件都有撤销操作，这也是使用栈来实现的，当然不同的软件具体实现代码会有很大差异，不过原理都是一样的。 栈是限定仅在表尾进行插入和删除操作的线性表。我们把允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈，栈又称为先进后出（Last In First Out）的线性表，简称LIFO结构。首先我们要知道栈是一个线性表，也就是说，栈元素具有线性关系，即前驱后驱关系，只不过它是一种特殊的线性表，前面定义中提到了在线性表的表尾进行插入和删除操作，这里的表尾指得是栈顶，而不是栈底。它的特殊之处就在于限制了这个线性表的插入和删除位置，他始终只在栈顶进行，这也就使得：栈底是固定的，最先进入栈的只能在栈底。栈的插入操作，叫做进栈，也叫压栈、入栈。

栈的删除操作，叫做出栈，有的也叫弹线。 

1.2进栈出栈的变化形式

这个最先进栈的元素，是不是只能是最后出栈呢？答案是不一定的，要看什么情况。栈对线性表的插入和删除的位置进行了限制，并未对元素出栈的时间进行限制，也就是说，在不是所有的元素都进栈的情况下，事先进入栈的元素也可以出栈，只要保证是栈顶元素就行，举例来说，如果我们现在是3个整型数字1、2、3依次进栈，会有哪些出栈的次序呢？

  1. 第一种：1、2、3进，再3、2、1出，这是最简单最好理解的一种，出栈次序为3、2、1。
  2. 第二种：1进，1出，2进，2出，3进，3出，也就是一个一个出嘛，出栈次序为1、2、3。
  3. 第三种：1进，2进，2出，1出，3进，3出。出栈次序为2、1、3。
  4. 第四种：1进，1出，2进，3进，3出，2出。出栈顺序为1、3、2。
  5. 第五种：1进，2进，2出，3进，3出，1出。出栈顺序为2、3、1。

有没有可能是3、1、2这样的次序呢？肯定是不会的，因为3先出栈的话，就意味着3曾经进过栈，既然3都进栈了，那么1和2也早就进栈了，此时2一定是在1的上面，更接近栈顶，那么出栈只可能是3、2、1，不然不满足1、2、3依次进栈的要求，所以不会出现1会比2先出栈的情况。下面给大家举两个简单的练习：

1.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（ ）。

A.12345ABCDE

B.EDCBA54321

C.ABCDE12345

D.54321EDCBA

答案：B

2.若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）

A.1432

B.2341

C.3142

D.3421

答案：C

1.3栈的各个功能的实现

上面我们也提到了栈是一个特殊的线性表，所以线性表的顺序存储和链式存储对于栈来说，也同样适用。所以栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些：

  1. 存储效率高：数组使用连续的内存空间存储数据，在访问元素时，可以直接通过索引访问，不需要额外的指针，因此访问速度更快。而链表每个节点需要存储数据和指向下一个节点的指针，占用更多的内存空间。
  2. 空间效率高：数组的存储空间是预先分配的连续内存块，不需要额外的指针来表示节点之间的链接关系，因此相对于链表来说，占用的内存空间更小。
  3. 实现简单：使用数组实现栈，只需要一个指针来表示栈顶的位置，通过调整指针的位置即可进行进栈和出栈操作。而链表实现栈需要额外的指针来表示栈顶和节点之间的链接关系，实现起来更加复杂。
  4. 随机访问：由于数组支持随机访问，可以直接通过索引访问栈中的任意元素。而链表只支持顺序访问，需要从头节点开始依次遍历到目标节点。
  5. 空间预分配：数组在创建时需要指定大小，可以根据需求进行空间的预分配。而链表可以根据实际情况动态调整大小，但可能会导致频繁的内存分配和释放操作。

所以在这里我们就是用数组来实现栈。我们先来定义一下栈的结构：

typedef int STDatatype;
typedef struct stack
{
	STDatatype* a;
	int top;      //栈顶
	int capacity;//容量
}ST;

1.3.1栈的初始化和销毁

通过上面栈的结构的定义，可以看出来它和我们之前写的顺序表极其相似，栈的初始化和顺序表基本相同：函数接受一个指向栈对象的指针pst，并使用assert断言函数确保pst不为 NULL，以确保安全性。接下来，将栈对象pst的成员变量a设置为 NULL。这表示栈中的元素存储数组当前为空，因为还没有分配内存。将栈对象pst的成员变量capacity设置为 0,这表示栈的当前容量为0，还没有分配内存。那么top初始化也为0吗？很多的数据结构相关书籍在介绍栈的初始化的时候都将top初始化为-1，这是因为栈为空栈的时候top等于0，当栈中有一个元素的时候top也为0，因此通常把空栈的判定条件定位top等于-1。当然将top初始化为0也是可以的，top的意义会发生变化，这时候我们让top指向的时栈顶的下一个元素。大多数书上都是以-1来初始化，那我就用0来初始化。我们来实现一下栈的初始化函数：

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->capacity = 0;
	pst->top = 0;
}

 栈的销毁是将栈占用的内存空间释放掉，栈的销毁具体操作步骤为：

  1. 将栈对象的成员变量a设置为 NULL，表示栈中的元素存储数组为空。
  2. 将栈对象的成员变量capacity设置为 0，表示栈的容量为0。
  3. 将栈对象的成员变量top设置为 0，表示栈为空。

我们来实现一下栈的销毁：

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

1.3.2栈中的入栈和出栈操作

栈的入栈具体操作步骤为：

  1. 检查栈是否已满。如果栈已满，那么无法将新元素入栈。这种情况下，可能需要扩展栈的容量或者处理溢出的方式。
  2. 如果栈未满，则将新元素放置在栈顶位置。
  3. 前面我们说了给top定义为0（即栈顶的下一个元素），所在这里我们还要将top+1。

我们来实现一下入栈的操作：

void STPush(ST* pst, STDatatype x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		ST* tmp = (ST*)realloc(pst->a, sizeof(ST));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return -1;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

栈的出栈具体操作步骤为：

  1. 检查栈是否为空。如果栈为空，无法执行出栈操作，因为栈中没有元素可以出栈，这时候我们可以使用assert断言一下。
  2. 如果栈非空，则将栈顶元素移除。在数组实现栈中，可以通过将栈顶指针减1，来实现将栈顶元素出栈。

我们来具体实现一下出栈的操作：

void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}

1.3.3栈中的其他操作

 我们在栈中能进行的操作不仅仅只有入栈和出栈两种操作，在这里再和大家介绍一些其他的操作。首先先来介绍获取栈顶元素操作，其具体操作步骤为：

  1. 检查栈是否为空。如果栈为空，无法获取栈顶元素，因为栈中没有元素可用。这时候我们仍然可以用assert来断言一下。

  2. 如果栈非空，则返回栈顶元素的值。注意不要返回top所在位置，因为我们给它的定义是栈顶的下一个元素。

我们来实现一下获取栈顶元素的函数：

STDatatype STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}

获取栈中元素的个数实现就简单了，直接返回top的值即可，我们来实现一下这个函数：

int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

 判断栈是否为空我们只需要判断top是否为0即可，我们来实现一下 ：

int STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

1.4多文件实现栈

stack.h文件：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int STDatatype;
typedef struct stack
{
	STDatatype* a;
	int top;      //栈顶
	int capacity;//容量
}ST;
void STInit(ST* pst);//栈的初始化
void STPush(ST* pst, STDatatype x);//栈的插入
void STPop(ST* pst);//栈的删除
STDatatype STTop(ST* pst);//获取栈顶元素
int STSize(ST* pst);//获取栈中有效的元素个数
int STEmpty(ST* pst);//检测栈是否为空
void STDestroy(ST* pst);//栈的销毁

 stack.c文件：

#include"stack.h"
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->capacity = 0;
	pst->top = 0;
}
void STPush(ST* pst, STDatatype x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		ST* tmp = (ST*)realloc(pst->a, sizeof(ST));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return -1;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}
STDatatype STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}
int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}
int STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

test.c文件（用来测试函数功能）：

#include"stack.h"
void Test1()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	STPush(&s, 4);
	printf("%d ", STTop(&s));
	STPop(&s);
	printf("%d\n", STTop(&s));
	STPop(&s);
	STPush(&s, 4);
	STPush(&s, 5);
	while (!STEmpty(&s))
	{
		printf("%d ", STTop(&s));
		STPop(&s);
	}
	printf("\n");
}
int main()
{
	Test1();
	return 0;
}

 

2.队列 

2.1队列的定义

 大家在使用电脑的时候都应该经历过这种情况：电脑有时候疑似死机状态，鼠标点击什么都好像没有效果，无论怎么点击文件都没动静，就当我们失去耐心的时候，想要将它重启的时候，它好像清醒过来一样，把你刚才的操作全部按顺序执行了一遍——疯狂弹窗。这是因为操作系统在当时CPU一时忙不过来，等前面的事情忙完之后，后面多个指令需要通过一个通道输出，按先后次序排队执行造成的结果。再比如我们在某个网红店铺进行网购时，我们想要询问客服时，客服人员相对于顾客是较少的，在所有客服都占线的情况下，客户会被要求等待，直到某个客服空下来，才能让和先等待的客户联系，这里也是因为对当前所有联系客服的客户进行了排队处理。

上面的例子中都是应用了一种数据结构来实现刚才提到的先进先出的排队功能，这就是队列。队列是只允许一端进行插入的操作，而在另一端进行删除操作的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO，允许插入的一端称为队尾，允许删除的一端称为队头。下图中1就是这个队列的队头，4是这个队列的队尾。这样我们就可以删除时总是从队头开始，而插入时从队尾插入。这也符合我们的一个习惯：排在第一个优先出队列，最后来的排队尾。

2.2 队列的各个功能的实现

队列和栈一样也是一种特殊的线性表，它一般也可以使用数组或者链表来实现，队列和栈不一样，它使用链表实现更优一些：

  1. 动态扩容：链表实现的队列可以动态地增加或减少节点，不需要预先定义容量。当需要插入新的元素时，可以直接创建新的节点并将其插入到队列的尾部，而不需要考虑数组的容量限制。这样可以更灵活地适应不同规模的数据。
  2. 内存利用率高：链表实现的队列只会使用实际需要的内存，不会浪费额外的内存。相比之下，数组实现的队列必须预先分配一定大小的连续内存空间，如果队列的实际大小远小于数组的容量，就会造成内存浪费。
  3. 插入和删除操作高效：链表实现的队列在插入和删除操作上具有较高的效率。在链表中插入或删除一个节点的时间复杂度是 O(1)，而在数组中插入或删除一个元素则需要移动其他元素，其时间复杂度是 O(n)。当队列的规模很大时，链表实现的队列会更加高效。
  4. 队列长度无限制：链表实现的队列的长度理论上没有限制，只受限于计算机内存的大小。相比之下，使用数组实现的队列必须预先定义一个固定的容量，当元素数量超过容量时，需要进行扩容操作。
  5. 更容易实现其他特殊操作：链表实现的队列更容易实现一些特殊操作，例如反转队列、合并队列等。这是因为链表的灵活性和可动态调整的特性，使得实现这些操作更为简单。

 在这里我们使用链表来实现队列，我们先来定义一下队列的结构：

typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;
typedef struct Queue
{
	QNode* phead;
	QNode* tail;
	int size;
}Queue;

在上面的定义中，我们首先定义了一个结构体QueueNode，用该结构体表示队列中的节点，它包含两个成员变量：

  1. data：存放在节点中的数据。
  2. next：指向下一个节点的指针。

 然后又定义了一个结构体Queue来表示队列本身，它包含三个成员变量：

  1. phead：指向队列头部的指针。该指针指向队列中的第一个节点。
  2. tail：指向队列尾部的指针。该指针指向队列中的最后一个节点。
  3. size：表示队列的大小，即队列中节点的数量。

2.2.1队列的初始化和销毁

 我们初始化时只需要将队列的成员变量初始化为合适的初值就可以了，我们来实现一下队列的初始化：

void QueueInit(Queue* q)
{
	assert(q);
	q->phead = q->tail = NULL;
	q->size = 0;
}

 队列销毁的操作具体步骤为：

  1. 遍历队列元素：从队列的头指针开始，依次遍历队列中的每个节点。

  2. 释放节点内存：通过free函数释放每个节点的内存空间。确保释放节点时，先保存下一个节点的指针，然后释放当前节点的内存。

  3. 然后将队列的头指针和尾指针置空，给size赋值为0，表示是一个空的队列。

我们来实现一下队列的销毁：

void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->phead = q->tail = NULL;
	q->size = 0;
}

2.2.2队列的入队和出队操作

使用上面的定义方法使我们在队列的操作更加方便快捷：

  1. 入队操作可以将新元素添加到队列的尾部，只需将新节点插入到tail指针所指的节点后面，并更新tail指针为新节点。
  2. 出队操作可以从队列的头部删除一个元素，只需将phead指针指向下一个节点，并释放原来头部节点的内存空间。
  3. 获取队列大小只需直接访问size变量的值。

 我们先来实现一下队列的入队操作：

void QueuePush(Queue* q, QDataType x)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return -1;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (q->tail == NULL)
	{
		q->phead = q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}

我们来实现一下队列的出队操作：

void QueuePop(Queue* q)
{
	assert(q);
	assert(q->phead);
	QNode* cur = q->phead;
	q->phead = q->phead->next;
	free(cur);
	cur = NULL;
	if (q->phead == NULL)
		q->tail = NULL;
	q->size--;
}

既然在上面提到了获取队列的大小，那我们就来实现一下：

int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}

2.2.3获取队列的队头和队尾元素

获取队列的队头元素的具体操作步骤为：

  1. 检查队列是否为空：判断队列的头指针是否为空，如果为空则表示队列为空，无法获取队头元素。
  2. 返回队头元素的值：如果队列不为空，直接返回队列的头指针所指向的节点的值。

我们来实现一下获取队头元素的操作：

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->phead);
	return q->phead->data;
}

获取队尾元素操作的具体步骤为：

  1. 检查队列是否为空，如果队列为空，则无法获取队尾元素。
  2. 返回队尾元素的值：如果队列不为空，直接返回队列尾指针所指向节点的值。

我们来实现一下获取队尾元素的操作：

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->tail);
	return q->tail->data;
}

2.3多文件实现队列

Queue.h文件：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;
typedef struct Queue
{
	QNode* phead;
	QNode* tail;
	int size;
}Queue;
void QueueInit(Queue* q);//队列的初始化
void QueuePush(Queue* q, QDataType x);//队尾入队列
void QueuePop(Queue* q);//对头出队列
QDataType QueueFront(Queue* q);//获取队头元素
QDataType QueueBack(Queue* q);//获取队尾元素
int QueueSize(Queue* q);//获取队列中的元素个数
int QueueEmpty(Queue* q);//检测队列是否为空
void QueueDestroy(Queue* q);//队列的销毁

Queue.c文件：

#include"Queue.h"
void QueueInit(Queue* q)
{
	assert(q);
	q->phead = q->tail = NULL;
	q->size = 0;
}
void QueuePush(Queue* q, QDataType x)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return -1;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (q->tail == NULL)
	{
		q->phead = q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}
void QueuePop(Queue* q)
{
	assert(q);
	assert(q->phead);
	QNode* cur = q->phead;
	q->phead = q->phead->next;
	free(cur);
	cur = NULL;
	if (q->phead == NULL)
		q->tail = NULL;
	q->size--;
}
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->phead);
	return q->phead->data;
}
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->tail);
	return q->tail->data;
}
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->phead == NULL;
}
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->phead = q->tail = NULL;
	q->size = 0;
}

test.c文件（用来测试函数功能）：

#include"Queue.h"
void Test1()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	printf("\n");
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");
	QueueDestroy(&q);

}
int main()
{
	Test1();
	return 0;
}

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

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

相关文章

二叉树——进阶（递归创建，非递归，广度优先，翻转，深度，对称）

二叉树——进阶（递归创建，非递归，广度优先，翻转，深度，对称）

二叉树——进阶 二叉树的递归创建非递归前中后序遍历非递归前序遍历非递归中序遍历非递归后序遍历 广度优先遍历二叉树&#xff08;层序遍历&#xff09;翻转二叉树 二叉树深度最大深度最小深度 对称二叉树 二叉树的递归创建 1&#xff0c;二叉树是一种结构相对固定的数据&…
阅读更多...
SpringBoot接入Knife4j接口文档

SpringBoot接入Knife4j接口文档

0.介绍 1&#xff09; Knife4j是什么 Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案&#xff0c;前身是swagger-bootstrap-ui&#xff0c;有着比Swagger更为美观的UI以及功能。 例如以下效果图&#xff1a; 2&#xff09; 官方链接 官网&#xff1a;Knife4j …
阅读更多...
Mujava 工具的简单使用

Mujava 工具的简单使用

首先下载openjava.jar和mujava.jar&#xff0c;以及自己手写一个mujava.config指向存放mujava的目录&#xff0c;并将这些文件放在mujava目录下。此时&#xff0c;基本的mujava环境就搭建好了。 分别创建src&#xff08;存放源码文件&#xff09;、classes&#xff08;存放源码…
阅读更多...
使用pygame绘制图形

使用pygame绘制图形

参考链接&#xff1a;https://www.geeksforgeeks.org/pygame-tutorial/?reflbp 在窗口中绘制单个图形 import pygame from pygame.locals import * import sys pygame.init()window pygame.display.set_mode((600,600)) window.fill((255,255,255))# pygame.draw.rect(wind…
阅读更多...
针对上一篇微信同声传译语音播报部分坑的解决和优化

针对上一篇微信同声传译语音播报部分坑的解决和优化

1. 上一篇语音播报其实是不完美的&#xff0c;就是如何停止上一个音频开始下一个音频的问题&#xff0c;我在此做一下修改 比如说&#xff1a;现在正在播放1&#xff0c;我点击2让2开始播放&#xff0c;1停止播放&#xff0c;我上面的写法是有问题的&#xff1a; 通过 innerAu…
阅读更多...
编译器 编译过程 compiling 动态链接库 Linking 接口ABI LTO PGO inline bazel增量编译

编译器 编译过程 compiling 动态链接库 Linking 接口ABI LTO PGO inline bazel增量编译

编译器 编译过程 compiling 动态链接库 Linking 接口ABI LTO PGO Theory Shared Library Symbol Conflicts (on Linux) 从左往右查找：Note that the linker only looks further down the line when looking for symbols used by but not defined in the current lib.Linux 下…
阅读更多...
【全部更新完毕】2024电工杯B题详细思路代码成品文章教学：大学生平衡膳食食谱的优化设计及评价

【全部更新完毕】2024电工杯B题详细思路代码成品文章教学：大学生平衡膳食食谱的优化设计及评价

大学生平衡膳食食谱的优化设计及评价 摘要 大学阶段是学生获取知识和身体发育的关键时期&#xff0c;也是形成良好饮食习惯的重要阶段。然而&#xff0c;当前大学生中存在饮食结构不合理和不良饮食习惯的问题&#xff0c;主要表现为不吃早餐或早餐吃得马虎&#xff0c;经常食用…
阅读更多...
JVM学习-垃圾收集器(三)

JVM学习-垃圾收集器(三)

G1回收器-区域化分代式 为了适应不断扩大的内存和不断增加的处理器数量&#xff0c;进一步降低暂停时间&#xff0c;同时兼顾良好的吞吐量官方给G1设定的目标&#xff1a;延迟可控的情况下获得尽可能高的吞吐量&#xff0c;所以才担当起“全功能收集器”的重任与期望G1是一款面…
阅读更多...
构建数字未来：探索Web3在物联网中的新视角

构建数字未来：探索Web3在物联网中的新视角

引言 随着Web3时代的来临&#xff0c;物联网技术正迎来一场新的变革。在这个数字化时代&#xff0c;Web3所带来的技术创新将为物联网的发展开辟新的视角。本文将深入探讨Web3在物联网领域的应用&#xff0c;揭示其在构建数字未来中的重要性和影响。 Web3与物联网的融合 区块链…
阅读更多...
Docker学习笔记(二)Dockerfile自定义镜像、DockerCompose、Docker私有镜像仓库

Docker学习笔记(二)Dockerfile自定义镜像、DockerCompose、Docker私有镜像仓库

文章目录 前言3 Dockerfile自定义镜像3.1 镜像结构3.2 Dockerfile文件3.3 构建自定义镜像3.3.1 基于Ubuntu构建Java项目3.3.2 基于Java8构建Java项目 3.4 小结 4 DockerCompose4.1 安装DockerCompose4.2 部署微服务集群 5 Docker私有镜像仓库 前言 Docker学习笔记(一)安装Dock…
阅读更多...
ctfhub中的SSRF的相关例题（下）

ctfhub中的SSRF的相关例题（下）

目录 URL Bypass 知识点 相关例题 数字IP Bypass 相关例题 方法一&#xff1a;使用数字IP 方法二&#xff1a;转16进制 方法三&#xff1a;用localhost代替 方法四&#xff1a;特殊地址 302跳转 Bypass ​编辑 关于localhost原理: DNS重绑定 Bypass 知识点&…
阅读更多...
每日练习之数学——砝码和天平

每日练习之数学——砝码和天平

砝码和天平 题目描述 运行代码 #include<iostream> using namespace std; int main() {int w,m,T;cin>>T;while(T--){cin>>w>>m;while(m){if((m-1)%w0)m(m-1)/w;else if((m1)%w0)m(m1)/w;else if(m%w0)m/w;else break;}if(!m)cout<<"YES&…
阅读更多...
「职场必备」让你摆脱思维混乱的7个工具

「职场必备」让你摆脱思维混乱的7个工具

1. 升维思考&#xff0c;降维拆解 解决复杂问题时&#xff0c;有两个关键的阶段&#xff0c;能让我们事半功倍。 第一个阶段是思考阶段&#xff0c;要自下而上进行“升维思考”&#xff0c;明确问题的本质是什么。第二阶段是行动阶段&#xff0c;要自上而下进行“降维拆解”&am…
阅读更多...
Excel查找匹配函数(VLOOKUP)：功能与应用解析

Excel查找匹配函数(VLOOKUP)：功能与应用解析

文章目录 概述VLOOKUP函数语法查询并返回单列结果查找并返回多列结果MATCH函数VLOOKUPMATCH 从右向左逆向查找&#xff1a;INDEX函数INDEXMATCH 函数匹配方式查找匹配注意事项函数名称错误: #NAME?值错误&#xff1a;#VALUE!引用错误&#xff1a;#REF!找不到数据&#xff1a;#…
阅读更多...
1、NLP分词

1、NLP分词

分词处理 1、token&#xff08;词汇单元&#xff09;2、Tokenizer&#xff08;分词&#xff09;3、ElasticSearch 分词器&#xff08;Analyzer&#xff09;4、分词工具停用词&#xff08;Stop words&#xff09; 1、token&#xff08;词汇单元&#xff09; “token”主要用于文…
阅读更多...
AI早班车5.25

AI早班车5.25

&#x1f4e2;&#x1f4e2;&#x1f4e2;&#x1f4e3;&#x1f4e3;&#x1f4e3; 哈喽&#xff01;大家好&#xff0c;我是「奇点」&#xff0c;江湖人称 singularity。刚工作几年&#xff0c;想和大家一同进步&#x1f91d;&#x1f91d; 一位上进心十足的【Java ToB端大厂…
阅读更多...
51-53 DriveWorld：通过自动驾驶世界模型进行 4D 预训练场景理解 （含模型数据流梳理）

51-53 DriveWorld：通过自动驾驶世界模型进行 4D 预训练场景理解 （含模型数据流梳理）

24年5月&#xff0c;北京大学、国防创新研究院无人系统技术研究中心、中国电信人工智能研究院联合发布了DriveWorld: 4D Pre-trained Scene Understanding via World Models for Autonomous Driving。 DriveWorld在UniAD的基础上又有所成长&#xff0c;提升了自动驾驶目标检测…
阅读更多...
linux之防火墙工具

linux之防火墙工具

netfilter Linux防火墙是由Netfilter组件提供的&#xff0c;Netfilter工作在内核空间&#xff0c;集成在linux内核中。 Netfilter在内核中选取五个位置放了五个hook(勾子) function(INPUT、OUTPUT、FORWARD、PREROUTING、POSTROUTING)&#xff0c;而这五个hook function向用户…
阅读更多...
人工智能应用-实验8-用生成对抗网络生成数字图像

人工智能应用-实验8-用生成对抗网络生成数字图像

文章目录 &#x1f9e1;&#x1f9e1;实验内容&#x1f9e1;&#x1f9e1;&#x1f9e1;&#x1f9e1;代码&#x1f9e1;&#x1f9e1;&#x1f9e1;&#x1f9e1;分析结果&#x1f9e1;&#x1f9e1;&#x1f9e1;&#x1f9e1;实验总结&#x1f9e1;&#x1f9e1; &#x1f9…
阅读更多...
Stable Diffusion【艺术特效】【霓虹灯】：霓虹灯像素化马赛克特效

Stable Diffusion【艺术特效】【霓虹灯】：霓虹灯像素化马赛克特效

提示词 Neon pixelated mosaic of [Subject Description],highly detailed [主题]的霓虹灯像素化马赛克&#xff0c;高度详细 参数设置 大模型&#xff1a;万享XL_超写实摄影V8.2 采样器&#xff1a;Euler a 采样迭代步数&#xff1a;25 CFG&#xff1a;3 反向提示词&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023