【数据结构】线性表——栈与队列

写在前面

栈和队列的关系与链表和顺序表的关系差不多，不存在谁替代谁，只有双剑合璧才能破敌万千~~😎😎

文章目录

  • 写在前面
  • 一、栈
    • 1.1栈的概念及结构
    • 1.2、栈的实现
      • 1.2.1、栈的结构体定义
      • 1.2.2、栈的初始化栈
      • 1.2.3、入栈
      • 1.2.4、出栈
      • 1.2.5、 获取栈顶元素
      • 1.2.6、 获取栈中有效元素个数
      • 1.2.7、检测栈是否为空，如果为空返回非零结果，如果不为空返回0
      • 1.2.8、销毁栈
  • 二、队列
    • 2.1队列的概念及结构
    • 2.2、队列的实现
      • 2.2.1、队列的结构体定义
      • 2.2.2、初始化队列
      • 2.2.3、队尾入队列
      • 2.2.4、队头出队列
      • 2.2.5、检测队列是否为空，如果为空返回非零结果，如果非空返回0
      • 2.2.6、获取队列头部元素
      • 2.2.7、获取队列队尾元素
      • 2.2.8、获取队列中有效元素个数
      • 2.2.9、销毁队列
  • 三、栈与队列的相互实现
    • 3.1、栈模拟实现队列
    • 3.2、队列模拟实现栈
  • 四、循环队列
    • 4.1、循环队列的结构体定义
    • 4.2、循环队列的初始化
    • 4.3、循环队列的判断是否为空
    • 4.4、循环队列的判断是否满了
    • 4.5、循环队列的入队列
    • 4.6、循环队列的出队列
    • 4.7、循环队列获取头队列元素
    • 4.7、循环队列获取尾队列元素
    • 4.7、循环队列的销毁

一、栈

1.1栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶

在这里插入图片描述ps：图片来源51CTO

1.2、栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

  • 栈的实现逻辑与顺序表的大差不差，只是需要规定规定入队列与出队列需要遵守遵守后进先出即可

1.2.1、栈的结构体定义

typedef int stackData;
typedef struct stack
{stackData* val;int size;int cakacity;
}stack;
  • typedef int stackData;把顺序表结构的类型重命名为：stackData。若将来如果要改变数据栈内容的结构类型。可以极为方便的改变。
  • 在结构体中定义了。栈的总体大小和当前容量。以便确认是否需要扩容。
  • 定义的stackData*用于接收动态开辟的内存。
  • size是栈空间的大小。
  • capacity是栈空间当前的元素数量。

1.2.2、栈的初始化栈

void SKinit(stack* head) {head->val = (stackData*)malloc(sizeof(stackData) * 4);assert(head->val);head->size = 4;//栈存储空间的大小head->top = 0;//top是栈顶元素的下一个位置
}
  • 因为栈的结构体是用户自己开辟没有进行栈存储空间内存划分的。所以需要把栈的表存储空间进行初始化。
  • 默认开辟两个空间。
  • 在成功开辟后。把size设置为2。top 设置为0（此时栈空间内没有存储有效数据）。

1.2.3、入栈

void SKpush(stack* pHead, stackData x) {assert(pHead);stack* head = pHead;if (head->top == head->size) {//判断是否需要扩容stackData* p1 = (stackData*)realloc(head->val,sizeof(stackData) * head->size * 2);assert(p1);head->val = p1;head->size *= 2;}head->val[head->top] = x;head->top++;}
  • 与顺序表尾插增添并无二样。

1.2.4、出栈

stackData SKPop(stack* pHead) {assert(pHead);stack* head = pHead;stackData date = head->val[head->top - 1];head->top--;return date;
}
  • 只要把当前数据。进行减减。无需把栈中的内容进行删除。因为再次入栈数据，就会把之前的数据覆盖。

1.2.5、 获取栈顶元素

stackData StackTop(stack* ps) {assert(ps);return ps->val[ps->top - 1];
}
  • 访问数组而已。
  • 因为top是栈顶元素的下一个元素，所以top-1就是栈顶当前元素的下标。

1.2.6、 获取栈中有效元素个数

int SKsize(stack* pHead) {return pHead->top;
}
  • 只需要返回top就知道栈空间有多少元素了

1.2.7、检测栈是否为空，如果为空返回非零结果，如果不为空返回0

int SKEmpty(stack* pHead) {return pHead->top == 0;
}
  • top也代表栈空间有多少元素，只需要把top与0比较即可。

1.2.8、销毁栈

void SKdestory(stack* pHead) {while (pHead->top) {SKPop(pHead);}
}
  • 遍历出栈即可完成销毁。

二、队列

2.1队列的概念及结构

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

  • 入队列：进行插入操作的一端称为队尾
  • 出队列：进行删除操作的一端称为队头

在这里插入图片描述

2.2、队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

在这里插入图片描述
即：在单链表中只能使用尾插和头删进行数据的更改

2.2.1、队列的结构体定义

typedef int queData;
typedef struct QueNode {queData data;struct qnode* next;
}qnode;
typedef struct Queue {qnode* head;qnode* tail;
}que;
  • typedef int queData;把链表结构的类型重命名为：queData。若将来如果要改变链表内容的结构类型，就可以极为方便的改变。
  • 在结构体QueNode中定义了链表的存储的内容与存储下个节点的指针。
  • 为了更方便使用链表结构体，把链表结构体重命名为qnode。
  • 在定义完成链表的结构体后，我们需要定义队列的结构体，用来确保每次访问队列只能访问到链表的头节点或尾节点
  • 队列结构体struct Queue是用来管理链表的，所以成员变量类型都是qnode*，head代表头节点，tail代表尾节点。

2.2.2、初始化队列

void QueInit(que** queue) {que* p1 = (que*)malloc(sizeof(que));assert(p1);p1->head = NULL;p1->tail = NULL;*queue = p1;
}
  • 动态开辟一个空队列。先把队列设置为空，把前后指针设置为NULL。

2.2.3、队尾入队列

void QuePush(que* queue, queData x) {assert(queue);qnode* p1 = (qnode*)malloc(sizeof(qnode));assert(p1);p1->next = NULL;p1->data = x;if (queue->head == NULL) {queue->head = p1;queue->tail = p1;}else {queue->tail->next = p1;queue->tail = p1;}}
  • 首先动态开辟一个链表节点。
  • 把入队节点的next赋为空值，并且把需要插入的x值传递给新开辟的链表节点p1->data。完成入队数据的处理。
  • 在入队列之前，我们需要判断队列是否为NULL，如为NULL说明队列的链表里面目前没有一个节点，那就需要把p1赋值head为作为队列的队头。
  • 判断了队列不为NULL，则直接把队尾的next指向p1，之后更新队尾完成入队。

2.2.4、队头出队列

qnode* QuePop(que* queue) {assert(queue);if (queue->head == NULL) {return NULL;}qnode* p1 = queue->head;queue->head = queue->head->next;if (queue->head == NULL) {queue->tail = NULL;}return p1;
}
  • 在出队列之前，我们需要判断队列是否为NULL，如为NULL说明队列的链表里面目前没有一个节点，那就需返回NULL即可。
  • 判断了队列不为NULL，用一个指针p1记录原对头，之后把队头的head指针指向next节点， 更新新队头后返回指针p1 完成出队。
  • 如果把队列的节点全部出完后，就需要把head与tail赋为NULL。

2.2.5、检测队列是否为空，如果为空返回非零结果，如果非空返回0

bool QueEmpty(que* queue) {assert(queue);if (queue->head == NULL && queue->tail == NULL) {return true;}return false;
}
  • 如果队头和队尾指针同时为NULL则说明队列为空。否则肯定不为空。

2.2.6、获取队列头部元素

queData QueueFront(que* queue){assert(queue);assert(!QueEmpty(queue));return queue->head->data;
}
  • 直接返回队头的data。

2.2.7、获取队列队尾元素

queData QueueBack(que* queue) {assert(queue);assert(!QueEmpty(queue));//如果队列为空还哪有说明头部元素return queue->tail->data;
}
  • 直接返回队尾的data。

2.2.8、获取队列中有效元素个数

int QueSize(que* queue) {assert(queue);qnode* p1 = queue->head;int sz = 0;while (p1 != NULL) {sz++;p1 = p1->next;}return sz;
}
  • 遍历++即可

2.2.9、销毁队列

void QueDestory(que* queue) {assert(queue);while (!QueEmpty(queue)) {free(QuePop(queue));}
}
  • 循环出队列即可。

三、栈与队列的相互实现

3.1、栈模拟实现队列

  • 队列的特性是先入先出。即：FIFO（First In First Out）的原则。
  • 栈的特性是后入先出。即：LIFO（Last In First Out）的原则。
  • 我们可以利用两栈后入先出的特性，先用栈1把入队列的值存起来，在存起来后，就把栈1的值出栈到栈2中进行保存，这样就完成栈中底部的值变为顶部的值了。（如下图）在这里插入图片描述
  • 在上图中可以看到，当栈2出栈的时候，就变成了栈1底部的数据先出，即：先入先出。
  • 所以我们只需要创建两个栈，一个栈负责入数据：栈1，一个栈负责出数据：栈2，为了不影响先后顺序，我们必须等到栈2为空的时候才把栈1的数据导入进去。

示例代码

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int stackData;
typedef struct stack
{stackData* val;int size;int top;
}stack;//栈的结构体typedef struct {stack* stack1;//接收数据stack* stack2;//出数据
} MyQueue;//栈模拟的队列//栈函数的实现
void SKinit(stack** head) {*head = (stack*)malloc(sizeof(stack));assert(*head);(*head)->val = (stackData*)malloc(sizeof(stackData) * 4);assert((*head)->val);(*head)->size = 4;(*head)->top = 0;
}
//入栈
void SKpush(stack* pHead, stackData x) {assert(pHead);stack* head = pHead;if (head->top == head->size) {stackData* p1 = (stackData*)realloc(head->val,sizeof(stackData) * head->size * 2);assert(p1);head->val = p1;head->size *= 2;}head->val[head->top] = x;head->top++;}
//出栈
stackData SKPop(stack* pHead) {assert(pHead);stack* head = pHead;stackData date = head->val[head->top - 1];head->top--;return date;
}
//销毁
void SKdestory(stack* pHead) {while (pHead->top) {SKPop(pHead);}
}
//大小
int SKsize(stack* pHead) {return pHead->top;
}
//判断为空
int SKEmpty(stack* pHead) {return pHead->top == 0;
}
stackData StackTop(stack* ps) {assert(ps);return ps->val[ps->top - 1];
}//队列函数的实现// 创建一个队列
MyQueue* myQueueCreate() {MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));  // 为队列分配内存SKinit(&obj->stack1);  // 初始化栈1，用于接收数据SKinit(&obj->stack2);  // 初始化栈2，用于出数据return obj;  // 返回队列对象
}// 入队操作，将元素x压入栈1
void myQueuePush(MyQueue* obj, int x) {SKpush(obj->stack1, x);  // 直接将元素压入栈1
}// 出队操作，从栈2中弹出元素
int myQueuePop(MyQueue* obj) {// 如果栈2为空，将栈1中的元素移动到栈2if (obj->stack2->top == 0) {// 从栈1依次弹出元素并压入栈2while (!SKEmpty(obj->stack1)) {stackData n = SKPop(obj->stack1);SKpush(obj->stack2, n);}}// 从栈2中弹出元素return SKPop(obj->stack2);
}// 查看队列头部元素
int myQueuePeek(MyQueue* obj) {// 如果栈2为空，将栈1中的元素移动到栈2if (obj->stack2->top == 0) {while (!SKEmpty(obj->stack1)) {stackData n = SKPop(obj->stack1);SKpush(obj->stack2, n);}}// 返回栈2的栈顶元素return StackTop(obj->stack2);
}// 判断队列是否为空
bool myQueueEmpty(MyQueue* obj) {return (obj->stack2->top == 0) && (obj->stack1->top == 0);  // 栈1和栈2都为空时，队列为空
}// 销毁队列，释放所有资源
void myQueueFree(MyQueue* obj) {// 一直出队直到队列为空while (!myQueueEmpty(obj)) {myQueuePop(obj);}// 释放栈1和栈2的内存free(obj->stack1->val);free(obj->stack2->val);free(obj->stack1);free(obj->stack2);// 释放队列对象free(obj);
}

3.2、队列模拟实现栈

  • 队列的特性是先入先出。即：FIFO（First In First Out）的原则。
  • 栈的特性是后入先出。即：LIFO（Last In First Out）的原则。
  • 我们可以利用两个队列进行互相入队，把队列中的最后一个元素进行返回，这样就完成栈的先入先出的原则了。（如下图）在这里插入图片描述
  • 至此，再下一次出栈时候只需要判断哪个队列不为空，就循环出队列到另一个队列中，这样就可以模拟实现栈了。

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>// 定义栈中存储的数据类型
typedef int stackData;// 栈的结构体定义
typedef struct stack {stackData* val;  // 动态数组，用来存储栈的元素int size;        // 栈的容量int top;         // 栈顶元素的索引
} stack;// 初始化栈函数
void SKinit(stack** head) {*head = (stack*)malloc(sizeof(stack));assert(*head);  // 确保内存分配成功(*head)->val = (stackData*)malloc(sizeof(stackData) * 4);assert((*head)->val);  // 确保内存分配成功(*head)->size = 4;(*head)->top = 0;
}// 入栈操作
void SKpush(stack* pHead, stackData x) {assert(pHead);  // 确保栈指针有效stack* head = pHead;// 如果栈满，进行扩容if (head->top == head->size) {// 重新分配内存，栈容量加倍stackData* p1 = (stackData*)realloc(head->val, sizeof(stackData) * head->size * 2);assert(p1); head->val = p1; head->size *= 2;  }head->val[head->top] = x;head->top++;  
}// 出栈操作
stackData SKPop(stack* pHead) {assert(pHead);  // 确保栈指针有效stack* head = pHead;stackData date = head->val[head->top - 1];head->top--;return date;
}// 销毁栈，释放栈中所有数据
void SKdestory(stack* pHead) {while (pHead->top) {SKPop(pHead);  // 依次出栈，直到栈为空}
}// 获取栈的大小（栈中的元素个数）
int SKsize(stack* pHead) {return pHead->top;  // 栈顶指针即为栈的大小
}// 判断栈是否为空
int SKEmpty(stack* pHead) {return pHead->top == 0;  // 如果栈顶指针为0，则栈为空
}// 获取栈顶元素
stackData StackTop(stack* ps) {assert(ps);  // 确保栈指针有效return ps->val[ps->top - 1];  // 返回栈顶元素
}// 队列结构体定义
typedef struct {stack* stack1;  // 用于接收数据（入队）stack* stack2;  // 用于出数据（出队）
} MyQueue;// 创建队列
MyQueue* myQueueCreate() {// 为队列分配内存MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));// 初始化两个栈SKinit(&obj->stack1);  // 用于接收数据SKinit(&obj->stack2);  // 用于出数据return obj;  // 返回队列对象
}// 入队操作，将元素x压入栈1
void myQueuePush(MyQueue* obj, int x) {SKpush(obj->stack1, x);  // 将数据压入栈1
}// 出队操作，从栈2弹出元素
int myQueuePop(MyQueue* obj) {// 如果栈2为空，将栈1中的元素转移到栈2if (obj->stack2->top == 0) {// 将栈1中的元素依次弹出并压入栈2while (!SKEmpty(obj->stack1)) {stackData n = SKPop(obj->stack1);SKpush(obj->stack2, n);}}// 从栈2中弹出元素并返回return SKPop(obj->stack2);
}// 查看队列头部元素
int myQueuePeek(MyQueue* obj) {// 如果栈2为空，将栈1中的元素转移到栈2if (obj->stack2->top == 0) {while (!SKEmpty(obj->stack1)) {stackData n = SKPop(obj->stack1);SKpush(obj->stack2, n);}}// 返回栈2的栈顶元素return StackTop(obj->stack2);
}// 判断队列是否为空
bool myQueueEmpty(MyQueue* obj) {return (obj->stack2->top == 0) && (obj->stack1->top == 0);  // 栈1和栈2都为空时，队列为空
}// 销毁队列，释放所有资源
void myQueueFree(MyQueue* obj) {// 一直出队直到队列为空while (!myQueueEmpty(obj)) {myQueuePop(obj);}// 释放栈1和栈2的内存free(obj->stack1->val);free(obj->stack2->val);free(obj->stack1);free(obj->stack2);// 释放队列对象free(obj);
}

四、循环队列

在操作系统的生产者消费者模型中可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。

因为是环形队列，所以不存在扩容队列的情况，本篇笔记以数组实现为例。
以数组为数据存储模型比链表实现方便的多。

4.1、循环队列的结构体定义

typedef struct {int* a;int front;int rear;int k;//开辟的数组大小
} MyCircularQueue;

  • 首先创建一个数组，用来存储队列的数据。

  • 定义两个指针，用来指向队列数据中的队头和队尾。

  • front：只需要保存队头元素在数组中的下标即可。

  • rear：保存队尾元素的下一个下标，这样可以保证队列位空时rear和front的下标相同，队列满时front是rear的下一位。如下图在这里插入图片描述

  • 为了达到上图的效果，需要在初始化时候把数组开大1个空间。多开的空间作为数组的预留位置。

  • 定义一个整形变量k用来保存队列大小。

4.2、循环队列的初始化

MyCircularQueue* myCircularQueueCreate(int k) {//传入开辟队列的大小MyCircularQueue* que = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));assert(que);que->a = (int*)malloc(sizeof(int) * (k + 1));que->k = k;que->front = 0;que->rear = 0;return que;
}
  • 动态开辟一个队列结构体
  • 动态开辟一个队列空间，其中队列空间需要比k大一个1
  • 并且把结构体中的其他值进行初始化赋值

4.3、循环队列的判断是否为空

bool IsEmpty(MyCircularQueue* obj) {return (obj->front == obj->rear);
}
  • 根据我们设计逻辑，只有obj->front == obj->rear时候队列位空

4.4、循环队列的判断是否满了

bool IsFull(MyCircularQueue* obj) {return (obj->rear + 1) % (obj->k + 1) == obj->front;
}

  • 根据我们设计逻辑，如果rear + 1是front的情况就说明队列满了。

  • 解析(obj->rear + 1) % (obj->k + 1) == obj->front（假设当前容量是：3。k == 3）:

    • 第一种：只入队列且未满的情况
      • 只入队列的情况下说明front值是未进行改变的，且rear值是最后元素下标的下一位（如下图）。在这里插入图片描述这时候判断，队列是否未满，只需要(rear +1) % (k + 1)== front。小数模大数的结果还是本身。
    • 第二种：只入队列且已经满的情况
      • 只入队列的情况下说明front值是未进行改变的，且rear值是最后元素下标的下一位（如下图）。在这里插入图片描述在队列满的情况下，当前的rear的值是:3。rear + 1就超出了数组的大小(如下图)在这里插入图片描述但是在循环队列中rear + 1是代表着数组原始起点的（如下逻辑图）在这里插入图片描述为了达到rear+1就能回到数组起始位置，进行rear+1 % k + 1。rear+1的值：4。k+1的值也为：4。相同的值同时模的到的值是0。此时我们只需要判断下标0处是否也是front的值就可以判断出队列是否为满了(obj->rear + 1) % (obj->k + 1) == obj->front。（如上图）
    • 第三种：入满队列后了一些且未满的情况
      • 此时队列的front元素进行了改变，不再是0下标的值，此时我们可以和第二种结合理解。先画出此时的数组的物理结构图和逻辑结构图。(如下图)在这里插入图片描述为了使rear + 1回到逻辑结构中的下一个位置，我们使用第二种中介绍的方法，使用(obj->rear + 1) % (obj->k + 1)方法，在把rear + 1回到数组起始位置，之后判断此时的front是否也是此下标。

4.5、循环队列的入队列

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {if (myCircularQueueIsFull(obj)) {return false;}else {obj->a[obj->rear] = value;obj->rear++;obj->rear = (obj->rear) % (obj->k + 1);return true;}
}
  • 入队列返回结果：如果成功插入则返回真。
  • 入队列前，需要检查队列是否为满。
  • 如果队列不为满，只需要在rear位置中，存放插入的数据即可。
  • 在每次插入完成后，rear数据都需要进行逻辑后移一位。在逻辑后移中，需要分成2中情况：
    • 第一种：rear不在数组最后一位(如下图)在这里插入图片描述此时小数模大数，结果还是本身。不受到(obj->rear) % (obj->k + 1)的影响。
    • 第二种：rear在数组最后一位(如下图)在这里插入图片描述rear+1的值：4。k+1的值也为：4。相同的值同时模的到的值是0。(obj->rear) % (obj->k + 1)即：把rear的值重新返回到数组头部。(如下图)
      在这里插入图片描述
  • 只有每次都对rear取模才能完成循环队列的逻辑。

4.6、循环队列的出队列

bool myCircularQueueDeQueue(MyCircularQueue* obj) {if (IsEmpty(obj)) {return false;}else {obj->front++;obj->front = (obj->front) % (obj->k + 1);return true;}
}
  • 出队列返回结果：如果成功出队则返回真。
  • 出队列前，需要检查队列是否为空。
  • 出队列需要把front下标++，把队列的队头在数组中往后移动一个位置，这样就完成了出队。
  • front在每次插入完成后，front数据都需要进行逻辑后移一位。在逻辑后移中，也分成2中情况，但是这两种情况与入队列的read相同，这里不做详细说明。

4.7、循环队列获取头队列元素

int myCircularQueueFront(MyCircularQueue* obj) {if (IsEmpty(obj)) {return -1;}return obj->a[obj->front];
}
  • 先判断是否为空，不为空直接返回队头元素即可。

4.7、循环队列获取尾队列元素

int myCircularQueueRear(MyCircularQueue* obj) {if (IsEmpty(obj)) {return -1;}//return obj->a[obj->rear - 1];return obj->a[((obj->rear - 1) + (obj->k + 1)) % (obj->k+1)];
}

  • 正常来说是：先判断是否为空，不为空直接返回rear - 1的位置元素即可。

  • 但是有一种特殊情况即：当rear是数组首元素下标时，rear - 1就造成了越界访问。在这里插入图片描述

  • 为了避免越界访问的情况，必须确保在数组首元素时，返回的是数组尾元素的值（可以使用分支语句处理）。这里使用取模处理：(k = 3)

    • 我们知道元素本身模本身的结果为:0，并且小数模大数结果为:小数本身
    • 所以当rear-1时，如果在非首元素位置中，通过分配率((obj->rear - 1) + (obj->k + 1)) % (obj->k+1)可以变成(obj->rear - 1) % (obj->k+1)，结果是obj->rear - 1本身
    • 如果在非首元素位置中时，(obj->rear - 1) + (obj->k + 1)的值：-1 + 4 == 3。这时候我们用得到的结果对k+1进行取模就变成了小数模大数结果为:小数本身。这时候rear的结果是数组尾元素的下标，返回的结果就是队列的尾节点元素。在这里插入图片描述

4.7、循环队列的销毁

void myCircularQueueFree(MyCircularQueue* obj) {free(obj->a);free(obj);
}
  • 干脆利落的销毁了用于存储队列元素的数组与队列结构体的两个动态开辟空间~

以上就是本章所有内容。若有勘误请私信不才。万分感激💖💖 如果对大家有帮助的话，就请多多为我点赞收藏吧~~~💖💖
请添加图片描述

ps:表情包来自网络，侵删🌹

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

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

相关文章

Rust编程与项目实战-特质（Trait）

Rust编程与项目实战-特质（Trait）

【图书介绍】《Rust编程与项目实战》-CSDN博客 《Rust编程与项目实战》(朱文伟&#xff0c;李建英)【摘要 书评 试读】- 京东图书 (jd.com) Rust编程与项目实战_夏天又到了的博客-CSDN博客 特质&#xff08;Trait&#xff09;是Rust中的概念&#xff0c;类似于其他语言中的接…
阅读更多...
运维之systemd 服务（Systemd Service of Operations and Maintenance）

运维之systemd 服务（Systemd Service of Operations and Maintenance）

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 本人主要分享计算机核心技…
阅读更多...
Vue — 组件化开发

Vue — 组件化开发

组件化开发&#xff1a;一个页面可以拆分成一个个组件&#xff1b;每个组件都有自己独立的结构、样式、行为 组件分类&#xff1a;普通组件、根组件 其中根组件包裹着所有普通小组件 普通组件的注册使用&#xff1b;有两种注册方式 局部注册全局注册 局部注册 目标&#xff…
阅读更多...
【软考】系统架构设计师-计算机系统基础（2）：操作系统

【软考】系统架构设计师-计算机系统基础（2）：操作系统

1、操作系统基础 OS的5个核心功能&#xff1a;进程管理、存储管理、设备管理、文件管理、作业管理 OS的3个作用&#xff1a;管理运行的程序和分配各种软硬件资源&#xff1b;提供友善的人机界面&#xff1b;为程序应用的开发和运行提供高效的平台 OS的4个特征&#xff1a;并…
阅读更多...
Android ANR分析总结

Android ANR分析总结

1、ANR介绍 ANR&#xff08;Application Not Responding&#xff09;指的是应用程序无响应&#xff0c;当Android应用程序在主线程上执行长时间运行的操作或阻塞I/O操作时发生。这可能导致应用程序界面冻结或无法响应用户输入。 1、Service ANR&#xff1a;前台20s&#xff0…
阅读更多...
WebRTC视频 01 - 视频采集整体架构

WebRTC视频 01 - 视频采集整体架构

一、前言&#xff1a; 我们从1对1通信说起&#xff0c;假如有一天&#xff0c;你和你情敌使用X信进行1v1通信&#xff0c;想象一下画面是不是一个大画面中有一个小画面&#xff1f;这在布局中就叫做PIP&#xff08;picture in picture&#xff09;&#xff1b;这个随手一点&am…
阅读更多...
Jenkins应用详解（Detailed Explanation of Jenkins Application）

Jenkins应用详解（Detailed Explanation of Jenkins Application）

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:Linux运维老纪的首页…
阅读更多...
【Python】计算机视觉应用：OpenCV库图像处理入门

【Python】计算机视觉应用：OpenCV库图像处理入门

计算机视觉应用&#xff1a;OpenCV库图像处理入门 在当今的数字化时代&#xff0c;计算机视觉&#xff08;Computer Vision&#xff09;已经渗透到各行各业&#xff0c;比如自动驾驶、智能监控、医疗影像分析等。而 Python 的 OpenCV 库&#xff08;Open Source Computer Visi…
阅读更多...
ctfshow-web入门-反序列化（web260-web264）

ctfshow-web入门-反序列化（web260-web264）

目录 1、web260 2、web261 3、web262 4、web263 5、web264 1、web260 要求传入的内容序列化后包含指定内容即可&#xff0c;在 PHP 序列化中&#xff0c;如果键名或值包含 ctfshow_i_love_36D&#xff0c;那么整个序列化结果也会包含这个字符串。 payload&#xff1a; ?…
阅读更多...
Python 爬虫运行状态监控：进度、错误与完成情况

Python 爬虫运行状态监控：进度、错误与完成情况

Python 爬虫运行状态监控&#xff1a;进度、错误与完成情况 在进行大规模数据爬取时&#xff0c;监控爬虫的运行状态至关重要。通过实时监控&#xff0c;可以了解爬虫的工作进度、出现的错误以及任务完成情况。这样可以及时发现并解决问题&#xff0c;确保数据抓取任务顺利进行…
阅读更多...
Flutter错误： uses-sdk:minSdkVersion 16 cannot be smaller than version 21 declared

Flutter错误： uses-sdk:minSdkVersion 16 cannot be smaller than version 21 declared

前言 今天要做蓝牙通信的功能&#xff0c;我使用了flutter_reactive_ble这个库&#xff0c;但是在运行的时候发现一下错误 Launching lib/main.dart on AQM AL10 in debug mode... /Users/macbook/Desktop/test/flutter/my_app/android/app/src/debug/AndroidManifest.xml Err…
阅读更多...
除了易我数据恢复，这10个数据恢复软件也能点亮数据找回的希望之光。

除了易我数据恢复，这10个数据恢复软件也能点亮数据找回的希望之光。

易我数据恢复工具具有广泛的系统兼容性&#xff0c;并且里面功能丰富&#xff0c;操作简单&#xff0c;能够完成多种数据恢复操作&#xff0c;是一款比较专业的数据恢复软件。如果大家在为数据丢失而烦恼的话&#xff0c;我可以推荐几款好用的数据恢复软件给大家。 1、福昕数据…
阅读更多...
Vue Cli 脚手架目录文件介绍

Vue Cli 脚手架目录文件介绍

小试牛刀 //vetur高亮; vuetab 快速生成 <template><div class"box">我是个盒子<button click"fn">按钮</button></div> </template><script> export default {methods:{fn(){alert("Hello Vue")}} …
阅读更多...
在公司中，如何表现出自己的高情商，学会这三句话就可以了

在公司中，如何表现出自己的高情商，学会这三句话就可以了

在职场中&#xff0c;高情商的重要性不言而喻。它能帮助你更好地处理人际关系&#xff0c;提升团队协作效率&#xff0c;还能让你在职场上获得更多的机会。 在职场中&#xff0c;适时地给予同事、上级和下属赞美、感谢和鼓励&#xff0c;能够拉近彼此的距离&#xff0c;增强团…
阅读更多...
cache（五）Write-through，Write-back，Write-allocate，No-write-allocate

cache（五）Write-through，Write-back，Write-allocate，No-write-allocate

这张图总结了缓存系统中写操作策略的不同方法&#xff0c;主要讨论了在**写命中&#xff08;write-hit&#xff09;和写未命中&#xff08;write-miss&#xff09;**情况下应该采取的操作策略。 1. 多个数据副本的存在 缓存系统通常有多个级别&#xff0c;例如 L1 缓存、L2 缓…
阅读更多...
商品规格递归拼接

商品规格递归拼接

创建实体类 Data public class Shopping {private String name;private List<String> children; } 测试 public static void main(String[] args) {ArrayList<Shopping> shoppings new ArrayList<>();Shopping shopping new Shopping();shopping.setName…
阅读更多...
大模型基础： 从零开始训练一个最小化的Transformer聊天机器人

大模型基础： 从零开始训练一个最小化的Transformer聊天机器人

这里将介绍如何从零开始&#xff0c;使用Transformer模型训练一个最小化的聊天机器人。该流程将尽量简化&#xff0c;不依赖预训练模型&#xff0c;并手动实现关键步骤&#xff0c;确保每一步都容易理解。 1. 环境准备 首先&#xff0c;确保安装了必要的Python库。我们只需要基…
阅读更多...
推荐一款3D建模软件：Agisoft Metashape Pro

推荐一款3D建模软件：Agisoft Metashape Pro

Agisoft Metashape Pro是一款强大的多视点三维建模设计辅助软件&#xff0c;Agisoft Metashape是一款独立的软件产品&#xff0c;可对数字图像进行摄影测量处理&#xff0c;并生成3D空间数据&#xff0c;用于GIS应用&#xff0c;文化遗产文档和视觉效果制作&#xff0c;以及间接…
阅读更多...
Docker--Docker是什么和对Docker的了解

Docker--Docker是什么和对Docker的了解

Docker 的本质 Docker的本质是LXC&#xff08;Linux容器&#xff09;之类的增强版&#xff0c;它本身不是容器&#xff0c;而是容器的易用工具。 Docker通过虚拟化技术&#xff0c;将代码、依赖项和运行环境打包成一个容器&#xff0c;并利用隔离机制来使得容器之间互相独立、…
阅读更多...
前端请求后端php接口跨域 cors问题

前端请求后端php接口跨域 cors问题

只需要后端在网站的入口文件 一般都是 index.php 加上 这几行代码就可以了 具体的参数可以根据需要去修改 header("Access-Control-Allow-Origin: *"); header(Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS); header(Access-Control-Allow-Heade…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023