栈和队列（C语言）

news2024/11/26 5:56:01

栈的定义

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶
可以把他想象成一个水杯

栈代码的实现

结构的定义，以及函数声明

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int QueueNodeType;
struct QueueNode {
	struct QueueNode* next;
	QueueNodeType data;
}typedef QueueNode;

//队列只需要在队尾插入，队头删除，不需要改变里面的内容
//所以只需要改变头尾
struct Queue {
	struct QueueNode* head;
	struct QueueNode* tail;
	size_t _size;
}typedef Queue;

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

接口的实现

#define  _CRT_SECURE_NO_WARNINGS 1
#include "queue.h"

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

void QueueDestroy(Queue* q)
{
	assert(q);
	while (q->head)
	{
		QueueNode* next = q->head->next;
		free(q->head);
		q->head = next;
	}
	q->tail = NULL;
	q->_size = 0;
}

void QueuePush(Queue* q, QueueNodeType data)
{
	assert(q);

	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	assert(newnode);
	newnode->data = data;
	newnode->next = NULL;

	//尾插
	if (q->tail == NULL)
	{
		q->tail = q->head = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = q->tail->next;
	}
	q->_size++;
}

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	QueueNode* newhead = q->head->next;
	free(q->head);
	q->head = newhead;
	if (q->head == NULL)
	{
		q->tail = NULL;
	}
	q->_size--;
}

bool QueueEmpty(Queue* q)
{
	assert(q);
	return q->head == NULL;
}

QueueNodeType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}

QueueNodeType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->tail->data;
}

size_t QueueSize(Queue* q)
{
	assert(q);
	return q->_size;
}

队列的定义

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

队列代码的实现

结构的定义，以及函数声明

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int QueueNodeType;
struct QueueNode {
	struct QueueNode* next;
	QueueNodeType data;
}typedef QueueNode;

//队列只需要在队尾插入，队头删除，不需要改变里面的内容
//所以只需要改变头尾
struct Queue {
	struct QueueNode* head;
	struct QueueNode* tail;
	size_t _size;
}typedef Queue;

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

接口的实现

#define  _CRT_SECURE_NO_WARNINGS 1
#include "queue.h"

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

void QueueDestroy(Queue* q)
{
	assert(q);
	while (q->head)
	{
		QueueNode* next = q->head->next;
		free(q->head);
		q->head = next;
	}
	q->tail = NULL;
	q->_size = 0;
}

void QueuePush(Queue* q, QueueNodeType data)
{
	assert(q);

	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	assert(newnode);
	newnode->data = data;
	newnode->next = NULL;

	//尾插
	if (q->tail == NULL)
	{
		q->tail = q->head = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = q->tail->next;
	}
	q->_size++;
}

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	QueueNode* newhead = q->head->next;
	free(q->head);
	q->head = newhead;
	if (q->head == NULL)
	{
		q->tail = NULL;
	}
	q->_size--;
}

bool QueueEmpty(Queue* q)
{
	assert(q);
	return q->head == NULL;
}

QueueNodeType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}

QueueNodeType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->tail->data;
}

size_t QueueSize(Queue* q)
{
	assert(q);
	return q->_size;
}

题目1：括号匹配问题

题目链接：https://leetcode.cn/problems/valid-parentheses/description/
在这里插入图片描述
思路详解：
在这里插入图片描述

参考代码

typedef char StackType;

struct Stack {
	StackType* _a;
	int _top;
	int _capacity;
}typedef Stack;

//初始化栈
void StackInit(Stack* pStack);

//入栈
void StackPush(Stack* pStack,StackType data);

//出栈
void StackPop(Stack* pStack);

//获取栈顶元素
StackType StackTop(const Stack* pStack);

//获取栈中有效元素个数
int StackSize(const Stack* pStack);

//判断栈是否为空
bool StackEmpty(Stack* pStack);

//销毁栈
void StackDestroy(Stack* pStack);

void StackInit(Stack* pStack)
{
	pStack->_a = NULL;
	pStack->_capacity = 0;
	pStack->_top = 0;
}

void StackPush(Stack* pStack,StackType data)
{
	assert(pStack);
	if (pStack->_top == pStack->_capacity)
	{
		int newCapacity = pStack->_capacity == 0 ? 4 : pStack->_capacity * 2;
		StackType* newa = NULL;
		newa = (StackType*)realloc(pStack->_a, sizeof(StackType) * newCapacity);
		if (newa == NULL)
		{
			perror("StackPush():: realloc::");
			return;
		}
		pStack->_a = newa;
		pStack->_capacity = newCapacity;
	}
	
	pStack->_a[pStack->_top] = data;
	pStack->_top++;
}

void StackPop(Stack* pStack)
{
	assert(pStack);
	assert(!StackEmpty(pStack));
	pStack->_top--;
}

StackType StackTop(const Stack* pStack)
{
	// 因为top的初始值为0 ，而插入一个数据后为1，
	// 但是所对应的数组下标为0
    assert(pStack);
	assert(!StackEmpty(pStack));
	return pStack->_a[pStack->_top - 1];
}

int StackSize(const Stack* pStack)
{
	return pStack->_top;
}

bool StackEmpty(Stack* pStack)
{
	assert(pStack);
	return pStack->_top == 0;
}

void StackDestroy(Stack* pStack)
{
	free(pStack->_a);
	pStack->_capacity = 0;
	pStack->_top = 0;
	pStack->_a = NULL;
}
//这里题目实现，上面都是栈的实现和接口，因为是C语言的关系没有STL库所以要自己造轮子
bool isValid(char* s) 
{
    
    Stack stack = { 0 };
    StackInit(&stack);
    while (*s)
    {
        if (*s == '(' || *s == '{' || *s == '[')
        {
            StackPush(&stack, *s);
            s++;
        }
        else
        {
            //第一个字符为有括号，证明不是有效括号，直接返回NULL
            if(StackEmpty(&stack))
            {
                //特殊案例如果是 [[]]],这里如果直接返回的话就会导致内存泄露
                StackDestroy(&stack);
                return false;
            }
            StackType top = StackTop(&stack);
            StackPop(&stack);
            if (top == '(' && *s != ')'
                || top == '{' && *s != '}'
                || top == '[' && *s != ']'
                )
            {
                StackDestroy(&stack);
                return false;
            }
            else
            { 
                s++;
            }
        }
    }

    bool ret = StackEmpty(&stack);
    StackDestroy(&stack);
    return ret;
    // return true;
}

题目2：用队列实现栈

题目链接：https://leetcode.cn/problems/implement-stack-using-queues/
在这里插入图片描述
思路详解：
在这里插入图片描述
在这里插入图片描述

参考代码：

typedef int QueueNodeType;
struct QueueNode {
	struct QueueNode* next;
	QueueNodeType data;
}typedef QueueNode;

//队列只需要在队尾插入，队头删除，不需要改变里面的内容
//所以只需要改变头尾
struct Queue {
	struct QueueNode* head;
	struct QueueNode* tail;
	size_t _size;
}typedef Queue;

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

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

void QueueDestroy(Queue* q)
{
	assert(q);
	while (q->head)
	{
		QueueNode* next = q->head->next;
		free(q->head);
		q->head = next;
	}
	q->tail = NULL;
	q->_size = 0;
}

void QueuePush(Queue* q, QueueNodeType data)
{
	assert(q);

	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	assert(newnode);
	newnode->data = data;
	newnode->next = NULL;

	//尾插
	if (q->tail == NULL)
	{
		q->tail = q->head = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = q->tail->next;
	}
	q->_size++;
}

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	QueueNode* newhead = q->head->next;
	free(q->head);
	q->head = newhead;
	if (q->head == NULL)
	{
		q->tail = NULL;
	}
	q->_size--;
}

bool QueueEmpty(Queue* q)
{
	assert(q);
	return q->head == NULL;
}

QueueNodeType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}

QueueNodeType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->tail->data;
}

size_t QueueSize(Queue* q)
{
	assert(q);
	return q->_size;
}

//上面是队列的接口，从这里下面才开始对栈的实现
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* mystack = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&mystack->q1);
    QueueInit(&mystack->q2);
    return mystack;
}

void myStackPush(MyStack* obj, int x) {
    if(QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q2,x);
    }
    else
    {
        QueuePush(&obj->q1,x);
    }
}

int myStackPop(MyStack* obj) {
	//找那个是为空队列
    Queue* emptyQueue = &obj->q1;
    Queue* nonEmptyQueue = &obj->q2;
    if(QueueEmpty(&obj->q2))
    {
        emptyQueue = &obj->q2;
        nonEmptyQueue = &obj->q1;
    }
    //保留非空队列中的最后一个元素，其余元素转移到空队列里面
    while(QueueSize(nonEmptyQueue) > 1)
    {
        QueuePush(emptyQueue,QueueFront(nonEmptyQueue));
        QueuePop(nonEmptyQueue);
    }
    int ret = QueueFront(nonEmptyQueue);
    QueuePop(nonEmptyQueue);
    return ret;
}

int myStackTop(MyStack* obj) {
	//两个队列中，非空的那个队列的队尾就是栈顶
    if(QueueEmpty(&obj->q1))
    {
       return QueueBack(&obj->q2); 
    }
    else
    {
        return QueueBack(&obj->q1);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

题目3：用栈实现队列

题目链接：https://leetcode.cn/problems/implement-queue-using-stacks/description/

在这里插入图片描述
思路详解：
在这里插入图片描述

参考代码：

typedef char StackType;

struct Stack {
	StackType* _a;
	int _top;
	int _capacity;
}typedef Stack;

//初始化栈
void StackInit(Stack* pStack);

//入栈
void StackPush(Stack* pStack,StackType data);

//出栈
void StackPop(Stack* pStack);

//获取栈顶元素
StackType StackTop(Stack* pStack);

//获取栈底元素
StackType StackBottom(Stack* pStack);

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

//判断栈是否为空
bool StackEmpty(Stack* pStack);

//销毁栈
void StackDestroy(Stack* pStack);


void StackInit(Stack* pStack)
{
	pStack->_a = NULL;
	pStack->_capacity = 0;
	pStack->_top = 0;
}

void StackPush(Stack* pStack,StackType data)
{
	assert(pStack);
	if (pStack->_top == pStack->_capacity)
	{
		int newCapacity = pStack->_capacity == 0 ? 4 : pStack->_capacity * 2;
		StackType* newa = NULL;
		newa = (StackType*)realloc(pStack->_a, sizeof(StackType) * newCapacity);
		if (newa == NULL)
		{
			perror("StackPush():: realloc::");
			return;
		}
		pStack->_a = newa;
		pStack->_capacity = newCapacity;
	}
	
	pStack->_a[pStack->_top] = data;
	pStack->_top++;
}

void StackPop(Stack* pStack)
{
	assert(pStack);
	assert(!StackEmpty(pStack));
	pStack->_top--;
}

StackType StackTop(Stack* pStack)
{
	assert(pStack);
	assert(!StackEmpty(pStack));
	// 因为top的初始值为0 ，而插入一个数据后为1，
	// 但是所对应的数组下标为0
	return pStack->_a[pStack->_top - 1];
}

StackType StackBottom(Stack* pStack)
{
	assert(pStack);
	assert(!StackEmpty(pStack));
	return pStack->_a[0];
}

int StackSize(Stack* pStack)
{
	return pStack->_top;
}

bool StackEmpty(Stack* pStack)
{
	assert(pStack);
	return pStack->_top == 0;
}

void StackDestroy(Stack* pStack)
{
	free(pStack->_a);
	pStack->_capacity = 0;
	pStack->_top = 0;
	pStack->_a = NULL;
}

//这里开始才是实现队列的代码
typedef struct {
    Stack PushStack;
    Stack PopStack;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* queue= (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&queue->PushStack);
    StackInit(&queue->PopStack);
    return queue;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->PushStack,x);
}

int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->PopStack))
    {
        while(!StackEmpty(&obj->PushStack))
        {
            StackPush(&obj->PopStack,StackTop(&obj->PushStack));
            StackPop(&obj->PushStack);
        }
    }
    int popTop = StackTop(&obj->PopStack);
    StackPop(&obj->PopStack);
    return popTop;
}

//返回队头
int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->PopStack))
    {
        while(!StackEmpty(&obj->PushStack))
        {
            StackPush(&obj->PopStack,StackTop(&obj->PushStack));
            StackPop(&obj->PushStack);
        }
    }
    return StackTop(&obj->PopStack);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->PushStack) && StackEmpty(&obj->PopStack);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->PopStack);
    StackDestroy(&obj->PushStack);
    free(obj);
}

题目4：设计循环队列

题目链接：https://leetcode.cn/problems/design-circular-queue/description/
在这里插入图片描述
思路详解：

在这里插入图片描述

参考代码：
用数组实现：

typedef struct {
    int* _a; //数组
    int _head; //头下标
    int _tail; //尾下标
    int _k; //存储的元素个数
} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);


// 初始化
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    assert(cq);
    cq->_a = (int*)malloc(sizeof(int) * (k + 1));
    assert(cq->_a);
    cq->_head = 0;
    cq->_tail = 0;
    cq->_k = k;
    return cq;
}

// 入队列
bool myCircularQueueEnQueue(MyCircularQueue * obj, int value) {
    assert(obj);
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->_a[obj->_tail] = value;
        if (obj->_tail >= obj->_k)
        {
            obj->_tail = 0;
        }
        else
        {
            obj->_tail++;
        }
        return true;
    }
}

//删队列
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    if (obj->_head >= obj->_k)
    {
        obj->_head = 0;
        return true;
    }
    else
    {
        obj->_head++;
        return true;
    }
}

//队头
int myCircularQueueFront(MyCircularQueue* obj) {
    assert(obj);
    if (myCircularQueueIsEmpty(obj))
    {
        return -1; 
    }
    return obj->_a[obj->_head];
}

//队尾
int myCircularQueueRear(MyCircularQueue* obj) {
    assert(obj);
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    //方法1；
    if (obj->_tail == 0)
    {
        return obj->_a[obj->_k];
    }
    else
    {
        return obj->_a[obj->_tail - 1];
    }
    //方法2：
    /*int i = (obj->_tail + obj->_k) % (obj->_k + 1);
    return obj->_a[i];*/
}

//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);
    return obj->_head == obj->_tail;
}

//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    assert(obj);
    return (obj->_tail + 1) % (obj->_k + 1) == obj->_head;
}

//销毁
void myCircularQueueFree(MyCircularQueue* obj) {
    assert(obj);
    free(obj->_a);
    free(obj);
}

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

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

相关文章

【Python正则表达式】：文本解析与模式匹配

【Python正则表达式】：文本解析与模式匹配

文章目录 1.正则表达式2. re模块3.修饰符3.元字符3-1 字符匹配元字符3-2 重复次数限定元字符3-3 字符集合匹配元字符3-4 分组元字符3-5 边界匹配元字符3-6 字符类别匹配元字符 4.技巧4-1 贪婪与非贪婪 5.案例 1.正则表达式 正则表达式面向什么样的问题&#xff1f; 1、判断一个…
阅读更多...
平衡三进制计算机模拟2

平衡三进制计算机模拟2

1、计算机的起源 在19世纪的时候&#xff0c;“Computer”代表的并不是计算机&#xff0c;而是计算员&#xff0c;那时并没有计算机的概念&#xff0c;而计算员当然是要计算东西的&#xff0c;当时计算东西多&#xff0c;计算水平也参差不齐&#xff0c;加上疲劳等因素&#xf…
阅读更多...
华夏银行的进和退：不良率位列同业第一，分红比例常年不达标

华夏银行的进和退：不良率位列同业第一，分红比例常年不达标

撰稿|芋圆 来源|贝多财经 近日&#xff0c;华夏银行股份有限公司&#xff08;SH:600015&#xff0c;下称“华夏银行”&#xff09;北京分行联合北京产权交易所举办了特殊资产推介会。会上&#xff0c;华夏银行包括北京分行在内的7家分行和信用卡中心&#xff0c;共同推介了超…
阅读更多...
从操作系统层面认识Linux

从操作系统层面认识Linux

描述进程-PCB Linux操作系统下的PCB是: task_struct https://www.cnblogs.com/tongyan2/p/5544887.htmlhttps://www.cnblogs.com/tongyan2/p/5544887.html校招必背操作系统面试题-什么是 PCB&#xff08;进程控制块&#xff09; &#xff1f;_哔哩哔哩_bilibili校招必背操作系…
阅读更多...
汉明权重（Hamming Weight）（统计数据中1的个数）VP-SWAR算法

汉明权重（Hamming Weight）（统计数据中1的个数）VP-SWAR算法

汉明权重&#xff08;Hamming Weight&#xff09;&#xff08;统计数据中1的个数&#xff09;VP-SWAR算法 定义 汉明重量是一串符号中非零符号的个数。它等于同样长度的全零符号串的汉明距离(在信息论中&#xff0c;两个等长字符串之间的汉明距离等于两个字符串对应位置的不同…
阅读更多...
浏览器插件利器--allWebPluginV2.0.0.16-beta版发布

浏览器插件利器--allWebPluginV2.0.0.16-beta版发布

allWebPlugin简介 allWebPlugin中间件是一款为用户提供安全、可靠、便捷的浏览器插件服务的中间件产品&#xff0c;致力于将浏览器插件重新应用到所有浏览器。它将现有ActiveX控件直接嵌入浏览器&#xff0c;实现插件加载、界面显示、接口调用、事件回调等。支持Chrome、Firefo…
阅读更多...
刷题了：242.有效的字母异位词 |349. 两个数组的交集 | 202. 快乐数|1. 两数之和

刷题了：242.有效的字母异位词 |349. 两个数组的交集 | 202. 快乐数|1. 两数之和

学习记录&#xff0c;主要参考&#xff1a;代码随想录 哈希表理论基础 文章讲解:https://programmercarl.com/%E5%93%88%E5%B8%8C%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html 哈希表&#xff08;Hash table&#xff09; 哈希表是根据关键码的值而直接进行访问的数据…
阅读更多...
deepseek-vl 论文阅读笔记

deepseek-vl 论文阅读笔记

目录 一、已有模型性能差距分析 二、创新点 数据集构建 模型架构 训练策略 实验与评估 三、细节 数据构建 内部SFT数据的分类体系 模型架构 训练流程包括三个阶段 系统包含三个模块 混合视觉编码器 视觉-语言适配器 语言模型 训练策略 阶段一&#xff1a;训练…
阅读更多...
nfs和web服务器的搭建

nfs和web服务器的搭建

&#xff08;一&#xff09;web服务器的搭建 1.配置基本环境 要点有&#xff0c;yum源&#xff0c;包含nginx和阿里云&#xff08;或者腾讯云或者华为云&#xff09;&#xff0c;这里的相关知识可以参考之前的yum配置笔记 2.安装nginx yum -y install nginx 3.验证并且开启服…
阅读更多...
MLCC电容特性及注意事项

MLCC电容特性及注意事项

MLCC结构和工作原理 如下图所示&#xff0c;MLCC电容结构较简单&#xff0c;由陶瓷介质、内电极金属层和外电极三层构成。 MLCC的电容量公式可以如下表示&#xff1a; C&#xff1a;电容量&#xff0c;以F&#xff08;法拉&#xff09;为单位&#xff0c;而MLCC之电容值以PF&…
阅读更多...
AWE2025正式启动，AWE×AI 推动智慧生活的普及

AWE2025正式启动，AWE×AI 推动智慧生活的普及

7月18日&#xff0c;2025年中国家电及消费电子博览会&#xff08;AWE2025&#xff09;正式启动。主办方宣布&#xff0c;AWE2025的主题为“AI科技、AI生活”&#xff0c;展会将于2025年3月20-23日在上海新国际博览中心举办。 作为全球三大家电和消费电子领域展会之一&#xff…
阅读更多...
数字孪生智慧农业技术：优化农业生产的未来

数字孪生智慧农业技术：优化农业生产的未来

随着科技的进步和全球食品需求的增长&#xff0c;数字孪生智慧农业技术作为现代农业生产的新兴力量&#xff0c;正在为农业界带来革命性的变化和巨大的发展潜力。本文将深入探讨数字孪生智慧农业技术的核心架构、关键技术应用及其在提升农业生产效率和可持续发展中的作用。 ###…
阅读更多...
word压缩大小怎么弄？这几种方法轻松压缩word文件！

word压缩大小怎么弄？这几种方法轻松压缩word文件！

word压缩大小怎么弄&#xff1f;面对庞大无比的Word文档&#xff0c;我们往往遭遇诸多不便&#xff0c;它们如同数据海洋中的巨鲸&#xff0c;不仅鲸吞存储空间&#xff0c;更在传输途中缓缓游弋&#xff0c;耗费大量时光&#xff0c;在资源有限的设备上&#xff0c;这些文档仿…
阅读更多...
python基础语法 007 文件操作-1读取写入

python基础语法 007 文件操作-1读取写入

1 文件操作 1.1 什么时候用文件操作&#xff1f; 打开文档写东西看东西拿文档做统计 在python 文档操作作用 存储数据读取数据 打开文件有什么用&#xff1f; 读取数据&#xff0c;写入数据不管什么数据都可以用open打开&#xff0c;如可复制一张图片 1.2 open() 读取,…
阅读更多...
开源模型应用落地-FastAPI-助力模型交互-进阶篇-中间件（四）

开源模型应用落地-FastAPI-助力模型交互-进阶篇-中间件（四）

一、前言 FastAPI 的高级用法可以为开发人员带来许多好处。它能帮助实现更复杂的路由逻辑和参数处理&#xff0c;使应用程序能够处理各种不同的请求场景&#xff0c;提高应用程序的灵活性和可扩展性。 在数据验证和转换方面&#xff0c;高级用法提供了更精细和准确的控制&#…
阅读更多...
SqlServer: LAG等开窗函数应用

SqlServer: LAG等开窗函数应用

原贴&#xff1a; https://bbs.csdn.net/topics/619167074 https://learn.microsoft.com/zh-cn/sql/t-sql/functions/lag-transact-sql?viewsql-server-ver16 CREATE TABLE #kcb(xlh INT,shul INT,ftshl INT ) INSERT INTO #kcb(xlh,shul,ftshl) SELECT 1,20…
阅读更多...
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 中文分词模拟器(200分) - 三语言AC题解(Python/Java/Cpp)

【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 中文分词模拟器(200分) - 三语言AC题解(Python/Java/Cpp)

🍭 大家好这里是清隆学长 ，一枚热爱算法的程序员 ✨ 本系列打算持续跟新华为OD-C/D卷的三语言AC题解 💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导 👏 感谢大家的订阅➕ 和 喜欢💗 🍿 最新华为OD机试D卷目录，全、新、准，题目覆盖率达 95% 以上，支持题目在线…
阅读更多...
python基础语法 007 文件操作-2文件支持模式文件的内置函数

python基础语法 007 文件操作-2文件支持模式文件的内置函数

1.3 文件支持的模式 模式含义ropen a file for reading(default)wopen a file for writing,creates a new file if it does not exist or truncates the file if it exists x open a file foe exclusive creation. if the file already exists, the operation fails.独创模式&…
阅读更多...
Redis中的哨兵（Sentinel）

Redis中的哨兵（Sentinel）

上篇文章我们讲述了Redis中的主从复制&#xff08;Redis分布式系统中的主从复制-CSDN博客&#xff09;&#xff0c;本篇文章针对主从复制中的问题引出Redis中的哨兵&#xff0c;希望本篇文章会对你有所帮助。 文章目录 一、引入哨兵机制 二、基本概念 三、主从复制的问题 四、哨…
阅读更多...
tensorflow keras Model.fit returning: ValueError: Unrecognized data type

tensorflow keras Model.fit returning: ValueError: Unrecognized data type

题意&#xff1a;TensorFlow Keras 的 Model.fit 方法返回了一个 ValueError&#xff0c;提示数据类型无法识别 问题背景&#xff1a; Im trying to train a keras model with 2 inputs: an image part thats a tf.data.Dataset and a nor mal part represented by a pd.DataF…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023