数据结构之队列的基本操作以及栈和队列的OJ题画图详解

最新推荐文章于 2023-01-04 13:16:34 发布
最新推荐文章于 2023-01-04 13:16:34 发布
阅读量1k 收藏 7
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 队列 用栈实现队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/attemptendeavor/article/details/119610504
版权

队列

文章目录

队列的概念

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

入队列：

进行插入操作的一端称为队尾

出队列：

进行删除操作的一端称为队头先进先出

image-20210806190631692

典型应用

  • 队列实际中要保证公平排队的地方都可以用它

比如在银行我们以前是排队，比如有三个窗口依次排队，但是有的窗口快，有的窗口慢，就有点不公平，后面出现了叫号机，而这个叫号机的系统就是队列的应用，满足了先到先办理业务，很公平，也是队列的特性先进先出的体现。

  • 广度优先遍历

数据结构中图的广度优先遍历也是用队列实现的。

队列的实现

队列的实现既可以用数组的结构实现，也可以用链表的结构实现，那么哪一种更好呢？

image-20210806185910282

image-20210806190311741

经过上面的分析，发现链表的结构实现对应更优

那么我们就用链表的结构来实现队列：

首先我们创建文件

文件的创建

image-20210806204556768

Queue.h对相关头文件的包含，以及实现队列的结构和函数的声明

Queue.c对实现队列操作的函数进行定义

test.c文件进行队列相关函数和单链表功能的测试

队列结构的定义

创建好文件后，我们首先来看队列结构的定义

typedef int QDataType;
//队列的链式结构结点的结构
typedef struct QueueNode
{
	QDataType data;
    struct QueueNode* next;
}QueueNode;

结点的结构

我们知道我们队列的插入数据在队尾插入，而插入需要找尾，我们不妨设一个指向尾的指针，然后将头指针和它封装成一个结构体：

typedef struct Queue
{
    QueueNode* phead;
    QueueNode* ptail;
}Queue;

接下来我们来看队列的下面操作：

//队列初始化
void QueueInit(Queue *pq);
//队列的销毁
void QueueDestory(Queue *pq);
//队列的插入
void QueuePush(Queue *pq,QDataType x);//队尾
//队列的删除
void QueuePop(Queue *pq);//队头
//队列的大小
int QueueSize(Queue *pq);
//取队头元素
QDataType QueueFront(Queue *pq);
//取队尾元素
QDataType QueueBack(Queue *pq);
//判队列是否为空
bool QueueEmpty(Queue *pq);

首先是队列的初始化：

队列初始化

//队列的初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
}

image-20210806222447900

我们调试发现我们已经将phead和ptail置空

队列的销毁

//队列的销毁
void QueueDestory(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->phead;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
}

我们首先断言一下pq不能为空，然后将phead赋给cur，开始迭代free，free前将cur的next保存下来，最后再将phead和ptail都置为空

队列的打印

//队列的打印
void QueuePrint(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

我们也是将phead赋给cur，然后利用cur进行迭代打印数据

队列的插入

//队列的插入
void QueuePush(Queue* pq, QDataType x)//队尾
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	if (pq->phead == NULL)//没有结点时
	{
		pq->phead = pq->ptail = newnode;
	}
	else//有结点时
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
}

因为我们插入元素只有这里能用到，所以我们就不将它写成和我们之前写的单链表那样单独写一个函数创建结点，我们开辟好一个结点，当队列没有结点时，我们将newnode赋给phead和ptail，有结点时我们直接将newnode赋给ptail的next，将newnode更新成尾

image-20210811160705333

可以看到我们插入成功了

队列的删除

//队列的删除
void QueuePop(Queue* pq)//队头
{
	assert(pq);
	assert(!QueueEmpty(pq));//队列不为空
	if (pq->phead->next == NULL)//只有一个结点时
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	QueueNode* next = pq->phead->next;
	free(pq->phead);
	pq->phead = next;
	//当队列中只剩下一个结点时，删除只是将phead置NULL了,
	//但是ptail并没有置空，此时它是野指针，故我们前面需考虑只剩一个结点时的情况
}

当队列中只剩下一个结点时，删除只是将phead置NULL了,但是ptail并没有置空，此时它是野指针，故我们前面需考虑只剩一个结点时的情况。当只有一个结点时，我们free phead，然后将phead和ptail都置为空

image-20210811160838564

上图是测试结果

队列的大小

//队列的大小
int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QueueNode* cur = pq->phead;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

取队头元素

//取队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->phead->data;
}

断言队列不能为空，phead就是队头，返回它的数据。

取队尾元素

//取队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->ptail->data;
}

ptail是尾，返回它的数据

判断是否是空队列

//判断是否是空队列
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL && pq->ptail == NULL;
}

phead和ptail为空时，队列为空

链表，栈，队列的操作实现时，关于函数传参传什么的问题：

  • 传二级指针(头指针可以在函数里面解引用改变)

  • 返回值(接收返回值改变)

  • 带哨兵位的头结点(不会改变头指针)

  • 结构体包一起(用结构体指针改变)

下面是队列实现的源代码：

源代码

Queen.h

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

typedef struct Queue
{
    QueueNode* phead;
    QueueNode* ptail;
}Queue;

void QueueInit(Queue *pq);
void QueueDestory(Queue *pq);
void QueuePush(Queue *pq,QDataType x);//队尾
void QueuePop(Queue *pq);//队头
int QueueSize(Queue *pq);
QDataType QueueFront(Queue *pq);
QDataType QueueBack(Queue *pq);
bool QueueEmpty(Queue *pq);

Queen.c

void QueueInit(Queue *pq)
{
    assert(pq);
    pq->phead = pq->ptail = NULL;
    
}
void QueueDestory(Queue *pq)
{
    assert(pq);

    QueueNode* cur = pq->phead;
    while(cur)
    {
        QueueNode* next=cur->next;
        free(cur);
        cur=next;
    }
    pq->phead=pq->ptail=NULL;
}
void QueuePush(Queue *pq,QDataType x)//队尾
{
    assert(pq);
    QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
    if(newnode==NULL)
    {
        perror("malloc");
        return;
    }
    newnode->data=x;
    newnode->next=NULL;
    
    if(pq->ptail==NULL)
    {
        pq->phead=pq->ptail=newnode;
    }

    else
    {
        pq->ptail->next = newnode;
        pq->ptail = newnode;
    }
    
}
bool QueueEmpty(Queue *pq)
{
    assert(pq);
    return pq->ptail==NULL && pq->phead==NULL;
}
void QueuePop(Queue *pq)//队头
{
    assert(pq);
    //删数据
    assert(!QueueEmpty(pq));
    if(pq->phead->next==NULL)
    {
        free(pq->phead);
        pq->phead=pq->ptail=NULL;
    }
    else
    {
        QueueNode* next=pq->phead->next;
    	free(pq->phead);
    	pq->phead=next;
    //如果被删空了，ptail指向的结点已经free了 但是它没有置空
    //ptail是个野指针
    }
}
int QueueSize(Queue *pq)
{
    assert(pq);
    //如果频繁调用这个接口函数，将size也放进Queue结构体中
    QueueNode* cur = pq->phead;
    int size=0;
    while(cur)
    {
        size++;
        cur=cur->next;
    }
    return size;
}
QDataType QueueFront(Queue *pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->phead->data;
}
QDataType QueueBack(Queue *pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->ptail->data;
}

test.c

int main()
{
    Quenu q;
    QueueInit(&q);
    QueuePush(&q,1);
    QueuePush(&q,2);
    QueuePush(&q,3);
    QueuePush(&q,4);
    
    return 0;
}

栈和队列的OJ题

用队列实现栈

题目描述：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

题目来源：用队列实现栈

思路：

image-20210807175109069

我们在用两个队列实现栈，队列是先进先出，而栈是先进后出，我们现在进去的顺序是1、2、3、4，而要实现栈的功能，我们出栈则应该要4先出，那么怎么样才能让4出呢？我们接着往下看思路

image-20210807175926429

那么我们入数据怎么入呢？

image-20210807180432758

入数据在不为空的队列入，我们想一想栈是后进先出，那么下次出数据操作，我们按照上面的操作，不就是出的5嘛，所以我们入数据在不为空的队列

我们来总结一下思路：

  • 一个队列有数据，一个队列没数据
  • 入数据在不为空的那个队列入
  • 出数据，把不为空的队列的前n-1个导入到空队列中，pop掉最后剩下的一个数据

代码如下：

//栈的结构--两个队列
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

/** Initialize your data structure here. */

//栈的创建
MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    if(pst==NULL)
    {
        perror("malloc MyStack");
        return NULL;
    }
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
    
    return pst;
}

/** Push element x onto stack. */
//进栈
void myStackPush(MyStack* obj, int x) {
    assert(obj);
    /*Queue* emptyQ=&obj->q1;//假设q1为空
    Queue* nonemptyQ=&obj->q2;//假设q2不为空
    if(!QueueEmpty(&obj->q1))//如果q1不为空则
    {
        emptyQ=&obj->q2;
        nonemptyQ=&obj->q1;
    }
    QueuePush(nonemptyQ,x);//在不为空的队列里入数据*/
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);

    }

}

bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
/** Removes the element on top of the stack and returns that element. */
//出栈
int myStackPop(MyStack* obj) {
    assert(obj);
    
    Queue* emptyQ=&obj->q1;//假设q1为空
    Queue* nonemptyQ=&obj->q2;//假设q2不为空
    if(!QueueEmpty(&obj->q1))//如果q1不为空则
    {
        emptyQ=&obj->q2;
        nonemptyQ=&obj->q1;
    }
    while(QueueSize(nonemptyQ)>1)
    {
        QueuePush(emptyQ,QueueFront(nonemptyQ));//将队列的队头入到空队列中
        QueuePop(nonemptyQ);//pop数据
    }
    int front = QueueFront(nonemptyQ);
    QueuePop(nonemptyQ);

    return front;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

/** Returns whether the stack is empty. */


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

设计循环队列

题目描述：

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

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

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

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

题目来源：设计循环队列

在看完题目之后，我们可以知道它是这样的结构：

image-20210808075559428

我们这样设计：front和rear分别指向头和尾的下一个元素，循环队列的结构既可以用链表结构也可以用顺序表结构，链表结构最后一个元素的next指向头，顺序表等到rear到达边界时，让他回到下标为0的地方，这样我们的顺序表和链表达到了循环的目的。

那么怎么插入数据和删除数据呢？

插入数据：

循环队列

可以看到插入数据将rear后移，当front等于rear时，队列为满

删除数据：

循环队列删除数据

删除数据我们直接让front移动，数据不用管，front和rear直接的数据才是有效数据，可以看到删除数据将front后移，当front等于rear时，队列为空

那么我们来看这样一个问题：

image-20210808084118262

那么这里我们考虑到将空间加一个单位：

image-20210808153034096

多增加一个单位空间，如上图顺序表中，队列的长度为7，但是我们实际最多只存储6个数据，当rear的下一个存储空间等于front时，我们就说队列是满的

我们假设k是实际存储的数据个数，则只要(rear+1)%(k+1)==front时，队列是满的，那么front==rear时，队列是空的。

下面我们开始写代码，我们这道题用顺序表结构来写，这里我建议大家用顺序表写，因为顺序表缓存利用率高，而且不用一直开辟节点。

首先我们创建循环队列的结构体：

typedef struct{
  	int *a;//指向动态开辟的内存的指针,这块内存用来存储数据
    int front;//队头的下标
    int rear;//队尾的下一个元素的下标
    int k;//数据的个数
}MyCircularQueue;

我们创建了指向动态开辟的内存的指针a，队头的下标，队尾的下一个元素的下标，数据的个数k

接下来我们来看循环队列的创建初始化函数：

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    q->a = (int*)malloc((k+1)*sizeof(int));//需要开辟k+1个存储数据的空间，实际存储k个
    q->front=q->rear=0;
    q->k=k;
    
    return q;
}

我们先对循环队列开辟一块空间，需要开辟k+1个存储数据的空间，实际存储k个，然后初始化循环队列。

接下来是判空函数：

bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
    assert(obj);
    return obj->front==obj->rear;
}

我们前面已经提到了，当front和rear相等时，队列为空

接下来是判满函数：

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    assert(obj);
    return (obj->rear+1)%(obj->k+1)==obj->front;
}

判满我们前面也用图片解释过了，当rear+1=front时是满的，但是当rear到达顺序表末尾时，此时rear+1我们需要回到顺序表下标为0的地方，故我们这里写成(obj->rear+1)%(obj->k+1)==obj->front;，此时就满足条件了。

接下来是进队列操作：

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

进队列操作，我们再前面动态展示进数据，其实就是将数据放在rear下标处，然后rear++，需要注意的是rear到达边界时的处理情况，rear等于k+1时我们需要让他回到起点

接下来我们来看出队列的函数：

bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    if(obj->front==obj->k+1)
    {
        obj->front=0;
    }
    //obj->front %= (obj->k+1);
}

我们前面动态也演示过删除数据，即将front++即可，注意还需要考虑边界的情况，front等于k+1时我们需要让他回到起点

接下来我们来看取队头的操作：

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

首先判断是不是空，依照题意要求，为空需要返回-1，最后返回头的下标front的数据

接下来我们来看取队尾的操作：

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

首先判断是不是空，依照题意要求，为空需要返回-1，最后返回尾的数据，这里要注意rear是尾的下一个位置的下标，故这里需要-1,需要注意的是当rear等于0时，队尾元素下标并不是0-1，而它的下标为k，这里需要特别处理，总而言之还是边界的问题

下面我们看最后一个销毁函数：

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

这道题的完整代码：

typedef struct{
  	int *a;//指向动态开辟的内存的指针,这块内存用来存储数据
    int front;//队头的下标
    int rear;//队尾的下一个元素的下标
    int k;//数据的个数
}MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    q->a = (int*)malloc((k+1)sizeof(int));
    q->front=q->rear=0;
    q->k=k;
    
    return q;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
    assert(obj);
    return obj->front==obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    assert(obj);
    return (obj->rear+1)%(obj->k+1)==obj->front;
}

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

bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    if(obj->front==obj->k+1)
    {
        obj->front=0;
    }
    //obj->front %= (obj->k+1);
}

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

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

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

两个栈实现队列

题目描述：

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

实现 MyQueue 类：

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

题目来源：两个栈实现队列

思路：

前面我们是用两个队列实现栈，这里是两个栈实现队列，那么想一想我们怎么实现呢？

image-20210808203141134

栈是先进后出，队列是先进先出，我们发现我们将栈1的数据依次出栈1，进栈2，栈2的出栈顺序就对应着队列的出队顺序了，所以我们入数据就在栈1，出数据就在栈2

我们不妨对栈1取名为pushst，栈2取名为popst

那么我们的思路为：

  • 入数据进pushst
  • 出数据看popst是不是空，如果为空，先把pushst的数据倒过来，然后出数据，如果不为空直接出数据

代码如下：

typedef struct {
    Stack pushst;
    Stack popst;
} MyQueue;

/** Initialize your data structure here. */

MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushst);
    StackInit(&q->popst);

    return q;
}

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    //
    StackPush(&obj->pushst,x);
}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
    assert(obj);
    //
    /*if(StackEmpty(&obj->popst))//如果popst为空，则在pushst中将数据倒过来
    {
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    int top = StackTop(&obj->popst);
    StackPop(&obj->popst);
    return top;*/
    int front = myQueuePeek(obj);//可以复用取队头的函数
    StackPop(&obj->popst);
    return front;
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
    assert(obj);
    if(StackEmpty(&obj->popst))//如果popst为空，则在pushst中将数据倒过来
    {
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    return StackTop(&obj->popst);
}

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {

    assert(obj);
    return StackEmpty(&obj->pushst)&&StackEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    StackDestroy(&obj->popst);
    StackDestroy(&obj->pushst);
    free(obj);
    obj=NULL;
}

以上就是队列概念与实现以及栈和队列的OJ题讲解，如果觉得有帮助，点个赞吧，欢迎大家互相学习

小赵小赵福星高照～
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
顺序栈，栈篇（画图教您顺序栈的进栈出栈操作）
qq_46104786的博客
11-01 8803
数据结构专升本学习，栈篇（顺序栈） 前言： 上次我们学了，线性表里面的的链表，今天我们学栈，用官方的术语就是，栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）也就是后进先出（LIFO）或者先进后出。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。 每日一遍，快乐无极限，哈哈哈 1.什么是栈 我们先学习一下栈的逻辑，在编程中逻辑是非常重要的东
队列的图文解析
qq_39584159的博客
05-13 2108
队列的介绍 队列（Queue），是一种线性存储结构。它有以下几个特点： (01) 队列中数据是按照"先进先出（FIFO, First-In-First-Out）"方式进出队列的。 (02) 队列只允许在"队首"进行删除操作，而在"队尾"进行插入操作。 队列通常包括的两种操作：入队列和出队列。 add，将val值添加到队列的末尾。 pop，返回队列首部，并且删除队列首部。 1，队列的示意...
C语言实现数据结构的栈和队列（附三题OJ+画图-＞解析
qq_68926231的博客
08-06 426
日拱一卒，功不唐捐！一起进步~
操作系统（三十六）动态分区分配算法
qq_40608137的博客
03-14 1177
3.5 动态分区分配算法 上节讲述了连续分区分配方式中有动态分区分配的方式，如果在动态分区分配算法中有许多空闲分区都满足需求的时候，那该如何分配空间呢，今天来介绍四种分配方法解决这个问题。 目录 3.5 动态分区分配算法 3.5.1 首次适应算法 3.5.2 最佳适应算法 3.5.3 最坏适应算法 3.5.4 邻近适应算法 3.5.5 四种方法比较 3.5.1 首次适应...
栈和队列经典OJ题
MEANSWER的博客
10-05 456
栈和队列经典OJ题1. LeetCode第225题---用队列实现栈2. LeetCode第232题---用栈实现队列3. LeetCode第20题---有效的括号4. LeetCode第150题---逆波兰表达式5. LeetCode第155题---最小栈6. 牛客网剑指offer21题---栈的压入、弹出序列 1. LeetCode第225题—用队列实现栈 链接: https://leetcode-cn.com/problems/implement-stack-using-queues/ 题解：用队列
数据结构与算法(Python版) | (7) 队列、列表OJ作业
12-21
OJ地址 1. 有序队列 def func(S): min_str = S #记录最小的字符串 for i in range(len(S)): #遍历字符串的长度 S = S[-1] + S[:-1] #每次把最后一个字符放在第一个位置 并拼接上剩余的字符 if S < min_str: ...
数据结构_栈_队列_prim算法_
10-04
数据结构OJ系统编程 个人向 禁止商用如有错误 还请海涵
数据结构（清华大学版）——栈和队列
04-19
数据结构（清华大学版）——栈和队列
8583 顺序栈的基本操作.zip_8583顺序栈_数据结构
09-21
数据结构：顺序栈的基本操作，符合国内oj检验
西南科技大学SWUST OJ 数据结构 图相关题题解 图.zip
01-01
SWUST OJ ： 1055、1056、1057、1058、1059、1060、1061、1062、1063、1064、1065、1066、1067、1068、1069、1070、1071、1072、1075、1086题答案
[013] 7种常见数据结构的图画解读
Pysamlam的博客
01-25 1038
“数据结构在我们做数据过程中会经常遇到的，算法的实现更是依赖。今天给大家分享的这篇文章，对我们工作中最为常用的数据结构进行了结构化解释，同时也有一些图画，更加容易理解，希望可以帮助到大家...
【数据结构和算法】超多图解，超详细，堆详解
热门推荐
Linux猿
10-24 5万+
???? 作者：Linux猿 ???? 简介：CSDN博客专家????，华为云享专家????，Linux、C/C++、面试、刷题、算法尽管咨询我，关注我，有问题私聊！ ???? 关注专栏：图解数据结构和算法（优质好文持续更新中……）???? ???? 欢迎小伙伴们点赞????、收藏⭐、留言???? 目录 ????一、什么是堆 ????二、堆排序 ✨2.1 算法原理 ✨2.2 算法步骤 ✨2.3 实例演示 ✨2.4代码实现 ✨2.5堆调整原理 ????三、实例讲解 ✨3.1 求第 k
数据结构详解：图（Graph)
qq_54169998的博客
11-14 4702
一个图就是一些顶点的集合，这些点通过一系列边结对（连接）。有时，顶点 会称为节点或交点，边称为链接。
数据结构复习笔记：图的概念和操作
qq_51448028的博客
05-24 1474
数据结构复习笔记：图的概念和操作 一，图 1.图的定义： 图G（Graph）由俩个集合V(Vertex)和E（Edge）组成，记为G=（V， E），其中V是顶点的有限集合，E是连接V中顶点的边的有限集合。通常，也将图中的顶点集记为V（G），边集记为E（G）。 2.有向图和无向图： 如果E中的顶点对是有序的，即E中的每条边都是有方向的，则G称为有向图。如果顶点对是无序对，则称G为无向图。 3.弧和边： ①弧的定义：若G = （V，E）是有向图，则它的一条有向边是由V中俩个顶点构成的有序对，也叫做弧，记为＜
队列重点OJ题
qq_72766756的博客
01-04 115
设计你的循环队列实现。循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头.请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出。
【OJ算法训练】03__九月__队列
aloong的半山农场
10-18 190
队列 参考资料，以下内容来自CSDN大佬： 队列基本操作_zhang21722668的博客-CSDN博客_队列 数据结构系列－队列的基本操作_lin20080410的专栏-CSDN博客_队列 ... ... 定义 1. 只允许在一端进行插入数据操作，在另一端进行删除操作的特殊线性表； 2. 进行插入操作的一端称为队尾(入队列)，进行删除操作的一端称为队头(出队列)； 3. 队列遵循“先进先出”(FIFO)原则。 实现方式 顺序队列 数组实现，比如有一个ｎ个元素的队列，数组下标0的一端是队
栈、队列(详细图解与代码实现)
YOLO97的博客
09-07 3910
栈 栈是一种只能在一端进行插入和删除的线性数据结构。主要有进栈(Push)和出栈(POP)两个操作。 - 栈的存储结构 栈一般使用一段连续的空间进行存储，通常预先分配一个长度，可以简单地使用数组去实现，具体的存储结构如下图所示： - 栈的特点 只能在一端进行操作，在遵循先进后出(FILO,First In Last Out)或后进先出(LIFO,Last In First Out...
oj教程--队列
weixin_30729609的博客
12-21 212
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 转载于:https://www.cnblogs.com/daxiang2008/p/10155925.html...
操作系统中文件存储空间的管理
永不言弃！
03-24 1万+
一、文件存储空间管理的概念 由于文件存储设备是分成若干个大小相等的物理块，并以块为单位来交换信息的，因此，文件存储空间的管理实质上是一个空闲块的组织和管理问题，它包括空闲块组织，空闲块的分配和空闲块的回收等几个问题。 二、文件存储空间管理的方式 1． 空闲表法（空闲文件目录） 操作系统为磁盘外存上所有空闲区建立一张空闲表，每个表项对应一个空闲区，空闲表中包含序号、空闲区的第一块
西南科技oj数据结构
最新发布
09-09
西南科技oj数据结构是指西南科技大学开发的一套用于编程竞赛的在线评测系统中，用于测试和评判学生对数据结构知识的掌握情况的题目。数据结构是计算机科学中的重要内容，它主要研究如何组织和存储数据以及如何高效地处理各种数据操作。 西南科技oj数据结构题目的特点是，它们涵盖了数据结构的各个方面，如线性表、栈、队列、链表、树、图等。每个题目都要求学生根据题目描述和要求，设计和实现相应的数据结构，然后使用合适的算法对数据进行操作和处理。 在解决这些题目时，学生需要具备一定的数据结构基础知识，如数组、链表、栈和队列的基本操作，以及树和图的遍历算法、最短路径算法等。此外，对于每个题目，学生还需要分析问题的特点和要求，选择合适的数据结构和算法，使得程序能够高效地运行。 通过西南科技oj数据结构题目的练习，学生能够加深对数据结构的理解和运用能力，同时也能够提高编程和算法设计的水平。这对于学生在进行编程竞赛和实际工程开发中都非常有帮助。 总之，西南科技oj数据结构题目的设计旨在帮助学生掌握和应用数据结构知识，提高编程和算法设计的能力。通过解决这些题目，学生能够在实践中提升自己的能力，并为日后的学习和工作打下坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小赵小赵福星高照～

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

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

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

打赏作者

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

抵扣说明：

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

余额充值