与队列和栈相关的【OJ题】

已于 2024-05-13 00:12:17 修改
阅读量884 收藏 32
点赞数 37
分类专栏： #c语言进阶(数据结构) 文章标签： c语言 数据结构
于 2024-05-11 01:26:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SWsunlight/article/details/138649387
版权

32becbd905a5411d8b4827566ec69ec4.jpeg

✨✨✨专栏：数据结构     

          🧑‍🎓个人主页：SWsunlight

5d474da1272640588145b2285d51bdf6.gif

目录

 一、用队列实现栈：

1、2个队列的关联起来怎么由先进先出转变为先进后出：（核心）

 2、认识各个函数干嘛用的：

3、代码实现：

二、用栈实现队列：

1、题目:

2、思路：

 3、代码：

 三、设计循环队列:

1、题目：

 2、思路：

​编辑

3、代码：

补充：思路2、用链表来实现：比起数据很快

 一、用队列实现栈：

内容如下：

654d26f0b2d54dc5863caf4f8aeb162f.png

 2个队列实现栈：：首先考虑的是  栈的规则：先进后出（后进先出）

                                                   队列的规则：先进先出

1、2个队列的关联起来怎么由先进先出转变为先进后出：（核心）

e59c31563ecf4ca6834c8ea8acaba4c1.png

 如上图，外围框架（虚构的，为了更好理解，让他具体化）就是我要实现的栈，而我要通过2个队列来实现栈，是不是是可以让小球先走上面的“通道”进去，全部小球（元素）进入上“通道”中，此时我排在通道最后的小球（元素）就是我要出栈的第一个数据。

如下图：2号球要第一个出栈，我们发现下“通道”是空的，那么我让2号球前面的球离开这个“通道”去到下面的通道，上通道就会剩下一个2号球，此时取2号球顺利的第一个走出去，就相当于栈的Top(将后进的元素取出)

547bcd2e0e4648da913d69dc63216c8b.png

1125b438160c4a6c9c9f4f606d909ecf.png 反复进行，就可以实现栈了，(队尾的元素能出栈，其他位置得绕着2个通道来回转（有点像明知她(他)不爱你，你还是要困死再这颗树），只有自己在成为队尾了（心灰意冷了），才会幡然醒悟（不能再一直停留再原地绕圈了，要向前看啦)

 2、认识各个函数干嘛用的：

可能只是对我而言 

我已经标好了，各个函数的功能：知道功能就好实现了

0d3dd4f7532b4948a150a2dc1a87a1ef.png

这个结构体的成员放2个队列即可：

 cae2ea53b23f43639dfcbb60bf923c8d.png

1c407e0554a442beab0e45d4de98d083.png

 结构体MyStack嵌套2个（队列）结构体（Queue）——>Queue的结构体在嵌套节点的结构体27709a53582f41e286b913b818744c67.png

如下：头节点后面还会链接更多的尾节点

1b07bf0d9a4940508dd3fa335af91bf9.png

3、代码实现：

将之前写队列的代码复制过来直接可以用了

typedef int QUDataType;
//节点
typedef struct QueueNode{
	
	QUDataType a;
	//一定要用指针，不然结构体的大小就无法确定了
	struct QueueNode *next;
}QuNode;
//再建立一个保存头和尾的结构体
typedef struct Queue {
	QuNode* head;
	QuNode* tail;
	int size;
}Queue;


//初始化头尾节点
void QuInto(Queue* q)
{
	//不能传空指针  即（q=NULL）
	assert(q);
	q->head = NULL;
	q->tail = NULL;
	q->size = 0;
}

//尾插(2种情况：1.头尾都为NUL  2.又数据入队列了)
void QuPush(Queue* q, QUDataType x)
{
	//申请空间
	QuNode* newnode = (QuNode*)malloc(sizeof(QuNode));
	//判空
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->a = x;
	newnode->next = NULL;//节点创建完成
	//判断尾的位置
	if (q->tail == NULL)
	{
		q->head = q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}

//头删(删除到尾以后，就不能再删了)
void QuPop(Queue* q)
{
	assert(q);
	//头的位置也不能为空
	assert(q->size!=0);
	//此时数据个数为1（也就是最后一个节点）
	if (q->head->next==NULL)
	{
		free(q->head);
		q->head = q->tail = NULL;
	}
	else//q->head != q->tail；
	{
		QuNode* next = q->head->next;
		free(q->head);
		q->head = next;
	}
	
	//数据个数也要减去
	q->size--;
	
}

//判空
bool QuEmpty(Queue* q)
{
	assert(q);
	//头尾都相等时到达同一个位置，此时就为真，其他的情况都为假；
	return q->size==0;
}

//取头数据
QUDataType QuFront(Queue* q)
{
	assert(q);
	assert(q->head);
	return q->head->a;
}

//取尾数据
QUDataType QuBack(Queue* q)
{
	assert(q);
	//队尾都为空了，已经没数据了
	assert(q->tail);
	return q->tail->a;
}
//数据个数
int QuSize(Queue* q)
{
	assert(q);
	return q->size;
}

//销毁空间(写进数据，想要一次性释放完就来用)
void QuDestroy(Queue* q)
{
	assert(q);
	QuNode* cur = q->head;
	while (cur)
	{
		QuNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->head = q->tail =NULL;
	q->size = 0;
}

//2个队列
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

//初始化
MyStack* myStackCreate() {
    MyStack*pts = (MyStack*)malloc(sizeof(MyStack));
    if(pts==NULL)
    {
        perror("malloc");
        //exit(1);
        return NULL;
    }
    QuInto(&pts->q1);
    QuInto(&pts->q2);
    return pts;  
}
//插入
void myStackPush(MyStack* obj, int x) {
    //判空插入,将数据插入不为空的队列
    if(!QuEmpty(&obj->q1))
    {
        QuPush(&obj->q2,x);
    }
    else
    {
        QuPush(&obj->q2,x);
    }
}
//删除并取出top元素
int myStackPop(MyStack* obj) {
    //假设法：no存不为空
    Queue* noEmpty = &obj->q1;
    Queue* empty = &obj->q2;
    if(!QuEmpty(empty))
    {
        noEmpty = &obj->q2;
        empty = &obj->q1;
    }
    //我们要让size-1个数据去到那条空通道
    while(QuSize(noEmpty)>1)
    {
        //头删，所以取头
        int x = QuFront(noEmpty);
        QuPop(noEmpty);
        //将其数据存到size-1个数据存入空道
        QuPush(empty,x);
    }
    //随便头还是尾取，因为此时这通道只有最后一个元素了
    int top =QuFront(noEmpty);
    QuPop(noEmpty);
    return top;
}
//直接取top元素
int myStackTop(MyStack* obj) {
    //不要删除，只是取元素，那么取不为空的通道的队尾元素（因为根据栈的原则：先出的是队尾元素）
    if(!QuEmpty(&obj->q1))
    {
        return QuBack(&obj->q1);
    }
    else
    {
        return QuBack(&obj->q2);
    }
}
//判空
bool myStackEmpty(MyStack* obj) {
    //2个都是空同通道则为真，否则为假
    return QuEmpty(&obj->q1)&&QuEmpty(&obj->q2);
}
//销毁
void myStackFree(MyStack* obj) {
    QuDestroy(&obj->q1);
    QuDestroy(&obj->q2);
    free(obj);
    obj = NULL;
}

 关于销毁：要先从小（从内向外）的开始，我们应该先从q1和q2进行销毁，在销毁obj

obj申请的空间是为2个队列开辟的，2个队列申请的空间又是为里面的单链表开辟的，你直接销毁大哥，小弟起步就是群龙无首，变成了“野狗”

二、用栈实现队列：

1、题目:

223cd369447d0410cad2cce24a6a26447.png

2、思路：

和上面思路大差不差

先画图：和上面说的类似，不做赘述

b69501cbeb4f4a33a6f8b44b5001e528.png

 区别1：栈的top指向的是  栈顶元素   还是  栈顶元素下一个位置

根据之前我写的top指向的是栈顶元素的下一个位置叙说：如下

没有数据是top = 0；当存入一个时top = 1；

4748e8bc1d484d5f982b4e29d9351807.png

 af765a10d7494fcb9dad3d46826fb0f1.png

 所以你再取数据放到空的栈时应该也要注意先pop一下再取

 还有一个需要注意的点：它比队列实现栈跟倔强（醒悟的更慢）！！！

一个栈里面的数据如下：

04cff4a000bd4378b877afd5f1568bca.png

 4 3 2 取出放到下面的空栈中

 流程图如下:1 就顺利走了，以为这样就完事了？？一开始我也这样想的，结果碰壁了

e627c9bb9bbb4ae19b040ef66478db1f.png

将1取走后，根据之前的思路，再pop时就会将3 2放到上面栈，那么最后出队顺序变成了：1 4 2 3

乱套了

非常不对劲

 我想到了再回转一次，这样就可以保证我开始入队时的顺序不变，也就是将上面的栈作为出数据用，每次出一次数据，就将其他数据入栈到下面的栈，出完再回到上面的栈，无论你423519e7ecb74c08b99aa6daccc1ccb5.png

可以理解为：不撞南墙不回头（心死了，才向前）！！！！头比较硬哈，越靠后撞的次数越多

9426bce6cbeb4acf8c687ee868f426b1.png

 3、代码：

有更好的代码，作参考即可

typedef int LTDataType;
//顺序表（栈）
typedef struct SL
{
	LTDataType* a;
	int top;
	int capacity;
}SL;
//入栈
void SLPush(SL* p,LTDataType x)
{
	//不能传NULL,判空;
	assert(p);
	if (p->top == p->capacity)
	{
		//先判断是否为0，好进行扩容
		int newnode = p->capacity == 0 ? 4 : 2 * (p->capacity);
		//扩容；创建一个临时变量接收新的空间，成功在将其交给p->a；
		LTDataType* s = (LTDataType*)realloc(p->a,newnode * sizeof(LTDataType));
		if (s == NULL)
		{
			perror("realloc");
			return;
		}
		p->a = s;
		p->capacity = newnode;
	}
	p->a[p->top] = x;
	//指向下一个数据地址
	p->top++;
}
//出栈(类似尾删)
void SLPop(SL* p)
{
	//是否为空
	assert(p);
	assert(p->top > 0);
	p->top--;
}
//初始化
void SLInit(SL* p)
{
	p->a = NULL;
	p->capacity = 0;
	//p->top = -1;//指向栈顶的数据
	p->top = 0;//指向栈顶的下一个数据
}
//销毁
void SLDestroy(SL* p)
{
	assert(p);
	free(p->a);
	p->a = NULL;
	p->capacity = p->top = 0;
}
//判空
bool SLEmpty(SL* p)
{
	//不能是空地址
	assert(p);
	//为0就是真(true)，为1就是假(flase)
	return p->top == 0;
}
//数据个数
int SLsize(SL* p)
{
	int size = p->top;
	return size;
}
//取数据：
LTDataType SLPot(SL*p)
{
	assert(p);
	return p->a[p->top];
}

//2个栈
typedef struct {
    SL q1;
    SL q2;
} MyQueue;

//初始化
MyQueue* myQueueCreate() {
    MyQueue*pts = (MyQueue*)malloc(sizeof(MyQueue));
    if(pts==NULL)
    {
        perror("malloc");
        return NULL;
    }
    SLInit(&pts->q1);
    SLInit(&pts->q2);
    return pts;
}
//入队
void myQueuePush(MyQueue* obj, int x) {
    //非空，存数据:一定要注意top，我的top是指向栈顶元素的下一个位置
    if(!SLEmpty(&obj->q1))
    {
        SLPush(&obj->q1,x);
    }
    else
    {
        SLPush(&obj->q2,x);
    }
}
//出队
int myQueuePop(MyQueue* obj) {
    //假设法：
    SL *noEmpty =&obj->q1;
    SL *empty =&obj->q2;
    if(!SLEmpty(empty))
    {
        noEmpty =&obj->q2;
        empty =&obj->q1;
    }
    while(SLsize(noEmpty)>1)
    {
        //根据top指向位置要先pop
        SLPop(noEmpty);
        int x = SLPot(noEmpty);
        SLPush(empty,x);
    }
    SLPop(noEmpty);
    int Top = SLPot(noEmpty);
    while(!SLEmpty(empty))
    {
        //根据top指向位置要先pop
        SLPop(empty);
        int x = SLPot(empty);
        SLPush(noEmpty,x);
    }
    return Top;
}
//取
int myQueuePeek(MyQueue* obj) {
    SL*qq1 = &obj->q1;
    SL*qq2 = &obj->q2;
    //直接取第一个进去的数据
    if(!SLEmpty(qq1))
    {
        return qq1->a[0];
    }
    else
    {        
        return qq2->a[0];
    }

}
//判空
bool myQueueEmpty(MyQueue* obj) {
    return SLEmpty(&obj->q1)&&SLEmpty(&obj->q2);
}
//销毁
void myQueueFree(MyQueue* obj) {
    SLDestroy(&obj->q1);
    SLDestroy(&obj->q2);
    free(obj);
    obj = NULL;
}

 三、设计循环队列:

粗略讲解一下：循环队列

循环队列是一种线性数据结构。它也被称为“环形缓冲器”，大致就是一个队列有了空间大小，这个空间只能存出的数据是有限个，满了不能存，未满则可以继续存，相当于苍蝇馆吃饭，比较火爆，只能坐下k个人，那么就得排队，若是离开一个，就能进去一个，接着走

bf14b081bb4149cba654f13db4ca3ff9.jpeg

相关概念：

1、题目：

 e9c47ad1ff7e44e7ab8d584c01ec78de.png

 2、思路：

有链表和顺序表（数组）都可以实现，我用的数组，因为更简单一点：

根据上面的介绍可以知道，循环列队要一个标记首和尾的变量（head和tail）

初状态:都在头的位置，下标来看的话就是  0 的位置

检查队列满和空的情况：

空队的情况：很简单  head = tail

满队时，tail应该指向的下一个位置，因为你存一个数据tail会后移一位，所以如下：4个数据的空间，满队时，刚好 tail = k（k表示数据个数（空间大小））根据循环队列，要判满的话  也是 tail==head 才行，就需要回绕

即 tail%k == head；   但是这么做的话有问题：空也是 head == tail，这不是冲突么！！ 

有2种方法解决：任选，操作难度差不多

1、设置size ——记下数据个数

2、多创建一个空间

用2：

当满栈时，tail与head差了一步，我们写下 （tail+1）%（k+1）；有点抽象，看下面:但是我们要保证只会用到4个空间

给变成环形来看：是不是更清晰了，头和尾的差了一个 1也就是tail+1；因为数组是一块连续的空间，所以我们要用%(k+1)将尾回绕到头去    通过取%  将尾和头相连 

插入数据时，需要注意tail的取值：

 先存数据再给tail = tail+1；但是tail不能一直往后走的（循环规定了循环的范围）！！！！它的取值只能是[0,k]（或者说时[0,k+1)这个区间）;所以还要写一个tail %=（k+1）;  因为x%k  (取值范围为：[0,k) )

 若是如此：tail是在下标为5的位置，后面是不能用的，所以要将tail传回到头去，保证了差一步（保证了一个空间不能用，因为我们多申请了一个，多申请的那一个空间只是饰品，占着茅不能用）：推出  tail = tail%(k+1)

取尾元素：

tail= tail%(jk+1) 

tail的位置是下一个元素的位置，所以要用tail-1来调用，但是有坑，因为会回绕当tail的位置到达了下标0处，还能减掉吗？？？那不就是-1么，此时区间[-1,k]  但是我们要的取的值tail-1的范围应该是 [o,k] 这个区间范围内

上面我们是  tail = tail%（k+1）;——>>> tail-1 = tail%（k+1)-1;有没有办法消掉-1

我们要将它区间变成[0,k];  写等式就消掉了-1

3、代码：

typedef struct {
    int *a;
    int head;
    int tail;
    int k;
} MyCircularQueue;
//因为在判空和判满的上面的函数需要调用他俩，所以我们要进行函数声明
bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueIsEmpty(MyCircularQueue* obj);

//初始化：
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*pts = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if(pts==NULL)
    {
        perror("malloc");
        return NULL;
    }
    pts->a = (int*)malloc(sizeof(int)*(k+1));
    if(pts->a==NULL)
    {
        perror("malloc");
        return NULL;
    }

    pts->k = k;
    pts->tail = pts->head =0;
    return pts;
}

//插入，返回真假
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //是否为满，满了就不能插入；
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->tail]= value;
        obj->tail++;
        obj->tail%=(obj->k+1);
        return true;
    }

}
//删除：返回真假
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
   //是否为空，为空不能删除
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->head++;
        obj->head%=(obj->k+1);
        return true;
    }
}
//取头元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->head];
    }
}
//取尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[(obj->tail-1+obj->k+1)%(obj->k+1)];
    }
}
//s是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head == obj->tail;
}
//是否满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->head == (obj->tail+1)%(obj->k+1);
}
//销毁
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a =NULL;
    free(obj);
    obj = NULL;

}

补充：思路2、用链表来实现：比起数据很快

一个头指针和一个尾指针，记录头和尾，保证队列空间一直是k，结构体里面可以在加一个size记录个数，Capycity用来记录空间大小；

本来开始考虑到可以将队头和队连接，但是多此一举，可以直接在后面尾插就行了，只要保证链表节点数一直小于等于空间大小；

代码：

//节点
typedef struct QueueNode
{
    struct QueueNode*next;
    int x;
}QuNode;


typedef struct {
    //头
    QuNode*q1;
    //尾
    QuNode*q2;
    //个数
    int size;
    //空间容量
    int Capycity;
} MyCircularQueue;
//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
//判满
bool myCircularQueueIsFull(MyCircularQueue* obj);
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pts = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if(pts==NULL)
    {
        perror("malloc");
        return NULL;
    }
    pts->q2=pts->q1 =NULL;
    pts->size=0;
    pts->Capycity = k;
    return pts;
}
        //若是满了，就不能插入；
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    QuNode*newnode = (QuNode*)malloc(sizeof(QuNode));
    if(newnode==NULL)
    {
        perror("malloc");
        return false;
    }
    newnode->x=value;
    newnode->next = NULL;
    //若是尾指针为空就是要传
    if(obj->q1==NULL)
    {
        obj->q2 = obj->q1 = newnode;
    }
    else
    {
        obj->q2->next = newnode;
        obj->q2 = newnode;
    }
    obj->size++;
    return true;
}
//删除：
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    //头删
    QuNode* next = obj->q1->next;
    free(obj->q1);
    obj->q1=next;
    obj->size--;
    return true;
}
//取头
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    int x = obj->q1->x;
    return x;
}
//取尾
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    int x = obj->q2->x;
    return x;
}
//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
     return obj->size==0;
}
//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    
    return obj->size==obj->Capycity;
}

void myCircularQueueFree(MyCircularQueue* obj) {
   QuNode*cur = obj->q1;
   while(cur)
   {
        QuNode*next = cur->next;
        free(cur);
        cur = next;
   }
   obj->q1=obj->q2=NULL;
   free(obj);
   obj=NULL;
}

啥也不会干的小码
关注
  • 37
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
专栏目录
栈队列OJ题分享及讲解
m0_69888254的博客
08-07 572
从今天开始后面的OJ题，我一致用C++来带大家实现，这需要大家先去了解C++STL里面的容器，以及相关的接口。 ## 1、有效的括号 ![在这里插入图片描述](https://img-blog.csdnimg.cn/24f0768e6bc348d7a19e9bb92750f371.png#pic_center) 这题是比较典型的用栈实现的题目，给了我们一个字符串s，让我们去判断里面的括号是否一一匹配。 **解题思路：** ```cpp class Solution { public: bool i
C语言回文数OJ题和答案
10-22
打印所有小于65536且是完全平方数的回文数。
两个队列模拟栈-OJ题
qq_58724706的博客
11-03 247
目录 题目描述 示例 提示 题目分析 结构体的创建 函数接口 void myStackPush(MyStack* obj, int x) int myStackPop(MyStack* obj) int myStackTop(MyStack* obj) bool myStackEmpty(MyStack* obj) void myStackFree(MyStack* obj) 完整代码 题目描述 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种..
栈与队列的3个oj题
编程SHARE的博客
05-20 482
栈与队列225.用队列实现栈解题思路代码232.用栈实现队列解题思路代码622.设计循环队列解题思路代码 225.用队列实现栈 解题思路 代码 232.用栈实现队列 解题思路 代码 622.设计循环队列 解题思路 代码 ...
【数据结构】栈与队列经典oj题
睿的博客
04-08 861
学会了栈与队列相关知识，快来刷题提升自己吧！
【万字详解栈和队列及其OJ题】
m0_68872612的博客
08-19 463
各位大佬们，今天分享的是栈和队列的实现以及相关OJ题，如果觉得不错的话能支持一下菜鸟吗？
栈和队列OJ题：LeetCode--232.用栈实现队列
Yikefore的博客
05-20 1233
LeetCode--232.用栈实现队列：详细题解以及图解和完整代码。
栈与队列相关OJ题
zdlynj的博客
06-12 608
前面学习了栈与队列的相关知识，及其基本实现。今天我们就来看看他们在题目中的应用吧。话不多说，那我们就直接开始吧。
栈和队列的初阶知识与基础OJ练习
CS_boy的博客
11-01 319
  本文仅使用了两种常见的实现方法——动态数组栈、链队列，如果要看更多的队列和栈的实现方法，可以看我的下面这篇文章中有关队列和栈的部分：图的五种接口的实现，   本文的有关队列和栈的实现均已上传码云，可以来关注呀~：我的Gitee star一下再走啊 文章目录????一、栈????1. 存储结构和接口????️2.初始化栈????️3. 入栈????4.判断栈是否为空????5.出栈????6.返回栈顶元素????7.判断栈的大小????8.销毁队列????二、队列????1.存储结构与接口????2.初
栈和队列OJ题：LeetCode--225.用队列实现栈
Yikefore的博客
05-19 846
LeetCode--225.用队列实现栈：详细题解以及图解和完整代码。
蓝桥杯历届题目和测试数据（oj建设题库）
02-19
因为有测试数据，也可以输入到您自己的oj系统里面，补充题库，或者作为出题的参考。 http://www.lanqiao.org/ 关于蓝桥 蓝桥网是一个帮助泛IT领域人士学习、就业及职业成长的立体式、综合性服务平台。平台业务...
洛谷_oj题库_洛谷oj网站_洛谷_洛谷题库下载_洛谷OJ_
09-29
这是洛谷OJ题库导出文件，希望大家下载看看
从各大的OJ平台提取的题库
04-16
这是从各大的OJ平台提取的题库，虽然不全但是经典，分享给大家，使用能打开HTML的软件都能打开的。文件较大，压缩包文件较多。
OJ系统蓝桥杯题库
12-03
OJ系统的蓝桥杯题库，http://oj.xpuca.top/，这里有这些题的栗子。
CCF-GESP 等级考试 2024年3月认证C++一级真题解析
m0_46192147的博客
05-22 1226
第 1 题 C++表达式(3 - 2) * 3 + 5的值是( )。正确答案：B. 8第 2 题 C++语句执行后的输出是( )。正确答案：D. 5%2=15 % 2第 3 题 执行C++语句cin >> a时如果输入5+2，下述说法正确的是（ ）。正确答案：D. 依赖于变量a的类型。如果没有定义，会有编译错误cin >> aaaaaacin第 4 题 下面C++代码执行后的输出是（ ）。正确答案：A. a+1= 2coutaa+1endla+1。
CCF-GESP 等级考试 2023年12月认证C++一级真题解析
最新发布
m0_46192147的博客
05-23 852
第 1 题 以下C++不可以作为变量的名称的是( )。：A第 2 题 C++表达式10 - 3 * (2 + 1) % 10的值是( )。：B第 3 题 假设现在是上午⼗点，求出N⼩时（正整数）后是第⼏天⼏时，如输⼊20⼩时则为第2天6点，如N输⼊4则为今天14点。为实现相应功能，应在横线处填写代码是( )。：B第 4 题 下面的程序用于判断N是否为偶数，横线处应填写代码是（ ）。：A==第 5 题 下面对C++代码执行后输出的描述，正确的是（ ）。：B。
数据结构--顺序表
ykcyk的博客
05-23 890
具有相同特性的数据元素的有限序列，再逻辑结构上呈现线性，但是在物理结构上不一定是线性（也就是在内存中非线性）顺序表是线性表中的一种，他的底层逻辑就是数组，就是对数组的一种封装形式，有了增删改查等用法；注：数组在逻辑结构和物理结构都是线性的；
【数据结构】带修莫队
Texcavator的博客
05-23 318
中我们探讨了莫队的基础应用，但我们知道，莫队是个离线算法，需要读入所有询问才能进行处理，那如果遇到在线修改、但不需要在线输出的问题，我们有没有办法用莫队解决呢？，普通的莫队我们只记录下当前的左右端点，和当前询问的左右端点进行比较，对于带修改的问题，我们只需要多记录一个时间戳。
一本通 oj题库 测试数据
06-23
### 回答1： 一本通 OJ 题库的测试数据，通常是用来验证提交的代码在各种情况下的正确性。测试数据可以分为两种类型，手动和自动。 手动测试数据是由题目的出题人根据题意和数据范围设计的一组数据，用来检测程序的正确性和运行效率。手动测试数据的优点是能够涵盖各种情况，但缺点是数量相对较少，不足以覆盖所有可能的情况。 自动测试数据是由程序自动生成的一组数据，可以生成大量的数据以检测程序的健壮性和效率。自动测试数据的优点是数量大且可以自动生成，但缺点是可能无法覆盖某些特殊情况，导致漏洞。 对于提交的代码，一本通 OJ 题库会对其进行编译和运行，然后与测试数据进行比较，判断代码的正确性和效率。如果代码通过了测试数据，就会被判定为正确，否则会被判定为错误，并给出具体的错误信息，供用户进行调试和改进。 综上所述，一本通 OJ 题库的测试数据是一个重要的组成部分，它可以帮助用户测试代码的正确性和运行效率，提高用户的编程技能，同时也可以帮助出题人设计更好的题目，并保证题目的质量和难度。 ### 回答2： 一本通 oj题库是一个在线的程序设计竞赛平台，提供了丰富的编程题目和测试数据。测试数据是用于对程序进行测评的输入和输出数据集合。在题目描述中，会对问题进行详细的解释和要求，并提供多组测试数据作为样例，让程序员运行他们的代码，并得到程序的输出结果。 测试数据通常包括正向测试数据和反向测试数据。正向测试数据是指符合题目条件的测试数据，覆盖了大多数情况，测试程序是否正确；而反向测试数据则是用于测试程序是否能够正确处理异常情况。 在使用一本通 oj题库时，程序员不仅需要通过编写算法和程序的方式解决问题，还需要通过分析测试数据来判断自己的代码是否正确。而一本通 oj题库的丰富数据集合为程序员提供了充足的测试数据，帮助程序员准确地检测代码中存在的漏洞和错误。 总之，一本通 oj题库提供了全面的测试数据来测试程序员的代码是否满足题目描述和要求，是程序员进行程序设计竞赛、算法练习和编程学习的良好平台。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值