数据结构之栈与队列

一.栈

1.定义：一种线性表，只允许在固定的一端进行删除和插入数据的操作，该端叫栈底，另一端叫栈顶

2.特点：先进后出

注：栈中元素出栈是一对多的(他虽然满足先进后出但是我们可以在pop数据前先获取栈顶元素并打印再pop，这样就可能改变数据在屏幕上出现的顺序)

3.思路：可以用数组实现，也可以用链表实现

数组实现更简单，链表实现较为复杂，下面小编将从两方面解释不选择链表实现的原因

1>若选择单链表，在进行删除操作时，我们不好解决栈顶先前移一位的问题

2>若选择双向链表，将占用过多的内存

4.代码实现(以数组实现栈为例)：

(1)栈的结构体定义：包含数组指针，栈顶的位置，有效空间容量

typedef int STDatatype;
typedef struct Stack
{
	STDatatype* arr;
	int top;//栈顶
	int capacity;//有效空间容量
}ST;

(2)栈的初始化：将栈顶初始化为0：表示栈顶指向最后一个数据的下一个

                          将栈顶初始化为-1：表示栈顶指向最后一个数据所在位置

//栈的初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->arr = NULL;
	//top指向栈顶后的一个元素,此时top等值于有效数据个数
	ps->top = 0;
	ps->capacity = 0;
}

(3)栈的销毁

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

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

(4)插入数据/入栈：先判断是否需要增容，再插入数据

//入栈
void STPush(ST* ps, STDatatype x)
{
	assert(ps);
	//判断是否需要增容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity * 2==0 ? 4 : ps->capacity*2;
		STDatatype* tmp = (STDatatype*)realloc(ps->arr, sizeof(STDatatype) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
	ps->arr[ps->top] = x;
	ps->top++;
}

(5)删除数据/出栈：先判断数组是否为空，再将top--即完成删除

//出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);

	ps->top--;
}

(6)获取栈顶元素

//获取栈顶数据
STDatatype STTop(ST* ps)
{
	assert(ps);
	return ps->arr[ps->top-1];
}

(7)判断栈是否为空：若top==0则为空

//判断栈是否为空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

(8)栈中有效数据个数

//栈的有效数据个数
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

二.队列

1.定义：一种线性表，只允许在一端(队尾)进行数据插入，在另一端(队头)进行数据删除

2.特点：先进先出

注：队列的数据出队列时是一对一的

3.思路：可以用数组实现，也可以用链表实现 

单链表实现更简单，数组实现较为复杂，是因为在使用数组实现时，进行删除数据不好记录下一次该删除数据的位置

4.代码实现(以单链表实现队列为例)：

(1)队列的节点定义：指向下一个节点的指针，存储数据的数值

    队列的结构体定义：队列的头指针，尾指针，队列有效数据的个数

typedef int QueueDataType;

typedef struct QueueNode
{
	QueueDataType val;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

(2)队列的初始化

//队列的初始化
void QueueInit(Queue* pq)
{
	assert(pq);

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

(3)队列的销毁：先逐个销毁队列的节点，再销毁队列

//队列的销毁
void QueueDestory(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* Next = cur->next;
		free(cur);
		cur = Next;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

(4)插入数据：为该数据开辟一个新节点，若原队列中有数据则让尾指针向后走一步，若无则头尾    指针均指向该新节点

//队尾入数据
void QueuePush(Queue* pq, QueueDataType x)
{
	//开辟一个新节点
	QNode* node = (QNode*)malloc(sizeof(QNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return;
	}
	node->val = x;
	node->next = NULL;

	//队列中没有节点
	if (pq->tail == NULL)
	{
		pq->head = node;
		pq->tail = node;
	}
	else
	{
		pq->tail->next = node;
		pq->tail = node;
	}

	pq->size++;
}

(5)删除数据：删除头指针指向的节点，并让头指针向后走一步，若只有一个节点删除后需将尾指针置空

//队头出数据
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);

	QNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}

	pq->size--;
}

(6)获取队头元素

//获取队头数据
QueueDataType QueueFront(Queue* pq)
{
	assert(pq);
	return pq->head->val;
}

(7)获取队尾元素

//获取队尾数据
QueueDataType QueueBack(Queue* pq)
{
	assert(pq);
	return pq->tail->val;
}

(8)判断队列是否为空

//判断队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

(9)队列的大小

//获取队列有效数据个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

三.栈与队列的相互转化

1.用栈实现队列

. - 力扣（LeetCode）

(1)思路：栈：先进后出，队列：先进先出

               创建两个栈实现队列中数据的删除

(2)解题方法：

1>自己实现栈

2>定义一个队列结构体包含两个栈

3>队列的创建：为队列结构体malloc一块空间，防止出函数时结构体被销毁

4>队列的销毁：先销毁两个栈，再销毁队列

5>队尾插数据：当两栈均为空栈时：随便在哪个空栈的栈顶插入数据均可

                          当有一个栈不为空时：在非空栈的栈顶插入数据

6>队头删数据：将非空栈的前size-1个数据导入空栈中，再删除队头的数据。此时对下次删除来说栈中数据顺序是错乱的，故还需要将原空栈的数据导回原非空栈中。

7>判断队列为空：当两个栈均为空时，队列为空

8>获取队尾数据：即非空栈的栈顶数据

(3)代码实现：

typedef int STDatatype;
typedef struct Stack
{
	STDatatype* arr;
	int top;//栈顶
	int capacity;//有效空间容量
}ST;

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

//栈的销毁
void STDestory(ST* ps);

//入栈
void STPush(ST* ps, STDatatype x);

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

//获取栈顶数据
STDatatype STTop(ST* ps);

//判断栈是否为空
bool STEmpty(ST* ps);

//栈的有效数据个数
int STSize(ST* ps);

//栈的初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->arr = NULL;
	//top指向栈顶后的一个元素,此时top等值于有效数据个数
	ps->top = 0;
	ps->capacity = 0;
}

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

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

//入栈
void STPush(ST* ps, STDatatype x)
{
	assert(ps);
	//判断是否需要增容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity * 2==0 ? 4 : ps->capacity*2;
		STDatatype* tmp = (STDatatype*)realloc(ps->arr, sizeof(STDatatype) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
	ps->arr[ps->top] = x;
	ps->top++;
}

//出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);

	ps->top--;
}

//获取栈顶数据
STDatatype STTop(ST* ps)
{
	assert(ps);
	return ps->arr[ps->top-1];
}

//判断栈是否为空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

//栈的有效数据个数
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

typedef struct {
    ST st1;
    ST st2;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* pq=(MyQueue*)malloc(sizeof(MyQueue));
    STInit(&(pq->st1));
    STInit(&(pq->st2));
    return pq;
}

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    if(!STEmpty(&(obj->st1)))
    {
        STPush(&(obj->st1),x);
    }
    else
    {
        STPush(&(obj->st2),x);
    }
    
}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    ST* empty=&(obj->st1);
    ST* noempty=&(obj->st2);
    if(!STEmpty(&(obj->st1)))
    {
        empty=&(obj->st2);
        noempty=&(obj->st1);
    }
    while(STSize(noempty)>1)
    {
        STPush(empty,STTop(noempty));
        STPop(noempty);
    }
    STDatatype ret=STTop(noempty);
    STPop(noempty);
    //将noempty的数据导回empty,保证下次pop时数据顺序
    while(STSize(empty)>0)
    {
        STPush(noempty,STTop(empty));
        STPop(empty);
    }
    return ret;
}

int myQueuePeek(MyQueue* obj) {
    if(!STEmpty(&(obj->st1)))
    {
        return obj->st1.arr[0];
    }
    else
    {
        return obj->st2.arr[0];
    }
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&(obj->st1)) && STEmpty(&(obj->st2));
}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    STDestory(&(obj->st1));
    STDestory(&(obj->st2));
    free(obj);
    obj=NULL;
}

2.用队列实现栈

. - 力扣（LeetCode）

(1)思路：栈：先进后出，队列：先进先出

               创建两个队列实现栈中数据的删除

(2)解题方法：

1>自己实现队列

2>定义一个栈结构体包含两个队列

3>栈的创建：为栈结构体malloc一块空间，防止出函数时结构体被销毁

4>栈的销毁：先销毁两个队列，再销毁栈

5>入栈：当两队列均为空队列时：随便在哪个空队列的队尾插入数据均可

                          当有一个队列不为空时：在非空队列的队尾插入数据

6>出栈：将非空队列的前size-1个数据导入空队列中，再删除栈顶元素。

7>判断栈为空：当两个队列均为空时，栈为空

8>获取栈顶数据：即非空队列的队尾元素

(3)代码实现：

typedef int QueueDataType;

typedef struct QueueNode
{
	QueueDataType val;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

//队列的初始化
void QueueInit(Queue* pq);

//队列的销毁
void QueueDestory(Queue* pq);

//队尾入数据
void QueuePush(Queue* pq, QueueDataType x);

//队头出数据
void QueuePop(Queue* pq);

//获取队头数据
QueueDataType QueueFront(Queue* pq);

//获取队尾数据
QueueDataType QueueBack(Queue* pq);

//获取队列有效数据个数
int QueueSize(Queue* pq);

//判断队列是否为空
bool QueueEmpty(Queue* pq);

//队列的初始化
void QueueInit(Queue* pq)
{
	assert(pq);

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

//队列的销毁
void QueueDestory(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* Next = cur->next;
		free(cur);
		cur = Next;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

//队尾入数据
void QueuePush(Queue* pq, QueueDataType x)
{
	//开辟一个新节点
	QNode* node = (QNode*)malloc(sizeof(QNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return;
	}
	node->val = x;
	node->next = NULL;

	//队列中没有节点
	if (pq->tail == NULL)
	{
		pq->head = node;
		pq->tail = node;
	}
	else
	{
		pq->tail->next = node;
		pq->tail = node;
	}

	pq->size++;
}

//队头出数据
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);

	QNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}

	pq->size--;
}

//获取队头数据
QueueDataType QueueFront(Queue* pq)
{
	assert(pq);
	return pq->head->val;
}

//获取队尾数据
QueueDataType QueueBack(Queue* pq)
{
	assert(pq);
	return pq->tail->val;
}

//获取队列有效数据个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

//判断队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

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


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

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

int myStackPop(MyStack* obj) {
    Queue* empty=&(obj->q1);
    Queue* noempty=&(obj->q2);
    if(!QueueEmpty(&(obj->q1)))
    {
        empty=&(obj->q2);
        noempty=&(obj->q1);
    }
    //把前size-1个数据移到空队列中
    while(QueueSize(noempty)>1)
    {
        QueuePush(empty,QueueFront(noempty));
        QueuePop(noempty);
    }
    QueueDataType top=QueueFront(noempty);
    QueuePop(noempty);
    return top;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&(obj->q1)))
    {
        return QueueBack(&(obj->q1));
    }
    else
    {
        return QueueBack(&(obj->q2));
    }
}

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

void myStackFree(MyStack* obj) {
    assert(obj);
    QueueDestory(&(obj->q1));
    QueueDestory(&(obj->q2));
    free(obj);
    obj=NULL；
}

四.循环队列

. - 力扣（LeetCode）

1.定义：一种线性结构，基于先进先出原则，将队尾与队头连接起来构成循环

2.特点：有限空间，保证先进先出，从重复使用

3.思路：可以用数组实现，也可以用链表实现

用数组实现较为简单，用链表实现比较困难，下面小编将从两个角度来解释原因：

1>若使用单链表，在删除数据时不好获取待删除数据的前一个节点的位置，无法实现队尾的改变

2>若使用双向链表，占用内存太大，而且此时在判空判满时需要比较两个节点的地址比较麻烦

4.代码实现(以数组实现为例)：

(1)循环队列的结构体定义：数组指针，队头的下标，队尾下一个数据的下标，空间的大小

typedef struct {
    int* a;
    int head;//指向头
    int rear;//指向尾的下一个
    int k;//空间大小
} MyCircularQueue;

(2)循环队列的创建：

1>为循环队列malloc一块空间，防止出函数时，结构体被销毁

2>由于rear指向队尾的下一个数据，若直接开辟指定大小的空间，在插入最后一个数据时，rear会越界访问，此时我们称该情况为假溢出现象，为了解决假溢出我们可以采取以下两种措施

【1】为数组多开一块空间

【2】

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pc=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    
    //多开一块空间，解决假溢出问题
    pc->a=(int*)malloc(sizeof(int)*(k+1));
    pc->head=0;
    pc->rear=0;
    pc->k=k;
    return pc;
}

(3)循环队列的销毁：先销毁为数组开辟的空间，再销毁循环队列

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a=NULL;
    free(obj);
    obj=NULL;
}

(4)循环队列的判空：

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);
    //头与尾的下一个指向同一位置即为空
    return obj->head==obj->rear;
}

(5)循环队列的判满：

bool myCircularQueueIsFull(MyCircularQueue* obj) {

    assert(obj);
    //尾的下一个和头指向的位置相同即为满
    return obj->head==(obj->rear+1)%(obj->k+1);
}

(6)循环队列插入数据：在队尾插入数据，让rear向后走一步，为了避免rear++后越界访问，需要将自增后的rear模上k+1，使其在有效下标内且可以完成循环

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->rear]=value;
    obj->rear++;
    obj->rear%=(obj->k+1);
    return true;
}

(7)循环队列删除数据：删除队头数据，让head向后走一步，为了避免head++后越界访问，需要将自增后的head模上k+1，使其在有效下标内且可以完成循环(原理同上，就不再赘述了)

ool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }

    obj->head++;
    obj->head%=(obj->k+1);
    return true;
}

(8)获取队尾元素：


int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->rear==0?obj->a[obj->k]:obj->a[obj->rear-1];
    }
}

(9)获取队头元素：

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->head];
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

React 第三十二章 虚拟DOM

React 第三十二章 虚拟DOM

面试题：什么是虚拟DOM？其优点有哪些？ 标准且浅显的答案 虚拟dom本质上就是一个普通的 JS 对象，用于描述视图的界面结构 虚拟 DOM 最早是由 React 团队提出来的，因此 React 团队在对虚拟 DOM 的定义上面有绝对的话语权。…
阅读更多...
ASP.NET在线二手交易系统的设计与实现

ASP.NET在线二手交易系统的设计与实现

摘 要 随着当今社会信息技术的进步，基于互联网的各种应用日益受到了人们的重视，二手商品的重新利用也逐渐被人们关注，二手交易系统就在这种形势下产生了，它利用网络，改变了人们的购物方式。 本文是基于现代二手交易…
阅读更多...
醉了，面个功能测试，还问我Python装饰器

醉了，面个功能测试，还问我Python装饰器

Python 装饰器是个强大的工具，可帮你生成整洁、可重用和可维护的代码。某种意义上说，会不会用装饰器是区分新手和老鸟的重要标志。如果你不熟悉装饰器，你可以将它们视为将函数作为输入并在不改变其主要用途的情况下扩展其功能的函数。装饰器可…
阅读更多...
Git 分支命令操作详解

Git 分支命令操作详解

目录 1、分支的特点 2、分支常用操作 3、分支的使用 3.1、查看分支 3.2、创建分支 3.3、修改分支 3.4、切换分支 3.5、合并分支 3.6、产生冲突 3.7、解决冲突 3.8、创建分支和切换分支说明 1、分支的特点 同时并行推进多个功能开发，提高开发效率。各个分…
阅读更多...
[ROS 系列学习教程] 建模与仿真 - URDF 建模实践

[ROS 系列学习教程] 建模与仿真 - URDF 建模实践

ROS 系列学习教程(总目录) 本文目录 一、机器人结构组成二、新建功能包三、编写launch文件四、创建底盘五、添加轮子六、添加其他部件七、解决部分实体位于地面以下的问题 前文介绍了URDF建模与URDF语法，接下来介绍怎么使用URDF从零构建一个机器人模型并在rviz中显示…
阅读更多...
网络爬虫安全：90后小伙，用软件非法搬运他人原创视频被判刑

网络爬虫安全：90后小伙，用软件非法搬运他人原创视频被判刑

目录 违法视频搬运软件是网络爬虫 如何发现偷盗视频的爬虫？ 拦截违法网络爬虫 央视《今日说法》栏目近日报道了一名程序员开发非法视频搬运软件获利超700多万，最终获刑的案例。 国内某知名短视频平台报警称，有人在网络上售卖一款视频搬运…
阅读更多...
2024年最新最全面的软件测试面试题（四）

2024年最新最全面的软件测试面试题（四）

1、在项目中如何保证软件质量? 项目质量不仅仅是某个人或某个团队来保障的，而是整个团队一起努力的结果，因此，在公司级别需要 有一个规范的项目流程。 产品，保证迭代过程中的产品逻辑，对于可能的兼容，升…
阅读更多...
C++列表实现

C++列表实现

文章目录 一、listView相关内容主要思想实例全部代码 二、QTreeView 一、listView 相关内容 QAbstractItemModel：一个抽象的类，为数据项模型提供抽象的接口，常见的的数据模型列如：QStringListModel,QStandardItemMode,QDirModel…
阅读更多...
(实测验证)Gitee代码托管尝试（一）——克隆/下载

(实测验证)Gitee代码托管尝试（一）——克隆/下载

一、登录 Gitee（码云）代码托管平台： Gitee - 基于 Git 的代码托管和研发协作平台 新建个人账户如下： 二、SSH 公钥设置 1、在git安装目录打开“git-cmd.exe”; 2、通过命令 ssh-keygen 生成 SSH Key： ssh-keygen …
阅读更多...
社区服务用工具建立与居民的强关系

社区服务用工具建立与居民的强关系

在数字化时代的浪潮下，社区服务不再局限于传统的面对面交流模式，而是借助互联网医疗健康服务应用，尤其是智慧康养服务平台，构建起了与居民之间更为紧密、便捷的联系。这种新型的社区服务模式，不仅提升了服务效率&#…
阅读更多...
PDK安装及简介

PDK安装及简介

目录 PDK简介 pdk安装 Standard Cell Library简介 IO Library简介 PDK简介 PDK：全称Process Design Kit，是工艺设计工具包的缩写，是制造和设计之间的沟通桥梁，是模拟电路设计的起始点。 具体来说，PDK是代工厂(FAB…
阅读更多...
webhook 和 API：你了解吗

webhook 和 API：你了解吗

Webhooks 是许多 API 的补充。通过设置 webhook 系统，系统 B 可以注册接收有关系统 A 某些更改的通知。当更改发生时，系统 A 推送 更改到系统 B，通常是以发出 HTTP POST 请求的形式。 Webhooks 旨在消除或减少不断轮询数据的需要。但根据我的…
阅读更多...
【Axure原型分享】动态伸缩组织架构图

【Axure原型分享】动态伸缩组织架构图

今天和大家分享动态伸缩组织架构图图原型模板，我们可以通过点击加减按钮来展开或收起子内容，具体效果可以点击下方视频观看或者打开预览地址来体验 【原型效果】 【Axure高保真原型】动态伸缩组织架构图 【原型预览含下载地址】 https://axhub.im/ax9/…
阅读更多...
AI大模型探索之路-训练篇23：ChatGLM3微调实战-基于P-Tuning V2技术的实践指南

AI大模型探索之路-训练篇23：ChatGLM3微调实战-基于P-Tuning V2技术的实践指南

系列篇章💥 AI大模型探索之路-训练篇1：大语言模型微调基础认知 AI大模型探索之路-训练篇2：大语言模型预训练基础认知 AI大模型探索之路-训练篇3：大语言模型全景解读 AI大模型探索之路-训练篇4：大语言模型训练数据集概…
阅读更多...
【计算机毕业设计】springboot成都奥科厨具厂产品在线销售系统设计与实现

【计算机毕业设计】springboot成都奥科厨具厂产品在线销售系统设计与实现

时代在飞速进步，每个行业都在努力发展现在先进技术，通过这些先进的技术来提高自己的水平和优势，成都奥科厨具厂产品在线销售系统当然不能排除在外。成都奥科厨具厂产品在线销售系统是在实际应用和 软件工程的开发原理之上，运用jav…
阅读更多...
《网探》：网络安全，你不得不学的知识。

《网探》：网络安全，你不得不学的知识。

有没有一些亲戚朋友联系过你，让你和他们一起参与某一项投资？ 他们会告诉你，只要投入少部分钱就可以成为会员，今后每个月参与分红，投资的钱越多，分红越多。 而且要是你能成功带一定数量的人加入他们&#…
阅读更多...
代码+视频，R言语处理数据中的缺失值

代码+视频，R言语处理数据中的缺失值

在SCI论文中，我们不可避免和缺失数据打交道，特别是在回顾性研究，对于缺失的协变量（就是混杂因素），我们可以使用插补补齐数据，但是对于结局变量和原因变量的缺失，我们不能这么做。部分…
阅读更多...
网络审计：为什么定期检查您的网络很重要

网络审计：为什么定期检查您的网络很重要

在数字化时代，网络安全成为组织和个人必须面对的重要挑战。网络审计是一种关键的安全措施，通过定期检查和评估网络系统的安全性，帮助发现潜在的安全漏洞和弱点，从而防止数据泄露和其他安全威胁。本文将介绍网络审计的重要性&#…
阅读更多...
不干人事的表达式：(void)0

不干人事的表达式：(void)0

assert是C语言的一个宏。在<assert.h>中可以找到它的定义&#xff1a; #ifdef NDEBUG#define assert(_Expression) ((void)0) #else /* !defined (NDEBUG) */// 省略... #endif /* !defined (NDEBUG) */ 其用法在“捕捉错误的assert”一文中已有说明。 决定assert是否…
阅读更多...
【计算机毕业设计】springboot超市在线销售系统的设计与实现

【计算机毕业设计】springboot超市在线销售系统的设计与实现

当今社会已经步入了科学技术进步和经济社会快速发展的新时期&#xff0c;国际信息和学术交流也不断加强&#xff0c; 计算机技术对经济社会发展和人民生活改善的影响也日益突出&#xff0c;人类的生存和思考方式也产生了变化。传统超市在线销售采取了人工的管理方法&#xff0c…
阅读更多...
最新文章

Copyright @ 2022~2023