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

最新推荐文章于 2023-02-07 11:41:09 发布
最新推荐文章于 2023-02-07 11:41:09 发布
阅读量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_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 首次适应...
队列简介及常用操作
weixin_43744293的博客
05-13 682
队列简介及常用操作1.队列的定义2.队列的实现顺序队列的演变：循环队列C++实现循环队列和链式队列3.顺序队列和链式队列的对比4.队列的常用操作 1.队列的定义 队列是一种先进先出(FIFO:First In First Out)的数据结构。它的插入和删除操作分别在两端，其中插入的一端为队尾，删除的一端为队首，如下图。 2.队列的实现 队列的底层实现有两种形式：数组和链表。以数组实现的称为顺序队列，其元素在内存中连续；以链表实现的称为链式队列，元素在内存中不连续，如下图。 顺序队列的演变：循环队列 假设
顺序栈，栈篇（画图教您顺序栈的进栈出栈操作）
qq_46104786的博客
11-01 8803
数据结构专升本学习，栈篇（顺序栈） 前言： 上次我们学了，线性表里面的的链表，今天我们学栈，用官方的术语就是，栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）也就是后进先出（LIFO）或者先进后出。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。 每日一遍，快乐无极限，哈哈哈 1.什么是栈 我们先学习一下栈的逻辑，在编程中逻辑是非常重要的东
队列的图文解析
qq_39584159的博客
05-13 2108
队列的介绍 队列（Queue），是一种线性存储结构。它有以下几个特点： (01) 队列中数据是按照"先进先出（FIFO, First-In-First-Out）"方式进出队列的。 (02) 队列只允许在"队首"进行删除操作，而在"队尾"进行插入操作。 队列通常包括的两种操作：入队列和出队列。 add，将val值添加到队列的末尾。 pop，返回队列首部，并且删除队列首部。 1，队列的示意...
【操作系统】操作系统原理复习
m0_53700832的博客
02-07 1330
三、设某单面磁盘共有28000个扇区，采用CSCAN(循环扫描)磁盘调度策略，磁盘的旋转速度为每分钟6000转，每个磁道有100个扇区，相临磁道间的移动时间为1ms.若在某时刻，磁头位于100号磁道处，并沿着磁道号增大的方向移动,磁道号的请求队列为150，40，230，120，78，28，90，190，对请求队列中的每个磁道需读取1个随机分布的扇区，则读完这些扇区点共需要多少时间?四、设一系统中有三类资源，所有可用资源个数为（9，8，9）。时刻25时页面0，1，2，3分别装入到物理页框2，4，1，3中。
计算机操作系统-存储管理之分区技术
qq_43535469的博客
01-11 1292
目录简单存储技术连续存储固定分区技术动态分区技术伙伴系统离散存储：分页存储分段存储虚拟存储 简单存储技术 进程在执行之前将程序数据全部装入内存 连续存储 就是分区存储 一个进程占的是一整块连续内存 固定分区技术 一种是： 系统初始化启动时将内存划分为数目固定尺寸固定的多个分区 就是内存里面分好了一些固定大小(大小相同)的区域 进程进来了就直接放进相应的分区就行了 另一种是： 系统初始化启动时即将内存划分为大小尺寸不同的多个分区 优点：实现简单，系统开销小 缺点：空间利用率低 左边是第一种 右边是第二种 动
C语言实现数据结构的栈和队列（附三题OJ+画图-＞解析
qq_68926231的博客
08-06 426
日拱一卒，功不唐捐！一起进步~
数据结构与算法(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题答案
c语言作业解放军,2018年解放军信息工程大学软件工程806计算机组成原理和操作系统之计算机操作系统考研基础五套测试题...
weixin_39669701的博客
05-18 759
一、选择题1． 采用段式存储管理时，一个程序如何分段是在( )决定的。A. 分配主存时B. 用户编程时C. 装作业时D. 程序执行时【答案】B【解析】段式存储管理是为了方便编程，满足用户需求而引入的，所以分段必须在用户编程时决定。2． 在UNIX 中，通常把设备作为( )文件来处理。A. 特殊B. 普通C. 目录文件D. 设备【答案】A3． 周期挪用方式常用于方式的输入/输出中( ...
数据结构 - 队列（图解+源码）
三毛创作记
12-20 1256
顺序队列与循环队列分别实现，顺序队列的假溢出
❤️数据结构之栈（图文版详解）❤️
耀的博客
09-24 2094
一，写在前面 不知道大家有投有玩过手枪，估计都投有。现在和平年代，上哪去玩这种危险的 真东西，就是仿真玩具也大都被限制了.我高中在军训时，也算是一次机会，几个老兵和我们学生聊天，让我们学习了下关于枪的知识。 在你准备用枪的时候，那基本到了不是你死就是我亡的时刻，突然手枪明明有子弹却打不出来，这不是要命吗?而左轮手枪就不存在这问题，这一颗不行，转到下颗就可以 了，人总不会倒霉到六颗全是臭弹， 当然，后来子弹质量基本过关了，由于弹夹可以 8颗颗甚至20颗子弹，比左轮手枪的只能放6颗子弹要多，所以后来普及率更
用结论和画图快速秒杀判断出栈序列是否合法这一类题
无
02-19 509
相信大家在做和栈相关的题目的时候会遇到判断一个序列是否是合法的出栈序列这一类题，模拟栈的操作是标准解法，但是基础较差的同学可能模拟的时候容易出错，下面我给大家介绍两个结论和一些小技巧用于快速准确的秒杀这类题。 结论 下面我们先给出结论。 结论一：出栈序列中的每个数后面的比它小的数，是按递减排列的。 结论二：最大连续退栈次数等于最长连续递减序列。 实战 可能有些人不理解，我们给出两道例题来理解这两条结论 例1：设a,b,c,d,e,fa,b,c,d,e,fa,b,c,d,e,f以所给的次序进栈，若在进栈操作
【数据结构学习笔记】二、线性表---顺序表篇（1）（画图详解+代码实现）
大家好我叫张同学
12-29 3234
数据结构、算法图解、线性表、顺序表、链表
[013] 7种常见数据结构的图画解读
Pysamlam的博客
01-25 1038
“数据结构在我们做数据过程中会经常遇到的，算法的实现更是依赖。今天给大家分享的这篇文章，对我们工作中最为常用的数据结构进行了结构化解释，同时也有一些图画，更加容易理解，希望可以帮助到大家...
数据结构——队列（GIF图解）
weixin_43294413的博客
12-16 3136
一、队列的定义 队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表 队列也是一种线性结构； 队列是一种先进先出（First In First Out）的数据结构； 队列的描述如下图： 二、队列的实现 先定义一个接口Interface public interface Queue<E> extends Iterable<E>{ //获取队列中元素的个数 ...
西南科技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、付费专栏及课程。

余额充值