＜数据结构与算法＞ 队列OJ

于 2024-08-17 21:39:38 发布
阅读量359 收藏 4
点赞数 15
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/prodigy623/article/details/141287179
版权

目录

1.用队列模拟栈​编辑

2.用栈实现队列 

3.设计循环队列

4. 双端队列

1.用队列模拟栈

 思路：

  1. 将非空队列前size-1个数据倒到另一个空队列，出队
  2. 再将前size-1个数据倒到另一个空队列，出队，来回转移，循环操作
typedef int QDatatype;

typedef struct QueueNode	//链表
{
	struct QueueNode* next;
	QDatatype data;
}QNode;

typedef struct Queue		//为了方便形参书写，定义一个结构体包含头指针，尾指针
							//似乎是队列自己的结构体
{
	QNode* head;
	QNode* tail;
	QDatatype size;
}Queue;

void QueueInit(Queue* pq)//改变结构体，传结构体指针
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;
}
void QueueDestroy(Queue* pq)//释放
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
void QueuePush(Queue* pq, QDatatype x)//入队
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->head == NULL)//判断链表是否为空
	{
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;//更新尾指针
	}

	pq->size++;
}
void QueuePop(Queue* pq)//出队
{
	assert(pq);
	assert(pq->head != NULL);

	//法一：
	//QNode* next = pq->head->next;
	//free(pq->head);
	//pq->head = next;
	//if (pq->head == NULL)//这里有问题，当链表只剩一个节点时，head和tail同时指向一个节点，head释放后，tail成为野指针出现错误，所以要外加判断进行赋值
	//{
	//	pq->tail == NULL;
	//}

	//法二：提前判断是否只有一个节点
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	pq->size--;//最后不要忘了size--
}
int QueueSize(Queue* pq)
{
	/*QNode* cur = pq->head;
	QDatatype count = 0;
	while (cur)
	{
		count++;
	}*/

	return pq->size;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->size == 0;//也可判断 head == NULL && tail == NULL
}

QDatatype QueueFront(Queue* pq)//取队头数据
{
	assert(pq);
	assert(!QueueEmpty(pq));//为空就不能再取数据了

	return pq->head->data;
}
QDatatype QueueBack(Queue* pq)//取队尾数据
{
	assert(pq);
	assert(!QueueEmpty(pq));//为空就不能再取数据了

	return pq->tail->data;
}

//本题
typedef struct 
{
    Queue q1;
    Queue q2;
} MyStack;

//应该是主函数内调用它
MyStack* myStackCreate() 
{
    //malloc一个结构体代表栈，malloc申请的空间在堆内，函数栈帧收回后该空间不受影响
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    if(pst == NULL)
    {
        perror("malloc fail");
        return NULL;
    }
    
    //对这个栈-结构体里的队列初始化
    QueueInit(&pst->q1);//初始化，要改变结构体，传结构体指针，即地址
    QueueInit(&pst->q2);

    return pst;
}

//push保持只向非空队列进行push
void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

//Pop保持将n-1个数据放到空队列中
int myStackPop(MyStack* obj) {
    //这里因为如果要分类要写两次，所以用当时判断相交链表那里小技巧
    Queue* emptyQ = &obj->q1;//先认定它为空队列
    Queue* nonemptyQ = &obj->q2;
    if(!QueueEmpty(&obj->q1))//如果非空，两指针的值交换
    {
        emptyQ = &obj->q2;
        nonemptyQ = &obj->q1;
    }
    //倒数据，循环
    while(QueueSize(nonemptyQ) > 1)
    //这里因为本身就是结构体指针所以不需要再传地址，之所以传地址，是因为我们要改变结构体内的内容
    {
        QueuePush(emptyQ,QueueFront(nonemptyQ));//向空队列入队数据
        QueuePop(nonemptyQ);//拿出队头数据后出队
    }

    int top = QueueFront(nonemptyQ);//出栈并要求返回栈顶元素，即最初的非空队列的队尾元素，这里因为数据倒完了，所以成为队头数据了
    QueuePop(nonemptyQ);//实现出栈功能
    return top;
}

//看栈顶元素，看非空队列队尾数据即可
int myStackTop(MyStack* obj) {
    //Queue* emptyQ = &obj->q1;//先认定它为空队列
    // Queue* nonemptyQ = &obj->q2;
    //if(!QueueEmpty(&obj->q1))//如果非空，两指针的值交换
    //{
    //    emptyQ = &obj->q2;
    //    nonemptyQ = &obj->q1;
    //}

    //return QueueBack(&obj->q2);

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

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

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);//释放两个队列
    QueueDestroy(&obj->q1);
    free(obj);
}

三种结构之间关系： 

2.用栈实现队列 

​

思路：定义两个栈，一个只用来push，一个只用来pop 

​

结构体之间的关系 ：

​

typedef int STDataType;

typedef struct Stack
{
	int* a;
	int top;
	int capacity;
}ST;

//初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->capacity = 4;
	ps->top = 0;//top是栈顶元素的下一个位置
	//ps->top = -1; //top是栈顶元素
}

//释放
void STDestroy(ST* ps)
{
	assert(ps);

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


void STPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top++] = x;//在top位置把数据放进去
}

void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));//检查是否为空，为空那么top就不能再减了

	ps->top--;
}

int  STSize(ST* ps)
{
	assert(ps);

	return ps->top;//top是栈顶元素的下一个位置，正好对应栈内元素个数
}

int STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;//top == 0为真就表示空
}

STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));//元素为空就不能访问

	return ps->a[ps->top - 1];//返回栈顶元素
}

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


MyQueue* myQueueCreate() {
	MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
	if (obj == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	STInit(&obj->pushst);
	STInit(&obj->popst);
	return obj;
}

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

int myQueuePop(MyQueue* obj) {
	if (STEmpty(&obj->popst))//判断popst的栈内元素是否为空
	{
		while (!STEmpty(&obj->pushst))//将pushst栈内元素全压栈到popst
		{
			STPush(&obj->popst, STTop(&obj->pushst));
			STPop(&obj->pushst);
		}
	}

	int front = STTop(&obj->popst);
	STPop(&obj->popst);
	return front;
}

int myQueuePeek(MyQueue* obj) {
	//与myQueuePop一致，只是不需要pop栈顶元素
	if (STEmpty(&obj->popst))
	{
		while (!STEmpty(&obj->pushst))
		{
			STPush(&obj->popst, STTop(&obj->pushst));
			STPop(&obj->pushst);
		}
	}

	int front = STTop(&obj->popst);
	return front;
}

bool myQueueEmpty(MyQueue* obj) {
	return STEmpty(&obj->pushst) && STEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
	STDestroy(&obj->pushst);
	STDestroy(&obj->popst);
	free(obj);
}

 3.设计循环队列

​

思路一：用单链表实现， 但初始化时有一些问题

  • 如果rear指向队尾元素，那么遍历链表时，while( rear != front )，这样链表为空情况和链表为满的情况相同

​

  • 解决方案1：我们可以外加一个空节点，当rear->next == front 时结束循环 
  • 解决方案2：在结构体内加一个size用于存储队内元素个数，判断size是否等于k，就可以把两种情况分开

但是，以方案一的思路下去，我们不好找队尾元素，每次都要遍历，我们采用另一种方法，数组模拟实现队列

思路：

  • 开k+1的数组空间，front和rear初始化为0，为了避免队列空和满的条件不好区分
  • push时将数据放至下标为rear的空间，rear++
  • pop时将front++，当下标到尾时将下标%(k+1)
  • 队列为空——front == rear
  • 队列为满—— （rear + 1) % (k + 1) == front

​

 

typedef struct {

    int* a;
    int k;
    int front;
    int rear;
} MyCircularQueue;

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

//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1) % (obj->k+1) == obj->front;//看下表是否相等，这时要考虑下标循环
}

//初始化
MyCircularQueue* myCircularQueueCreate(int k) {
    //初始化要搞好
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->front = obj->rear = 0;
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    obj->k = k;

    return obj;
}
//入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->rear++] = value;
    obj->rear %= (obj->k+1);//下标循环
    return true;
}

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

//队头元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
        return obj->a[obj->front];
}

//队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    //return obj->a[obj->rear-1];//这样写是错误的，当rear == 0时，rear-1 = -1，数组越界
    //法一：
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[(obj->rear - 1 + obj->k + 1) % (obj->k + 1)];
    }
    //法二：
    //int x = obj->rear == 0? obj->k : obj->rear-1;
    //return obj->a[x];
}

//释放
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

4. 双端队列 

用数组模拟实现双端循环队列，即可以在两端入队与出队

问题：

        如果 front，rear 最初下标相同都为0，左入队后front--，右入队后rear++，发现在右入队时覆盖了左入队的值，那么这就表明左右指针必须错开赋值

        因此，有如下两种解决方法：

1. 改进入队方法：左边依旧先写值，后移动，右边则先移动，后写值

​

        但是，这样怎么看怎么别扭，左边和右边都执行了入队，但左指针位置无元素，右指针位置却有，而且左右入队操作不同，不太符合通用原则

#include <iostream>
#include <cstdlib>
#include <cstring>
using namespace std;

typedef int ElemType;
typedef enum { push, pop, inject, eject, End } Operation;

typedef struct QNode
{
    ElemType *Data;      /* 存储元素的数组   */
    int Front, Rear;   /* 队列的头、尾指针 */
    int MaxSize;            /* 队列最大容量     */
}Deque;

Operation GetOp()
{
    char op[7];
    cin>>op;
    if (strcmp(op,"Push")==0) return push;
    if (strcmp(op,"Pop")==0) return pop;
    if (strcmp(op,"Inject")==0) return inject;
    if (strcmp(op,"Eject")==0) return eject;
    if (strcmp(op,"End")==0) return End;
}

void PrintDeque( Deque D )
{
    if(D.Front==D.Rear) cout<<"Deque is Empty!\n";
    else{
        cout<<"Inside Deque:";
        while(D.Front!=D.Rear)
        {
            cout<<" "<<D.Data[D.Front];
            D.Front = (D.Front+1)%D.MaxSize;
        }
    }
}

bool CreateDeque(Deque &D, int MaxSize )
{
    /* 注意：为区分空队列和满队列，需要多开辟一个空间 */
    MaxSize++;
    D.Data = new ElemType[MaxSize];
    D.Front = D.Rear = 0;
    D.MaxSize = MaxSize;
    return true;
}


bool Push(Deque &D, ElemType e)
{
    if ((D.Rear + 1) % D.MaxSize == D.Front)
    {
        return false; // 队列已满
    }
    D.Front = (D.Front - 1 + D.MaxSize) % D.MaxSize;
    D.Data[D.Front] = e;
    return true;
}

bool Pop(Deque &D, ElemType &e)
{
    if (D.Front == D.Rear)
    {
        return false; // 队列为空
    }
    e = D.Data[D.Front];
    D.Front = (D.Front + 1) % D.MaxSize;
    return true;
}

bool Inject(Deque &D, ElemType e)
{
    if ((D.Rear + 1) % D.MaxSize == D.Front)
    {
        return false; // 队列已满
    }
    D.Data[D.Rear] = e;
    D.Rear = (D.Rear + 1) % D.MaxSize;
    return true;
}

bool Eject(Deque &D, ElemType &e)
{
    if (D.Front == D.Rear)
    {
        return false; // 队列为空
    }
    D.Rear = (D.Rear - 1 + D.MaxSize) % D.MaxSize;
    e = D.Data[D.Rear];
    return true;
}

int main()
{
    ElemType X;
    Deque D;
    int N, done = 0;
    cin>>N;
    CreateDeque(D,N);
    while (!done)
    {
        switch(GetOp())
        {
        case push:
            cin>>X;
            if (!Push(D,X)) cout<<"Deque is Full!\n";
                        break;
        case pop:
            if ( !Pop(D,X) ) cout<<"Deque is Empty!\n";
            else cout<<X<<" is out\n";
            break;
        case inject:
            cin>>X;
            if (!Inject(D,X)) cout<<"Deque is Full!\n" ;
            break;
        case eject:
            if ( !Eject(D,X) ) cout<<"Deque is Empty!\n" ;
            else cout<<X<<" is out\n" ;
            break;
        case End:
            PrintDeque(D);
            done = 1;
            break;
        }
    }
    return 0;
}

2. 改进指针位置：既然上述问题是由于左右指针指向同一个位置造成的，那么就可以让指针错位，初始时右指针在左指针右边一格

  • 队空：(front + 1) % (k + 1) == rear
  • 队满：front == rear
这个男人叫小帅
关注
  • 15
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构与算法，笔试题，OJ.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
数据结构与算法(Python版) | (7) 队列、列表OJ作业
12-21
在这篇关于“数据结构与算法(Python版) | (7) 队列、列表OJ作业”的文章中，我们将关注队列这一基本数据结构以及其在解决实际问题中的应用。 首先，我们来看有序队列的问题。有序队列要求队列中的元素按照一定的...
＜数据结构与算法＞队列
prodigy623的博客
04-07 303
队列的实现及栈与队列之间的相互实现
＜数据结构与算法＞ 二叉树的链式实现
prodigy623的博客
08-21 157
二叉树的遍历与OJ
＜数据结构|期末总结＞OJ部分代码及思路总结（二）
djs_snowyyy的博客
12-29 846
机考梳理思路用，未完全通过oj的已标出。搬运请标明出处。提交请修改代码。
【数据结构与算法】队列的实现
joy.728的博客
10-18 1217
数据结构队列的实现，保证你能够学会！！！
数据结构与算法Python版学习笔记一
12-21
理解这些基本的输入输出技巧对于在Python中编写数据结构与算法的代码至关重要，它们可以帮助你在OJ平台上更高效地测试和调试程序。此外，还需要注意不同数据结构（如数组、链表、栈、队列、树等）以及算法（如排序、...
mooc-清华数据结构与算法(邓俊辉) OJ习题.zip
06-17
【标题】"mooc-清华数据结构与算法(邓俊辉) OJ习题.zip" 涉及的是一门在线课程的编程练习题目，由清华大学的邓俊辉教授讲授，专注于数据结构与算法的学习。这个压缩包可能包含了一系列在在线判题系统（Online Judge...
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 745
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构----链表
新手嵌入式学习的博客
08-16 1208
数据结构顺序表中单向链表（包括有头单向链表，无头单向链表，单向循环链表）
数据结构：栈
最新发布
2301_80744520的博客
08-17 338
顺序栈的表示存储方式：利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。栈底一般在低地址。top：指示栈顶元素位置base：指示栈底元素位置stacksize：表示栈的最大容量接下来，我们用更详细的一幅图来描述顺序栈：起始状态，top和base都指向0的位置，此时是空栈：base==top，且栈的容量stacksize=4。接下来为空的栈添加元素（入栈），将新的元素添加到top所指位置，再将top移向下一位置，我们最终可以观察到top并没有指向D，而是栈的外面，即4的位置。
uva1586分子量（Molar Mass,ACM/ICPC Danang 2007）
2301_80844586的博客
08-14 244
然后代码具体要考虑i++每次进行i++自动i++这样避免算完字母后碰到数字然后会多算一次字母。就是一位算数字后i++如果【i+2】就是匹配到两位数的话再次i++；这样可以有效避免数字越界（你可以好好思考一下）如果都没有就是1直接定义1即可。第一个是有四个字母然后把for循环中匹配到的字母进行确认到z里面后面进行。第二的大逻辑就行下面的if那个三大判断条件第一个是一位数并且是。也是改了小两天，然后说一下核心代码逻辑两大块的核心。就是没有数字的就是1的。
【数据结构】二叉树（一）
m0_73107796的博客
08-14 1060
本篇主要理解树和二叉树相关概念，二叉树遍历及基本操作。
数据结构之红黑树
我要学编程的博客
08-16 742
红黑树的概念、性质、插入、验证； AVL树和红黑树的比较
【Java & 数据结构】LinkedList介绍
qq_42150700的博客
08-14 1114
回答这个问题前, 首先我们需要了解一下这个头节点是干什么的. 这个头节点实际上和寻常的节点没有什么两样, 但是它的数据域, 是不存储真正的数据的, 你可以在这个数据域中存储任意的数据, 例如存储链表的长度, 或者根本不使用这个数据域都是可以的. 它的作用就是用于作为链表的头, 便于链表的操作和管理而设计的.首先我们要想这个节点和链表是什么关系?很明显如果要插入一定要前一个位置的引用, 因为要令其 next 指向当前节点, 因此我们需要找到前一个节点. 那么我们如何找到前一个节点呢?
代码随想录DAY13 - 二叉树 - 08/12 (层序遍历)
chan_lay的博客
08-13 580
不能用 int 表示每一层的节点值总和，因为一个节点值最大可能是 2^31-1，当多个这么大的节点值相加，总和肯定超过 int 的最大表示范围了。对称二叉树、二叉树的最大深度、二叉树的最小深度、完全二叉树的节点个数、平衡二叉树、二叉树的所有路径、左叶子之和、找树左下角的值、路径总和。这道题目是要按层存储节点值，即同一层的节点值在同一个数组中，并且再用一个数组存储不同的层，也就是返回二维数组。注意：前中后序指的是中间结点的遍历顺序，前序即中间结点最前，中序即中间结点居中，后序即中间节点最后。
1223. 汉诺塔的移动次数
weixin_72786722的博客
08-13 269
汉诺塔的问题大家都已经很熟悉了，有三个柱子，每个柱子上有一些大小不一的金片，要把金片从 AA柱移动到 CC柱，可以借助 B 柱，请问 n个金片的情况下，需要最少移动多少次？输入一个整数 nn 代表金片的数量（n≤20）。一个整数，代表 n 个金片的移动次数。
【数据结构】链表
weixin_74076508的博客
08-13 797
链表的基本结构由节点组成，每个节点包含数据和指向下⼀个节点的指针。我们就可以定义这样的一个结构int data;//存储的数据//后继节点}SLTNode;typedef关键字在这里用于为结构体定义一个新的类型名Node这使得在后续的代码中，可以直接使用Node来声明该结构体类型的变量，而无需再使用这种较为繁琐的形式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值