栈实现队列与队列实现堆

        ok呀，上一篇博客写了队列的相关知识，接下来就是我们提及过的，栈与队列的相互实现了。堆与这个问题咧，其实大家完全可以当一个知识扩展因为，这个问题也是没有太多的实践意义的，更多的是教学意义。所以咧。大家了解了解就行了。

栈实现队列

      实现思路

       我们想一想栈与队列有一个最根本的区别就是一个先进先出，一个先进后出。那么如果只用一个栈来实现队列应该是不大可能的。所以我们普遍是使用两个栈来实现队列，用两个队列来实栈。但是这个实现的思路是什么呢？
       我们知道栈是后进先出的。那么我们要实现先进先出的话，那我们创建了两个栈，最好是一个为进栈，一个为出栈。这就好比因为我们一个栈顺序是和队列倒过来的，如果我再将我们的栈直接先倒过来，那么岂不是就要与队列相同吗？

 

        这样大家看一下应该就很清楚了吧？因为这样我们在利用栈的后进先出的关系，这样我们就可以实现队列的输出关系的。

实现代码

        那么接下来我们就直接用c语言来实现一下这个操作了。当然我们知道我们要用栈实现队列的话，我们肯定要先写一个栈。再加之我们之前已经写过了，所以我们直接cv过来。

       写一个栈

#include<stdio.h>
#include<malloc.h>#define STACK_INIT_SIZE 100  //栈的初始容量 
#define STACKINCREMENT 10    //容量增量
#define OK 1 
#define OVERFLOW -2
typedef int SDataType;
typedef int Status;typedef struct{SDataType *base; //栈底指针SDataType *top;  //栈顶指针int StackSize;   //当前已经分配的存储空间，以元素为单位 
}SqStack;//初始化顺序栈，构造一个空栈
Status InitStack(SqStack &S){//分配存储空间 S.base = (SDataType *)malloc(STACK_INIT_SIZE*sizeof(SDataType));if(!S.base){//如果分配失败，则返回error return OVERFLOW;}//S.top 始终指向栈顶元素的下一个位置 S.top = S.base;    //初始状态下为空栈 S.StackSize = STACK_INIT_SIZE;   //当前已经分配的存储容量为100个 return OK;	
} //入栈
Status Push(SqStack &s,SDataType e){SDataType *p;//首先判断栈是不是满的（上溢） if(s.top-s.base == s.StackSize){//追加空间 p = (SDataType *)realloc(s.base,(s.StackSize + STACKINCREMENT)*sizeof(SDataType));if(!p){//如果没有找到符合条件的存储空间，则返回error return OVERFLOW;}//成功找到则使s.base指向p s.base = p;  //系统会将原来的内容复制过来s.top = s.base + s.StackSize;s.StackSize +=  STACKINCREMENT;}//先插入元素，然后使栈顶指针加 1 *(s.top) = e;s.top++;return OK;
} //出栈
Status Pop(SqStack &s,SDataType &e){//判断是否会发生下溢 if(s.top != s.base){s.top--;    //先将栈顶指针减 1 e = *(s.top);}else{return 0;}return e;
}//判断是否为空栈 
void judgeNull(SqStack &s){if(s.top == s.base){printf("此栈为空栈！\n");}else{printf("此栈不为空栈！\n");}
}//判断是否为满栈
void judgeFull(SqStack &s){if(s.top-s.base == s.StackSize){printf("栈满！\n");}else{printf("栈未满！\n");} 
} int main(){SqStack s;SDataType element;InitStack(s);  //初始化栈//将1-10入栈for(int i=1;i<=10;i++){Push(s,i);}judgeNull(s);judgeFull(s);printf("出栈：\n");//只要栈不为空 while(s.top != s.base){Pop(s,element);    //出栈的元素用e接收 printf("%d ",element);}printf("\n"); judgeNull(s);return 0;}

        两个栈 

       我们开始也说过了，我们要两个栈。那么下一步我们就要了还写两个栈。

//两个栈模拟实现队列
typedef struct
{ST pushst;ST popst;
} MyQueue;

      栈的初始化

      既然我们已经创建好两个栈了，那么接下来我们就要将栈初始化了。

//开辟空间并初始化
MyQueue* myQueueCreate()
{MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));STInit(&obj->pushst);STInit(&obj->popst);return obj;
}

     入栈 

        然后我们前面也说过，我们创建了两个站，其中一个为入站，一个为出站，那么呢我们接下来要将数据插入到入栈里面。而且前面我们已经写过了一个栈的入栈。那么我们直接引用就可以了。

//将元素X推到队列的末尾
void myQueuePush(MyQueue* obj, int x)
{STPush(&obj->pushst, x);
}

    返回队头

        那么我们首次需要用到先入先出的这个相关定义。其实就很简单，就分为两种情况。一种是我们的出栈里面有数据。一种是我们的出栈里面没有数据。如果有数据的话，我们直接将队列的头元素给返回出来就可以了。但是如果没有数据的话，我们就需要先倒一下数据，然后再返回。虽然大家可能会第一时间想到if和else当然这也是最常见的，我们也可以直接来一个if然后就可以了。我们直接判断我们的出栈是否有数据，如果没有，我们就直接倒然后在最末尾返回数据。如果有数据的话，他就不会进入到这个判断里面，然后我们就可以直接返回了。也就是说我们只需要判断里面是否有数据就可以了，然后再如果没有就进循环导数据，然后出数据。


//返回队列开头的元素
int myQueuePeek(MyQueue* obj)
{if (STEmpty(&obj->popst))//如果出栈为空的话就进去循环导数据{//捯数据while (!STEmpty(&obj->pushst)){STPush(&obj->popst, STTop(&obj->pushst));STPop(&obj->pushst);}}return STTop(&obj->popst);//都要传出数据的所以直接整合了
}

   头删 

        我们对于队列的头山的话，其实就只需要将我们出栈的头元素给删除掉，但是呢他又需要将头元素的值给返回。那么我们就需要创建一个临时变量来储存值，然后再头元素删除。

//从队列的开头移除并返回元素
int myQueuePop(MyQueue* obj)
{int front = myQueuePeek(obj);//创建一个临时变量存储值STPop(&obj->popst);//销毁头元素return front;//返回头元素的值
}

  判空 

       对于判空的话其实是比较简单的。因为我们在最开始写栈的时候，我们就已经写过判空了。我们就直接引用就可以了。当然如果我们一个一个判断的话是比较繁琐的，所以我们直接在返回的时候看到他们是否相同，这样就可以了。因为我在我们上面写在判空的时候就已经写过了。

//如果队列为空，返回true；否则，返回false
bool myQueueEmpty(MyQueue* obj)
{return STEmpty(&obj->popst) && STEmpty(&obj->pushst);//判断是否都为空
}

销毁

       最后一个销毁队列。其实就很简单啦，我们因为是用栈实现队列的，所以我们就需要把两个栈销毁就可以了。当然还要记得释放里面的空间。 

//销毁队列
void myQueueFree(MyQueue* obj)
{STDestroy(&obj->popst);//销毁出栈STDestroy(&obj->pushst);//销毁入栈free(obj);//释放空间
}

完整代码 

//C语言模拟实现栈typedef int STDataType;
typedef struct Stack
{STDataType* a;int top;int capacity;
}ST;//初始化栈
void STInit(ST* ps);
//销毁栈
void STDestroy(ST* ps);
//入栈
void STPush(ST* ps, STDataType x);
//出栈
void STPop(ST* ps);
//获取栈顶元素
STDataType STTop(ST* ps);
//获取栈中有效元素个数
int STSize(ST* ps);
//检测栈是否为空，如果为空返回非零结果，如果不为空返回0
bool STEmpty(ST* ps);void STInit(ST* ps)
{assert(ps);ps->a = NULL;ps->capacity = 0;ps->top = 0;
}void STDestroy(ST* ps)
{assert(ps);free(ps->a);ps->a = NULL;ps->capacity = 0;ps->top = 0;
}void STPush(ST* ps, STDataType x)
{assert(ps);if (ps->top == ps->capacity){int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);if (tmp == NULL){perror("realloc fail");exit(-1);}ps->a = tmp;ps->capacity = newCapacity;}ps->a[ps->top] = x;ps->top++;
}void STPop(ST* ps)
{assert(ps);assert(ps->top > 0);ps->top--;
}STDataType STTop(ST* ps)
{assert(ps);assert(ps->top > 0);return ps->a[ps->top - 1];
}int STSize(ST* ps)
{assert(ps);return ps->top;
}bool STEmpty(ST* ps)
{assert(ps);return ps->top == 0;
}//=======================================================================//两个栈模拟实现队列
typedef struct
{ST pushst;ST popst;
} MyQueue;//开辟空间并初始化
MyQueue* myQueueCreate()
{MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));STInit(&obj->pushst);STInit(&obj->popst);return obj;
}//将元素X推到队列的末尾
void myQueuePush(MyQueue* obj, int x)
{STPush(&obj->pushst, x);
}//返回队列开头的元素
int myQueuePeek(MyQueue* obj)
{if (STEmpty(&obj->popst)){//捯数据while (!STEmpty(&obj->pushst)){STPush(&obj->popst, STTop(&obj->pushst));STPop(&obj->pushst);}}return STTop(&obj->popst);
}//从队列的开头移除并返回元素
int myQueuePop(MyQueue* obj)
{int front = myQueuePeek(obj);STPop(&obj->popst);return front;
}//如果队列为空，返回true；否则，返回false
bool myQueueEmpty(MyQueue* obj)
{return STEmpty(&obj->popst) && STEmpty(&obj->pushst);
}//销毁队列
void myQueueFree(MyQueue* obj)
{STDestroy(&obj->popst);STDestroy(&obj->pushst);free(obj);
}

队列实现栈 

     实现思路

       我们也是先将一个队列里面塞入数据，然后再将它导出来。当然我们还是要确定一下。哪个为进？哪个为出？我们知道队列是先进先出的，但是我们的栈呢是需要先进后出。

      对于队列实现上就不能像栈实现队列那样确定一个为入栈一个为出栈。我们需要时刻改变，我们就这样判断谁为空谁就会入栈，谁为谁就为出栈这样。就是当我们入队列的时候，我们的队列谁有数据就往谁里面插入。

   实现代码

     写一个队列

     当然我们还是老样子，先写一个队列，因为我们以前写过了，接下来还是cv一下就可以了。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>typedef int QDateType;typedef struct QueueNode
{QDateType val;struct QueueNode* next;
}QueueNode;typedef	struct Queue
{QueueNode* head;QueueNode* tail;
}Queue;void QueueInti(Queue* pq)
{assert(pq);pq->head = pq->tail = NULL;
}void QueueDestory(Queue* pq)
{assert(pq);QueueNode* cur = pq->head;while (cur){QueueNode* next = cur->next;free(cur);cur = next;}pq->tail = pq->head = NULL;
}void QueuePush(Queue* pq, QDateType x)
{assert(pq);QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));if (NULL == newNode){printf("malloc error\n");exit(-1);}newNode->val = x;newNode->next = NULL;if (pq->tail == NULL){assert(pq->head == NULL);pq->head = pq->tail = newNode;}else{pq->tail->next = newNode;pq->tail = newNode;}}void QueuePop(Queue* pq)
{assert(pq);assert(pq->head && pq->tail);if (pq->head->next == NULL){free(pq->head);pq->head = pq->tail = NULL;}else{QueueNode* next = pq->head->next;free(pq->head);pq->head = next;}
}bool QueueEmpty(Queue* pq)
{assert(pq);return pq->head == NULL;
}QDateType QueueFront(Queue* pq)
{assert(pq);assert(pq->head);return pq->head->val;
}int QueueSize(Queue* pq)
{assert(pq);QueueNode* cur = pq->head;int count = 0;while (cur){cur = cur->next;count++;}return count;
}

    两个队列

     开始我们也说过了，实现队列实现站的话也需要两个队列，所以我们第一步创建两个队列。

//创建两个队列
typedef struct
{Queue q1;Queue q2;
} MyStack;

     队列初始化 

        好，当我们将队列创建好出来之后，我们就要将队列的初始化了。并且我们开始也是说过我们写过单个队列的程序。那么我们还是直接引用就可以了。

//两个队列的初始化
MyStack* myStackCreate()
{MyStack* st = (MyStack*)malloc(sizeof(MyStack));//创建一个临时结构体if (st == NULL)return false;QueueInit(&st->q1);//分别初始化QueueInit(&st->q2);return st;
}

      入队列 

       我们前面说过我们看中了两个队列里面谁有数据就往谁里面插入。因为我们在前面已经写过了单个队列的相关代码了。那么我们接下来只需要判断谁不为空，就往谁里面插入就可以了。

//队列的入队列
void myStackPush(MyStack* obj, int x)
{if (QueueSize(&obj->q1) != 0)//如果q1不为空的话，q1插入，反之q2插入{QueuePush(&obj->q1, x);}else{QueuePush(&obj->q2, x);}
}

      队列的头元素 

       当然还是少不了我们的头元素。在我们不知情的情况下，我们肯定不知道谁的队列里面有数据，所以我们这里我们也需要判断一下。判断好之后，但是我们也需要再思考一下。我们队列和栈的输入输出顺序是不一样的，那么是不是我们队列需要先再倒一下，然后再输出这样得到的答案才是我们想要的。

       并且我们还需要知道我们从一个队列倒到另一个队列。是不是源队列导出一个元素，那么就要删除这个元素，不然的话只是导出来的话，两个队列都有元素了，这样就不满足我们一个队列有元素，一个队列无元素的基本原则了。

//返回栈的头元素
int myStackPop(MyStack* obj)
{Queue* tmp = &obj->q1;//假设法，确定谁有数据Queue* notmp = &obj->q2;if (QueueSize(notmp) == 0){tmp = &obj->q2;notmp = &obj->q1;}while (QueueSize(notmp)>1)//倒数据，并且清楚数据{QueuePush(tmp, QueueFront(notmp));QueuePop(notmp);}QDataType res = QueueFront(notmp);//一个临时变量，并且释放QueuePop(notmp);return res;
}

队列的尾元素

       还会队列的尾元素也是一样的道理吧？我们只需要判断谁的元素有就可以了，然后再访问他的尾节点的元素，那么就很简单。

//返回队列尾元素
int myStackTop(MyStack* obj)
{//判断谁不为空，直接返回if (QueueSize(&obj->q1) != 0)return QueueBack(&obj->q1);elsereturn QueueBack(&obj->q2);
}

    队列判空 

        当大家看了上面的栈实现线队列的判空的话，那么队列判空其实也是很简单的。也是直接判断一个然后相与就可以了。

//队列的判空
bool myStackEmpty(MyStack* obj) 
{return QueueEmpty(&obj->q1)  &&  QueueEmpty(&obj->q2);
}

队列的销毁

       当然实现了这些，我们就要实现最后的一个做指令对你的销毁了。但是我们也知道栈实现队列的销毁就很简单。这个只需要分开销毁并置空就可以了。那么队列的这个肯定也是一样的。只需要分开销毁，然后置空。

//队列的销毁
void myStackFree(MyStack* obj) 
{QueueDestory(&obj->q1);QueueDestory(&obj->q2);free(obj);
}

完整代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>typedef int QDateType;typedef struct QueueNode
{QDateType val;struct QueueNode* next;
}QueueNode;typedef	struct Queue
{QueueNode* head;QueueNode* tail;
}Queue;void QueueInti(Queue* pq)
{assert(pq);pq->head = pq->tail = NULL;
}void QueueDestory(Queue* pq)
{assert(pq);QueueNode* cur = pq->head;while (cur){QueueNode* next = cur->next;free(cur);cur = next;}pq->tail = pq->head = NULL;
}void QueuePush(Queue* pq, QDateType x)
{assert(pq);QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));if (NULL == newNode){printf("malloc error\n");exit(-1);}newNode->val = x;newNode->next = NULL;if (pq->tail == NULL){assert(pq->head == NULL);pq->head = pq->tail = newNode;}else{pq->tail->next = newNode;pq->tail = newNode;}}void QueuePop(Queue* pq)
{assert(pq);assert(pq->head && pq->tail);if (pq->head->next == NULL){free(pq->head);pq->head = pq->tail = NULL;}else{QueueNode* next = pq->head->next;free(pq->head);pq->head = next;}
}bool QueueEmpty(Queue* pq)
{assert(pq);return pq->head == NULL;
}QDateType QueueFront(Queue* pq)
{assert(pq);assert(pq->head);return pq->head->val;
}int QueueSize(Queue* pq)
{assert(pq);QueueNode* cur = pq->head;int count = 0;while (cur){cur = cur->next;count++;}return count;
}//创建两个队列
typedef struct
{Queue q1;Queue q2;
} MyStack;//两个队列的初始化
MyStack* myStackCreate()
{MyStack* st = (MyStack*)malloc(sizeof(MyStack));//创建一个临时结构体if (st == NULL)return false;QueueInit(&st->q1);//分别初始化QueueInit(&st->q2);return st;
}//队列的入队列
void myStackPush(MyStack* obj, int x)
{if (QueueSize(&obj->q1) != 0)//如果q1不为空的话，q1插入，反之q2插入{QueuePush(&obj->q1, x);}else{QueuePush(&obj->q2, x);}
}//返回栈的头元素
int myStackPop(MyStack* obj)
{Queue* tmp = &obj->q1;//假设法，确定谁有数据Queue* notmp = &obj->q2;if (QueueSize(notmp) == 0){tmp = &obj->q2;notmp = &obj->q1;}while (QueueSize(notmp)>1)//倒数据，并且清楚数据{QueuePush(tmp, QueueFront(notmp));QueuePop(notmp);}QDataType res = QueueFront(notmp);//一个临时变量，并且释放QueuePop(notmp);return res;
}//返回队列尾元素
int myStackTop(MyStack* obj)
{//判断谁不为空，直接返回if (QueueSize(&obj->q1) != 0)return QueueBack(&obj->q1);elsereturn QueueBack(&obj->q2);
}//队列的判空
bool myStackEmpty(MyStack* obj) 
{return QueueEmpty(&obj->q1)  &&  QueueEmpty(&obj->q2);
}//队列的销毁
void myStackFree(MyStack* obj) 
{QueueDestory(&obj->q1);QueueDestory(&obj->q2);free(obj);
}

总结

       好了，以上就是关于栈与队列相互实现的相关知识吧。当然这些有其中有很多可以优化的地方，大家可以细心的观察一下，然后呢其中关于这个博客大家其实可以相当于课后拓展，因为确实这样没必要把他作为一个非常重要知识点，大家只需要知道如何使用就可以了。

      最主要的还是需要大家熟练使用对业余战的单个的相关知识来，希望这篇不太对大家会有帮助，然后今天的讲解就到这里了。

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

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

相关文章

服务器数据恢复—DS5300存储raid5阵列数据恢复案例

服务器数据恢复—DS5300存储raid5阵列数据恢复案例

服务器存储数据恢复环境&#xff1a; 某单位一台某品牌DS5300存储&#xff0c;1个机头4个扩展柜&#xff0c;50块硬盘组建2组RAID5磁盘阵列&#xff08;一组raid5阵列有27块成员盘&#xff0c;存放Oracle数据库文件&#xff1b;另外一组raid5阵列有23块成员盘&#xff09;。存储…
阅读更多...
Jmeter使用JSON Extractor提取多个变量

Jmeter使用JSON Extractor提取多个变量

1.当正则不好使时&#xff0c;用json extractor 2.提取多个值时&#xff0c;默认值必填&#xff0c;否则读不到变量
阅读更多...
c进阶篇（四）：内存函数

c进阶篇（四）：内存函数

内存函数以字节为单位更改 1.memcpy memcpy 是 C/C 中的一个标准库函数&#xff0c;用于内存拷贝操作。它的原型通常定义在 <cstring> 头文件中&#xff0c;其作用是将一块内存中的数据复制到另一块内存中。 函数原型&#xff1a;void *memcpy(void *dest, const void…
阅读更多...
长难句打卡7.4

长难句打卡7.4

But policymakers who refocus efforts on improving well-being rather than simply worrying about GDP figures could avoid the forecasted doom and may even see progress. 但政策制定者们应重新集中精力于提升&#xff08;社会&#xff09;幸福感&#xff0c;而非仅仅担…
阅读更多...
Unity 资源 之 Sweet Cakes Icon套装，110个高品质蛋糕图标分享

Unity 资源 之 Sweet Cakes Icon套装，110个高品质蛋糕图标分享

Sweet Cakes Icon 套装 - 为 Unity 开发者带来甜蜜惊喜 前言资源包内容领取兑换码 前言 亲爱的 Unity 开发者们&#xff0c;今天要向你们介绍一款令人心动的图标套装 - Sweet Cakes Icon。 Sweet Cakes Icon 套装包含了超过 110 种高品质的蛋糕和纸杯蛋糕图标&#xff0c;这无…
阅读更多...
鸿蒙开发HarmonyOS NEXT （三） 熟悉ArkTs

鸿蒙开发HarmonyOS NEXT （三） 熟悉ArkTs

一、自定义组件 1、自定义组件 自定义组件&#xff0c;最基础的结构如下&#xff1a; Component struct Header {build() {} } 提取头部标题部分的代码&#xff0c;写成自定义组件。 1、新建ArkTs文件&#xff0c;把Header内容写好。 2、在需要用到的地方&#xff0c;导入…
阅读更多...
去中心化 RAG 先行者，KIP Protocol 如何保护数据所有权、激活 AI 资产

去中心化 RAG 先行者，KIP Protocol 如何保护数据所有权、激活 AI 资产

AI 时代&#xff0c;人人都应实现 KnowledgeFi 的梦想或许并不遥远&#xff0c;KIP Protocol 正在生动践行这一价值理念&#xff0c;带动去中心化数字产权的创建与盈利&#xff0c;面向 CryptoAI 的蓝海市场迈出创新探索的技术步伐&#xff0c;朝着 Web3 行业打造去中心化 AI 的…
阅读更多...
30斤用什么快递便宜？大件物品怎么寄划算省钱？

30斤用什么快递便宜？大件物品怎么寄划算省钱？

大学生小李最近因为毕业要搬家&#xff0c;不得不把一堆书籍、衣服和一些生活用品寄回家。作为一个精打细算的“穷学生”&#xff0c;小李可是不愿意在快递费上花冤枉钱的。于是&#xff0c;他开始研究各种寄快递省钱的方法&#xff0c;今天我们就来看看小李是怎么操作的。一、…
阅读更多...
一款纯 js 实现的大模型应用服务 FastGPT 解读

一款纯 js 实现的大模型应用服务 FastGPT 解读

背景介绍 最近被不同的人安利了 FastGPT 项目&#xff0c;实际上手体验了一下&#xff0c;使用流程类似之前调研过的 Dify, 包含的功能主要是&#xff1a;任务流的编排&#xff0c;知识库管理&#xff0c;另外还有一些外部工具的调用能力。使用页面如下所示&#xff1a; 实际…
阅读更多...
【C++】 解决 C++ 语言报错：Undefined Reference

【C++】 解决 C++ 语言报错：Undefined Reference

文章目录 引言 未定义引用&#xff08;Undefined Reference&#xff09;是 C 编程中常见的错误之一&#xff0c;通常在链接阶段出现。当编译器无法找到函数或变量的定义时&#xff0c;就会引发未定义引用错误。这种错误会阻止生成可执行文件&#xff0c;影响程序的正常构建。本…
阅读更多...
武汉免费 【FPGA实战训练】 Vivado入门与设计师资课程

武汉免费 【FPGA实战训练】 Vivado入门与设计师资课程

一&#xff0e;背景介绍 当今高度数字化和智能化的工业领域&#xff0c;对高效、灵活且可靠的技术解决方案的需求日益迫切。随着工业 4.0 时代的到来&#xff0c;工业生产过程正经历着前所未有的变革&#xff0c;从传统的机械化、自动化逐步迈向智能化和信息化。在这一背景下&…
阅读更多...
日志自动提取---七牛Logkit观星应急工具

日志自动提取---七牛Logkit观星应急工具

目录 七牛Logkit (Windows&Linux&Mac 等) 下载: 文档: windows配置过程: 1-下载 2-修改logkit-community基本配置 3-启动! 4-浏览器访问 5-添加配置吧 观星应急工具 &#xff08;Windows 系统日志&#xff09; 七牛Logkit (Windows&Linux&Mac 等) -…
阅读更多...
ETCD 基本介绍与常见命令的使用

ETCD 基本介绍与常见命令的使用

转载请标明出处&#xff1a;https://blog.csdn.net/donkor_/article/details/140171610 文章目录 一、基本介绍1.1 参考1.2 什么是ETCD1.3 ETCD的特点1.4 ETCD的主要功能1.5 ETCD的整体架构1.6 什么时候用ETCD&#xff0c;什么时候用redis 二、安装三、使用3.1 etcdctl3.2 常用…
阅读更多...
Camera link（学习笔记）

Camera link（学习笔记）

Camera Link协议是一种专门针对机器视觉应用领域的串行通信协议&#xff0c;它使用低压差分信号(LVDS)进行数据的传输和通信。Camera Link标准是在ChannelLink标准的基础上多加了6对差分信号线&#xff0c;其中4对用于并行传输相机控制信号&#xff0c;另外2对用于相机和图像采…
阅读更多...
KEYSIGHT N1092系列，DCA-M系列采样示波器连接与自检？

KEYSIGHT N1092系列，DCA-M系列采样示波器连接与自检？

KEYSIGHT N1092系列 采样示波器&#xff0c;虽然省去了屏幕和操作系统&#xff0c;但根据不同的型号&#xff0c;可以配备不同数量的光口和电口&#xff0c;满足各种测试需求。本次介绍的具体型号为N1092D&#xff0c;它拥有4个光口&#xff0c;能够进行多种测试。 测试步骤详解…
阅读更多...
开源大模型和闭源大模型，打法有何区别？

开源大模型和闭源大模型，打法有何区别？

现阶段&#xff0c;各个公司都有自己的大模型产品&#xff0c;有的甚至不止一个。除了小部分开源外&#xff0c;大部分都选择了闭源。那么&#xff0c;头部开源模型厂商选择开源是出于怎样的初衷和考虑&#xff1f;未来大模型将如何发展&#xff1f;我们来看看本文的分享。 在对…
阅读更多...
揭秘：华火电焰灶可不可信，安不安全？

揭秘：华火电焰灶可不可信，安不安全？

随着科技的不断进步&#xff0c;传统厨房灶具也在经历着前所未有的变革。在这个追求环保、节能和智能化的时代&#xff0c;最近发布的一款名为华火电燃喷焰式组合灶厨吸引了众多消费者的目光。今天&#xff0c;我们就来对这款华火HH-SZQP60电燃喷焰式组合灶进行一次深入评测&am…
阅读更多...
文字识别技术升级：Airtest与PaddleOCR模型的协作小技巧

文字识别技术升级：Airtest与PaddleOCR模型的协作小技巧

一、前言 在进行自动化测试的过程中&#xff0c;ocr文字识别一直是大家最想要实现以及最需要的能力&#xff0c;今天就来介绍一个由百度飞浆提供的一个免费的ocr识别库——PaddleOCR&#xff0c;以及探讨一下&#xff0c;PaddleOCR与Airtest协作能擦出怎么样的火花~ 二、Padd…
阅读更多...
智慧交通运行监测与应急指挥中心方案

智慧交通运行监测与应急指挥中心方案

建设目标 建立感知层数据的实时采集以及数据处理&#xff0c;实现监测预警自动化和智能化&#xff1b;推动交通运输数据资源开放共享&#xff0c;打破数据资源壁垒&#xff0c;与城市各部门数据建立共享交换机制&#xff0c;实现应急指挥的协同化&#xff1b;充分运用大数据、互…
阅读更多...
《简历宝典》01 - 一文带你学会如何写一份糟糕透顶的简历

《简历宝典》01 - 一文带你学会如何写一份糟糕透顶的简历

我们每个人几乎都会面对找工作这件事&#xff0c;而找工作或者说求职首先就是要写一份简历。今天狗哥将以一个不同的视角带你写一份无与伦比&#xff0c;糟糕透顶的求职简历&#xff0c;说实话&#xff0c;其实几年前&#xff0c;我就是这么写的。 目录 1. 文件名 2. 基本信…
阅读更多...
最新文章

Copyright @ 2022~2023