栈和队列相关知识以及oj题

最新推荐文章于 2024-07-18 00:08:52 发布
最新推荐文章于 2024-07-18 00:08:52 发布
阅读量147 收藏 4
点赞数 7
分类专栏： c语言 数据结构 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gemgod/article/details/126276185
版权

文章目录

栈和队列相关知识以及oj题

1.栈

1.栈的概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据也在栈顶。

如图所示: 即后入先出.

image-20220810204554770

2.栈的实现

栈一般可以使用链表和数组实现,总体来说使用数组实现会简单一些,尾插尾删相对于链表简单,但是使用链表会比使用数组节约空间.

image-20220810210114130

image-20220810210740998

从图可以看出,数组实现栈的会比链表简单,因为链表尾删操作还要找他的上一结点.

栈的代码实现:

//头文件
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);
//函数接口实现
#define _CRT_SECURE_NO_WARNINGS 1
#include"stack.h"
// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a, newcapacity*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
	ps->_a[ps->_top] = data;
	ps->_top++;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(StackSize(ps));
	--ps->_top;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(StackSize(ps));
	return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
// 检测栈是否为空，如果不为空返回非零结果，如果为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->_top == 0)
	{
		return 0;
	}
	return 1;
}
// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}
//主体
#define _CRT_SECURE_NO_WARNINGS 1
#include"stack.h"
int main()
{
	Stack teststack;
	StackInit(&teststack);
	StackPush(&teststack, 1);
	StackPush(&teststack, 2);
	StackPush(&teststack, 3);
	StackPush(&teststack, 4);
	StackPush(&teststack, 5);
	StackPush(&teststack, 6);
	StackPush(&teststack, 7);
	StackPush(&teststack, 8);
	int len = StackSize(&teststack);
	for (int i = 0; i < len; i++)
	{
		printf("%d->", StackTop(&teststack));
		StackPop(&teststack);
	}
	printf("NULL\n");
	len = StackSize(&teststack);
	StackDestroy(&teststack);
	return 0;
}

部分函数接口运行图:

image-20220810211124219

2.队列

1.队列概念

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

先进先出.如图所示

image-20220810211913498

2.队列实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数 组头上出数据，效率会比较低。

image-20220810213507350

代码实现:

//头文件
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
}Queue;

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

//函数接口实现
#define _CRT_SECURE_NO_WARNINGS 1
#include"qlist.h"
// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->_front = NULL;
	q->_rear = NULL;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	newnode->_data = data;
	if (q->_front == NULL)
	{
		q->_front = newnode;
	}
	if (q->_rear == NULL)
	{
		newnode->_next = q->_rear;
		q->_rear = newnode;
	}
	else
	{
		newnode->_next = q->_rear->_next;
		q->_rear->_next = newnode;
		q->_rear = newnode;
	}
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(QueueEmpty(q));
	
	QNode* cur = q->_front;
	if (q->_front == q->_rear)
	{
		q->_rear = NULL;
	}
	q->_front = cur->_next;
	free(cur);
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	return q->_front->_data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	return q->_rear->_data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	QNode* cur = q->_front;
	int i = 0;
	while (cur != NULL)
	{
		cur = cur->_next;
		i++;
	}
	return i;
}
// 检测队列是否为空，如果为非空返回非零结果，如果为非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	if (q->_front == NULL)
	{
		return 0;
	}
	return 1;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->_front;
	while (cur)
	{
		QNode* tmp = cur;
		cur = cur->_next;
		free(tmp);
	}
	q->_front = q->_rear = NULL;
}


//主体
#define _CRT_SECURE_NO_WARNINGS 1
#include"qlist.h"
int main()
{
	Queue qs;
	QueueInit(&qs);
	QueuePush(&qs, 1);
	QueuePush(&qs, 2);
	QueuePush(&qs, 3);
	QueuePush(&qs, 4);
	QueuePush(&qs, 5);
	printf("%d\n", QueueBack(&qs));
	QueuePop(&qs);
	QueuePop(&qs);
	QueuePop(&qs);
	QueuePop(&qs);
	QueuePop(&qs);
	
	QueuePush(&qs, 6);
	QueuePush(&qs, 7);
	printf("%d\n", QueueBack(&qs));
	int len = QueueSize(&qs);
	for (int i = 0; i <len; i++)
	{
		printf("%d<-", QueueFront(&qs));
		QueuePop(&qs);
	}
	printf("NULL\n");
	QueueDestroy(&qs);
	return 0;
}

部分函数接口运行结果图:

image-20220810213845738

3.特殊的队列:循环队列

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

循环队列题目

此题目将会在第三部分讲解,此处仅提出循环队列的概念.

3.栈和队列OJ题

1.225. 用队列实现栈

image-20220810214547743

解题思路:

栈的特点是后进先出,队列的特点是先进先出.这里的难点是用先进先出的队列实现后进先出的队列,所以我们可以建立两个队列,往其中一个队列插入数据(往非空队列插入数据,如果两个都为空,则任意一个都可以),在进行pop时操作将该非空队列出最后一个移入空队列,删除最后一个元素,及实现了栈的后进先出.

image-20220810221556690

解题代码:

typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
}Queue;
void QueueInit(Queue* q)
{
	assert(q);
	q->_front = NULL;
	q->_rear = NULL;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	newnode->_data = data;
	if (q->_front == NULL)
	{
		q->_front = newnode;
	}
	if (q->_rear == NULL)
	{
		newnode->_next = q->_rear;
		q->_rear = newnode;
	}
	else
	{
		newnode->_next = q->_rear->_next;
		q->_rear->_next = newnode;
		q->_rear = newnode;
	}
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	QNode* cur = q->_front;
	if (q->_front == q->_rear)
	{
		q->_rear = NULL;
	}
	q->_front = cur->_next;
	free(cur);
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	return q->_front->_data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	return q->_rear->_data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	QNode* cur = q->_front;
	int i = 0;
	while (cur != NULL)
	{
		cur = cur->_next;
		i++;
	}
	return i;
}
// 检测队列是否为空，如果为空返回true
bool QueueEmpty(Queue* q)
{
	assert(q);
	if (q->_front == NULL)
	{
		return true;
	}
	return false;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->_front;
	while (cur)
	{
		QNode* tmp = cur;
		cur = cur->_next;
		free(tmp);
	}
	q->_front = q->_rear = NULL;
}

typedef struct {
Queue q1,q2;
} MyStack;


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

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

int myStackPop(MyStack* obj) {
Queue*empty=&obj->q1;
Queue*notempty=&obj->q2;
if(QueueEmpty(&obj->q1)==false)
{
    notempty=&obj->q1;
    empty=&obj->q2;
}
while(QueueSize(notempty)>1)
{
    QueuePush(empty,QueueFront(notempty));
    QueuePop(notempty);
}
int tmp=QueueFront(notempty);
QueuePop(notempty);
return tmp;
}

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

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

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

image-20220810221620627

2.232. 用栈实现队列

image-20220810214618917

解题思路:

栈的特点是后进先出,队列的特点是先进先出.这里的难点时用栈的后进先出实现队列的先进先出

所以此处建立两个栈,一个为pushstack,一个为poppush,pushstack栈用来插入数据,当进行pop时,如果popstack为空,则将pushstack的数据全部转移到popstack,即实现了队列的先入先出

image-20220810223058163

解题代码:

typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a, newcapacity*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
	ps->_a[ps->_top] = data;
	ps->_top++;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(StackSize(ps));
	--ps->_top;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(StackSize(ps));
	return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果 
bool StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->_top == 0)
	{
		return true;
	}
	return false;
}
//将第一个栈的数据第二个栈
void doublestack(Stack* s1,Stack* s2)
{
    while(StackSize(s1))
    {
        StackPush(s2,StackTop(s1));
        StackPop(s1);
    }
}
// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}


typedef struct {
Stack s1,s2;
} MyQueue;


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

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

int myQueuePop(MyQueue* obj) {
if(obj->s2._top==0)
{
   doublestack(&obj->s1,&obj->s2); 
}
int tmp=StackTop(&obj->s2);
StackPop(&obj->s2);
return tmp;

}

int myQueuePeek(MyQueue* obj) {
if(obj->s2._top==0)
{
   doublestack(&obj->s1,&obj->s2); 
}
return StackTop(&obj->s2);
}

bool myQueueEmpty(MyQueue* obj) {
if(StackEmpty(&obj->s1)&&StackEmpty(&obj->s2))
{
    return true;
}
else
{
    return false;
}
}

void myQueueFree(MyQueue* obj) {
StackDestroy(&obj->s1);
StackDestroy(&obj->s2);
free(obj);
obj=NULL;
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

image-20220810223146578

3.622. 设计循环队列

image-20220810214438433

解题思路:

这里实现循环队列有两种思路,链表实现和数组实现,这里使用数组来实现循环队列.

typedef struct {

int* _data;

int head;//记录起始位置

int last;//记录末位置

int size;//记录数组大小

} MyCircularQueue;

循环队列难点在于判断满与空,按照一般思维当head与last相等时为空,但是当数组满时,head与last的值也相等.此处的解决方法为,建立数组时多建立一个位置,此时如果数组满了,则last+1=head(此处位置的判断代码请看解题代码,这里只是给出思路),解决了数组空与满的判断问题.

image-20220810224842221

解题代码:

typedef struct {
int* _data;
int head;
int last;
int size;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj=(MyCircularQueue *)malloc(sizeof(MyCircularQueue));
obj->_data=(int *)malloc(sizeof(int)*(k+1));
obj->head=obj->last=0;
obj->size=k+1;
return obj; 
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if((obj->last+1)%(obj->size)==obj->head)
{
    return false;
}
obj->_data[obj->last]=value;
obj->last=(obj->last+1)%(obj->size);
return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(obj->head==obj->last)
{
    return false;
}
obj->head=(obj->head+1)%(obj->size);
return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
if(obj->head==obj->last)
{
    return -1;
}

return obj->_data[obj->head];
}

int myCircularQueueRear(MyCircularQueue* obj) {
if(obj->head==obj->last)
{
    return -1;
}
int tmp=(obj->last-1)==-1?(obj->size-1):(obj->last-1);
return obj->_data[tmp];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
if(obj->head==obj->last)
{
    return true;
}
else
{
    return false;
}
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
if((obj->last+1)%(obj->size)==obj->head)
{
    return true;
}
else
{
    return false;
}
}

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

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

image-20220810224230542

se
{
return false;
}
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
if((obj->last+1)%(obj->size)==obj->head)
{
return true;
}
else
{
return false;
}
}

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

/**

  • Your MyCircularQueue struct will be instantiated and called as such:

  • MyCircularQueue* obj = myCircularQueueCreate(k);

  • bool param_1 = myCircularQueueEnQueue(obj, value);

  • bool param_2 = myCircularQueueDeQueue(obj);

  • int param_3 = myCircularQueueFront(obj);

  • int param_4 = myCircularQueueRear(obj);

  • bool param_5 = myCircularQueueIsEmpty(obj);

  • bool param_6 = myCircularQueueIsFull(obj);

  • myCircularQueueFree(obj);
    */


![image-20220810224230542](https://img-blog.csdnimg.cn/d9622e36d1f74ae4860039cc12870ca5.png)

第一次未判断数组为空,所以报错.
sleepymonstergod
关注
  • 7
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
oj题.zip
10-18
每一道题目都可能包含多种解题策略，如动态规划、贪心算法、回溯、深度优先搜索、广度优先搜索、链表操作、二叉树操作、字符串处理、图论以及基本的数据结构如数组、栈、队列、哈希表等。通过深入研究这些解决方案，...
程序设计基础 OJ 题库 NUIST
10-22
在OJ题库中，常见的数据结构包括数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树等）、哈希表等。理解并熟练运用这些数据结构可以有效地组织和操作数据，实现高效的算法。 在NUIST的"程序设计基础"课程中，...
栈和队列的实现以及相关OJ题目
qq_57770005的博客
05-24 362
栈和队列的实现以及相关OJ题目一、栈1.栈的概念及结构2.栈的动态实现3.有关于栈的OJ题目3.1括号匹配问题二、队列1.队列的概念以及结构2.队列的实现3.队列的OJ题目3.1用队列实现栈3.2用栈实现队列3.3循环队列总结 一、栈 1.栈的概念及结构 栈：是一种特殊的·线性表，其只允许在固定的一端进行插入和删除元素操作 进行数据插入和删除操作的一端成为栈顶，另一端成为栈底。 栈遵循的原则：是先进后出。 2.栈的动态实现 栈的实现一般可以使用数组或者链表来实现，相对而言数组的结构实现会更优， 因为在
栈和队列的初阶知识与基础OJ练习
CS_boy的博客
11-01 346
  本文仅使用了两种常见的实现方法——动态数组栈、链队列，如果要看更多的队列和栈的实现方法，可以看我的下面这篇文章中有关队列和栈的部分：图的五种接口的实现，   本文的有关队列和栈的实现均已上传码云，可以来关注呀~：我的Gitee star一下再走啊 文章目录????一、栈????1. 存储结构和接口????️2.初始化栈????️3. 入栈????4.判断栈是否为空????5.出栈????6.返回栈顶元素????7.判断栈的大小????8.销毁队列????二、队列????1.存储结构与接口????2.初
数据结构:栈和队列详解和相关oj题
qq_62274623的博客
06-13 429
栈队列超详细解答,欢迎阅读
栈与队列相关OJ题
zdlynj的博客
06-12 619
前面学习了栈与队列的相关知识，及其基本实现。今天我们就来看看他们在题目中的应用吧。话不多说，那我们就直接开始吧。
【数据结构】栈和队列重点知识汇总（附有OJ题）
qq_68993495的博客
09-25 978
Java实现数据结构之栈和队列以及OJ习题，很想对大家有帮助！
【数据结构】栈与队列经典oj题
睿的博客
04-08 915
学会了栈与队列相关知识，快来刷题提升自己吧！
LeetCode —— 栈和队列相关的oj题（含循环队列）
M的博客
04-13 884
LeetCode——栈和队列相关的oj题
栈和队列经典OJ题详解
都市隸人的博客
05-13 713
本文摘录了关于栈和队列的经典OJ题，并给出了详细的思路解释以及C语言题解
栈和队列的几道OJ题（数据结构、C语言、LeetCode）
分享学习方面的一些笔记
07-04 275
本篇博客整理了几道关于栈和队列的OJ题，着重介绍栈和队列之间的互相实现，以及循环队列
OJ用函数以及相关答案
06-28
【标题】"OJ用函数以及相关答案"指的是在在线编程平台（Online Judge，简称OJ）上，解决编程问题时常用的函数以及这些函数在实际解题中的应用和相关解答。OJ是程序员进行算法练习、提升编程技能的重要平台，其中涉及...
swust西南科技大学OJ数据结构80题答案
10-14
西南科技大学的OJ提供了80道数据结构相关的题目，旨在帮助学生深入理解和掌握各种数据结构及其应用。 在这个压缩包中，包含了这80道题目的解题代码，是学习和复习数据结构的好资料。下面我们将逐一探讨这些题目可能...
南阳理工oj离线题库
05-14
2. 数据结构与算法：题库中的题目可能会涉及各种数据结构，如数组、链表、栈、队列、树、图等，以及各种算法，如排序、搜索、动态规划、贪心算法等。用户可以通过解答这些题目来巩固和提升这些基础知识。 3. 编程...
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
最新发布
铁匠匠匠的博客
07-18 268
可以参考以下视频。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 39
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 873
如有错误，欢迎指出~
HALCON数据结构
qq_44744164的博客
07-17 724
HALCON数据结构
训练营OJ完整版1
08-03
总结：这两个文件展示了如何使用C++编程实现基本的数据结构栈和队列，涉及到数组作为底层存储，以及常见的操作如入栈、出栈、入队、出队和查询。这对于理解和实践基础数据结构理论，以及在实际编程中高效地处理问题...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

sleepymonstergod

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值