[数据结构]栈和队列面试题解析

news2025/7/9 5:55:09

作者： 华丞臧.
专栏：【数据结构】
各位读者老爷如果觉得博主写的不错，请诸位多多支持(点赞+收藏+关注)。如果有错误的地方，欢迎在评论区指出。
推荐一款刷题网站 👉 LeetCode刷题网站

文章目录

  • 一、有效括号
    • 题目描述
    • 解题思路
    • 代码实现
  • 二、用队列实现栈
    • 题目描述
    • 解题思路
    • 代码实现
  • 三、用栈实现队列
    • 题目描述
    • 解题思路
    • 代码实现
  • 四、设计循环队列
    • 题目描述
    • 解题思路
    • 代码实现

一、有效括号

题目描述

LeetCode.20 有效的括号
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

在这里插入图片描述

解题思路

我们知道在一个式子当中后出现的左括号要与先出现的右括号配对；那么对于左括号而言，就是先入后出符合栈的特性，所以我们用栈来存储左括号；当遇到右括号时，判断栈顶的括号和该右括号是否配对，如果配对成功则出栈栈顶元素，否则配对失败则return false,这样既保证了相同类型又保证了顺序闭合；当遍历完传入的字符串时，还需要检查栈中是否为空。

代码实现

typedef char STDataType;

typedef struct Stack
{
	STDataType* data;
	int top;
	int capacity;
}ST;


//初始化栈
void StackInit(ST* ps);

//销毁栈
void StackDestroy(ST* ps);

//入栈
void StackPush(ST* ps, STDataType x);

//出栈
void StackPop(ST* ps);

//获取栈顶元素
STDataType  StackTop(ST* ps);

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

//检查栈是否为空，如果为空返回非0结果，如果不为空返回0
bool StackEmpty(ST* ps);

//初始化栈
void StackInit(ST* ps)
{
	assert(ps);
	ps->data = NULL;
	ps->top = ps->capacity = 0;
}

//销毁栈
void StackDestroy(ST* ps)
{
	assert(ps);

	free(ps->data);
	ps->data = NULL;
	ps->capacity = ps->top = 0;
}


//入栈
void StackPush(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->data, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->data = tmp;
		ps->capacity = newCapacity;
	}
	ps->data[ps->top] = x;
	ps->top++;
}


//出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	ps->top--;
}


//获取栈顶元素
STDataType StackTop(ST* ps) 
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->data[ps->top - 1];
}


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

	return ps->top;
}


//检查栈是否为空，如果为空返回非0结果，如果不为空返回0
bool StackEmpty(ST* ps)
{
	assert(ps);

	/*if (ps->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/

	return ps->top == 0;
}

bool isValid(char* s)
{
    ST pst;
    StackInit(&pst);
    char* cur = s;

    while(*cur)
    {
        if(*cur == '(' || *cur == '{' || *cur == '[')
        {
            StackPush(&pst,*cur);
        }
        else
        {
            if(StackEmpty(&pst))
            {
                StackDestroy(&pst);
                return false;
            }
            char tmp = StackTop(&pst);
            StackPop(&pst);
            if((*cur == '}' && tmp != '{')
            || (*cur == ']' && tmp != '[')
            || (*cur == ')' && tmp != '('))
            {
                StackDestroy(&pst);
                return false;
            }
        }
    cur++;
    }

   bool flag = StackEmpty(&pst);
    StackDestroy(&pst);
    return flag;
}

二、用队列实现栈

题目描述

LeetCode.225 用队列实现栈
请你仅使用两个队列实现一个后入先出（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;
}QLNode;

typedef struct Queue
{
	QLNode* head;
	QLNode* tail;
	int size;
}QE;

//初始化队列
void QueueInit(QE* q);

//队尾入队列
void QueuePush(QE* q,QDataType x);

//队头出队列
void QueuePop(QE* q);

//获取队列头部元素
QDataType QueueFront(QE* q);

//获取队列队尾元素
QDataType QueueBack(QE* q);

//获取队列有效元素个数
int QueueSize(QE* q);

//检查队列是否为空，如果为空返回非0数，如果不为空返回0
bool QueueEmpty(QE* q);

//销毁队列
void QueueDestroy(QE* q);

//申请一个结点
QLNode* BuyQListNode(QDataType x);

//初始化队列
void QueueInit(QE* q)
{
	assert(q);

	q->head = q->tail = NULL;
	q->size = 0;
}


//申请一个结点
QLNode* BuyQListNode(QDataType x)
{
	QLNode* newnode = (QLNode*)malloc(sizeof(QLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

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

	//申请一个结点
	QLNode* newnode = BuyQListNode(x);

	//分有数据和无数据
	if (q->head == NULL && q->tail == NULL)
	{
		q->head = newnode;
		q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}


//队头出队列
void QueuePop(QE* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	if (q->head->next == NULL)
	{
		free(q->head);
		q->head = q->tail = NULL;
	}
	else
	{
		QLNode* tmp = q->head->next;
		free(q->head);
		q->head = tmp;
	}	
	--q->size;
}

//获取队列头部元素
QDataType QueueFront(QE* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->head->data;
}


//获取队列队尾元素
QDataType QueueBack(QE* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->tail->data;
}


//获取队列有效元素个数
int QueueSize(QE* q)
{
	assert(q);
	return q->size;
}

//检查队列是否为空，如果为空返回非0数，如果不为空返回0
bool QueueEmpty(QE* q)
{
	assert(q);
	return q->head == NULL && q->tail == NULL;
}


//销毁队列
void QueueDestroy(QE* q)
{
	assert(q);
	while (q->head)
	{
		QLNode* tmp = q->head->next;
		free(q->head);
		q->head = tmp;
	}
	q->head = q->tail = NULL;
	q->size = 0;
}

typedef struct {
    QE q1;
    QE q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    if(obj == NULL)
    {
        perror("malloc fail");
        return NULL;
    }
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);    
    return obj;
}

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

int myStackPop(MyStack* obj) {
    assert(obj);
    QE* empty = &obj->q1;
    QE* nonempty = &obj->q2;

    if(QueueEmpty(&obj->q2))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }

    int tmp = 0;

    while(QueueSize(nonempty) > 1)
    {
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }
    tmp = QueueFront(nonempty);
    QueuePop(nonempty);
    
    return tmp;
}

int myStackTop(MyStack* obj) 
{
    assert(obj);

    if(!QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2))
    {
        return obj->q1.tail->data;
    }
    else if(!QueueEmpty(&obj->q2) && QueueEmpty(&obj->q1))
    {
        return obj->q2.tail->data;
    }
    return 0;
}

bool myStackEmpty(MyStack* obj) {
    assert(obj);

    return  QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

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

三、用栈实现队列

题目描述

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

实现 MyQueue 类：

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

在这里插入图片描述

解题思路

用两个栈实现队列，那么我们把两个栈分为 入队列的栈 push 和 出队列的栈 pop;进行入队列操作时，把数据压入push。进行出队列操作时，如果pop为空，则把push中的数据压入pop中再进行出栈操作；如果push不为空，则直接对pop进行出栈操作。
在这里插入图片描述

代码实现

typedef int STDataType;

typedef struct Stack
{
	STDataType* data;
	int top;
	int capacity;
}ST;


//初始化栈
void StackInit(ST* ps);

//销毁栈
void StackDestroy(ST* ps);

//入栈
void StackPush(ST* ps, STDataType x);

//出栈
void StackPop(ST* ps);

//获取栈顶元素
STDataType  StackTop(ST* ps);

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

//检查栈是否为空，如果为空返回非0结果，如果不为空返回0
bool StackEmpty(ST* ps);

//初始化栈
void StackInit(ST* ps)
{
	assert(ps);
	ps->data = NULL;
	ps->top = ps->capacity = 0;
}

//销毁栈
void StackDestroy(ST* ps)
{
	assert(ps);

	free(ps->data);
	ps->data = NULL;
	ps->capacity = ps->top = 0;
}


//入栈
void StackPush(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->data, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->data = tmp;
		ps->capacity = newCapacity;
	}
	ps->data[ps->top] = x;
	ps->top++;
}


//出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	--ps->top;
}


//获取栈顶元素
STDataType StackTop(ST* ps) 
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->data[ps->top - 1];
}


//获取栈中有效元素个数
int StackSize(ST* ps)
{
	assert(ps);
	
	return ps->top;
}


//检查栈是否为空，如果为空返回非0结果，如果不为空返回0
bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}


typedef struct {
    ST push;
    ST pop;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->push);
    StackInit(&obj->pop);
    return obj;
}

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

int myQueuePop(MyQueue* obj) {
    assert(obj);

    STDataType top = 0;
    if(!StackEmpty(&obj->pop))
    {
        top = StackTop(&obj->pop);
        StackPop(&obj->pop);
    }
    else
    {
        while(StackSize(&obj->push) > 0)
        {
            StackPush(&obj->pop,StackTop(&obj->push));
            StackPop(&obj->push);
        }
        top = StackTop(&obj->pop);
        StackPop(&obj->pop);
    }
    return top;
}

int myQueuePeek(MyQueue* obj) {
    assert(obj);
    if(!StackEmpty(&obj->pop))
    {
        return StackTop(&obj->pop);
    }
    else
    {
        while(StackSize(&obj->push) > 0)
        {
            StackPush(&obj->pop,StackTop(&obj->push));
            StackPop(&obj->push);
        }
        return StackTop(&obj->pop);
    }
}

bool myQueueEmpty(MyQueue* obj) {
    assert(obj);

    return StackEmpty(&obj->push) && StackEmpty(&obj->pop);
}

void myQueueFree(MyQueue* obj) {
    assert(obj);

    free(obj->push.data);
    free(obj->pop.data);
    free(obj);

}

四、设计循环队列

题目描述

LeetCode.622 设计循环队列
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

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

解题思路

在这里插入图片描述
用数组实现循环队列，循环队列如上图所示，其长度是固定的，当循环队列存满时就不能存放新的数据了；给两个标记front和back，分别用来标记循环队列的第一个元素和最后一个元素；当 back 的下一个元素等于 front 时，循环队列存满就不能再存放数据了；当 bakc 等于 front 时，循环队列为空。删除队列元素只需要对 front 减一即可。

代码实现

typedef struct {
    int* data;
    int front;
    int back;
    int size;
    int capacity;
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    //return ((back - front + obj->capacity) % obj->capacity);
    if(obj->size)
    {
        return false;
    }
    else
    {
        return true;
    }
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->capacity ;
}

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    int* tmp = (int*)malloc(sizeof(int)*k);
    if(tmp == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    obj->data = tmp;
    obj->front = obj->back = obj->size = 0;
    obj->capacity = k;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->data[obj->back] = value;
    obj->back++;
    if(obj->back == obj->capacity)
    {
        obj->back = 0;
    }
    obj->size++;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    if(obj->front == obj->capacity)
    {
        obj->front =  0;
    }
    obj->size--;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->data[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->data[(obj->back - 1 + obj->capacity) % obj->capacity];
}



void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->data);
    free(obj);
}

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

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

相关文章

freemarker+yml介绍 以及freemarker与JSP的区别

freemarker+yml介绍 以及freemarker与JSP的区别

目录 1. freemarker介绍 2. freemarker使用步骤 2.1 在pom.xml引入freeMarker的依赖包 2.2 在springboot中添加freemarker配置 2.3 编写模板文件*.ftl(当做jsp使用即可) ​编辑 2.4 访问控制器后进行页面跳转 3. freemarker常用语法 3.1 取值 3.2 条件 3.3 循环 3…
阅读更多...
超赞：不愧是“阿里内部Redis学习笔记”从头到尾，全是精华

超赞：不愧是“阿里内部Redis学习笔记”从头到尾，全是精华

近几年，随着移动互联网的飞速发展，我们享受着整个社会的技术进步带来的便利，但同时也给从业者带来了如何保证项目的高并发、低延时的技术挑战，相应的互联网技术也随之发生了重大变革，NoSQL技术得到了蓬勃的发展。 Red…
阅读更多...
【JavaSE】抽象类与接口

【JavaSE】抽象类与接口

文章目录抽象类的概念抽象类的语法抽象类的特性接口的概念接口的语法接口的特性多接口的实现接口的继承抽象类的概念 什么是抽象类呢？我们先来看一个例子：一个父类是动物类，两个子类一个狗狗类，一个猫猫类。 Animal中有一个dark…
阅读更多...
有趣的statement stack

有趣的statement stack

引子 在使用events_statements_current的过程中发现，同一线程在同一时刻，可能有多条记录，与直观感觉不太一样，于是跟踪了一下内部实现，有了本文。 STATEMENT STACK的定义 STATEMENT STACK 是events_statements_curr…
阅读更多...
Linux基础内容（11）—— 进程理解

Linux基础内容（11）—— 进程理解

目录 1.进程状态 1.只针对操作系统的宏观概念 2.Linux的进程状态 1.运行状态(R) 2.休眠状态(S) 3.暂停状态/浅度睡眠状态(T) 4.深度睡眠状态(D) 5.当前进程正在被追踪(t) 6.死亡状态(X) 7.僵尸状态(Z) 8.孤儿进程 2.进程的优先级 1.优先级定义 2.Linux的优先级表现…
阅读更多...
matlab 小数据法求liyapunov指数

matlab 小数据法求liyapunov指数

1、内容简介 略 625-可以交流、咨询、答疑 2、内容说明 摘 要：从 Lyapunov 指数的定义出发：在常用计算最大 Lyapunov 指数的基础上，将自相关法和 G-P 法应用于小数 据量法中，得到了一种计算最大 Lyapunov 指数的改进小数据量法…
阅读更多...
推特的算法规则你知道多少？

推特的算法规则你知道多少？

如果玩Twitter却不明白Twitter算法是如何运作的，就如同贸然出征却忘了带上武器。 社交媒体的算法正在成为你在平台中所见内容的核心，当知晓了该平台的推荐算法，自然也就知道发布什么样的内容有助于被更多用户看到。因此，了解了算…
阅读更多...
Spring之依赖注入

Spring之依赖注入

文章目录前言一、set注入1.1 UserDao类：1.2 UserService类：1.3 spring.xml配置文件：1.4 测试类：1.5 执行结果：二、构造方法注入2.1 UserDao2.2 UserService类：1.3 spring.xml配置文件：2.4 测试类…
阅读更多...
微服务改造过程中那些必须重视的问题

微服务改造过程中那些必须重视的问题

“微服务”近几年尤其火热，各大厂都在进行微服务化改造和微服务建设，想享受微服务化带来的好处以便对自己的系统进行改造。分布式实验室特约记者李鹏采访了广州轻阅科技系统架构师陈珙，就微服务与SOA的区别与联系、企业引入微服务会带来的问题…
阅读更多...
Vue2：官方路由 Vue-Router 3.x

Vue2：官方路由 Vue-Router 3.x

前端路由 前端路由：根据不同的url地址，页面上展示不同的内容（根据url地址的不同分发到不同的组件。） SPA 介绍 spa 是 single page application 简写，意思是单页面应用程序。Vue 适合开发 spa 类型的项目。 优点&…
阅读更多...
Django 所带的用户auth_user的坑点，authenticate()校验一直为None，校验与创建所遇到的问题整理与解决

Django 所带的用户auth_user的坑点，authenticate()校验一直为None，校验与创建所遇到的问题整理与解决

整理一下django中用户模块自定义model后登录的一些问题： 网上的报错解决不是万能方案，主要还是要自主分析原因，有的是有用但是导包之类的也要看清楚因为自己修改了所以有所变得，不自定义的话又不太好用。 在项目初期决定使用auth…
阅读更多...
鸡卵白蛋白偶联脂多糖(OVA-LPS)，麻黄多糖修饰卵白蛋白(PB-OVA)

鸡卵白蛋白偶联脂多糖(OVA-LPS)，麻黄多糖修饰卵白蛋白(PB-OVA)

产品名称：鸡卵白蛋白偶联脂多糖 英文名称：OVA-LPS 用途：科研 状态：固体/粉末/溶液 产品规格：1g/5g/10g 保存：冷藏 储藏条件：-20℃ 储存时间：1年 脂多糖（Lipopolysacchar…
阅读更多...
第四站：数组

第四站：数组

目录 一、一维数组的创建和初始化 1.数组的创建 （1）基本定义，创建方式 （2）经典的错误标准的零分 2.数组的初始化 3.一维数组的使用 4.一维数组在内存中的存储 二、二维数组的创建和初始化 1.二维数组的创建 2…
阅读更多...
SpringBoot SpringBoot 开发实用篇 2 配置高级 2.2 松散绑定

SpringBoot SpringBoot 开发实用篇 2 配置高级 2.2 松散绑定

SpringBoot 【黑马程序员SpringBoot2全套视频教程，springboot零基础到项目实战（spring boot2完整版）】 SpringBoot 开发实用篇 文章目录SpringBootSpringBoot 开发实用篇2 配置高级2.2 松散绑定2.2.1 问题引入2.2.2 松散绑定2.2.3 小结2 配…
阅读更多...
MySQL学习笔记：模型2

MySQL学习笔记：模型2

序言 《MySQL45讲》 为什么表数据删除一半，表文件大小不变？ 表数据既可以存在共享表空间里，也可以是单独的文件。这个行为是由参数 innodb_file_per_table 控制的： 这个参数设置为 OFF 表示的是，表的数据放在系统共…
阅读更多...
错字修改 | 布署1个中文文文本拼蟹纠错模型

错字修改 | 布署1个中文文文本拼蟹纠错模型

内容一览：中文文本错误的种类之一为拼写错误，本篇文章为利用 BART 预训练方法实现中文文本纠错功能的模型部署教程。 关键词：BART 中文拼写纠错 NLP 本文首发自微信公众号：HyperAI超神经 中文文本错误3大障碍：拼写、语…
阅读更多...
Chapter9.1：线性系统的状态空间分析与综合(上)

Chapter9.1：线性系统的状态空间分析与综合(上)

此系列属于胡寿松《自动控制原理题海与考研指导》(第三版)习题精选，仅包含部分经典习题，需要完整版习题答案请自行查找，本系列属于知识点巩固部分，搭配如下几个系列进行学习，可用于期末考试和考研复习。 自动控制原理(…
阅读更多...
第六节.常用Linux命令—chmod修改目录权限，组管理，用户管理

第六节.常用Linux命令—chmod修改目录权限，组管理，用户管理

第六节.常用Linux命令—chmod修改目录权限，组管理，用户管理 1. chmod：可以修改用户/文件/目录的权限 1).命令格式: chmod(代表增加权限)/-(代表减少权限) r(可读权限)w(可写权限)x(可执行权限) 文件名/目录名 2.组管理： 1).终端…
阅读更多...
年产5000吨饼干食品加工厂的工艺设计

年产5000吨饼干食品加工厂的工艺设计

目 录 摘 要 I Abstract II 第1章 绪论 1 1.1概述 1 1.2饼干的特点 1 1.2.1适宜大规模生产 1 1.2.2容易消化吸收 1 1.2.3食用方便 1 1.2.4营养价值高 2 1.3设计依据 2 1.4 设计范围 2 1.4.1 一般部分 2 1.4.2 重点部分 2 1.4.3 图纸 3 1.5设计指导思想 3 1.5.1 指导思想 3 1.5.…
阅读更多...
org.activiti.validation.validator

org.activiti.validation.validator

org.activiti.validation.validator目录概述需求：设计思路实现思路分析1.ActivitiEventListenerValidator3.AssociationValidator4.validateAtLeastOneExecutable5.DataObjectValidator拓展实现参考资料和推荐阅读Survive by day and develop by night. talk for im…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023