4.2较难的栈和队列OJ

news2024/9/22 13:26:05

本篇博客来手撕三道稍有难度的栈和队列相关OJ，题目均已插入超链接，点击即可跳转~

一、设计循环队列

1、题目描述

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出，即first in first out）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
描述

2、题目分析

（1）思路

这里采用数组的结构实现，核心问题就是解决下标的回绕问题，防止下标越界，怎么在走到数组尾部的时候绕回头部去，实现出循环的效果

  1. k：空间的大小
  2. 定义变量head和tail：head指向队头数据，tail指向队尾数据的下一个位置
  3. push表示插入，pop表示删除
①先感受一下插入数据和删除数据时head和tail的变化

插入和删除过程head和tail的变化

②关键问题

如何判断数组是空的还是满的？
空数组or满数组
不难看出，不论数组是空的还是满的，下标特点都是head=tail。为了区分数组是满的还是空的，我们可以多开辟一个空间，但是数组能存储的最大数据量不变，以此进行区分
我们再来感受一下进行插入删除操作时下标的变化情况额外多开一个空间
注意:要小心（tail+1）越界的情况，单独拿出来讨论一下：当tail位于下标为k处时，head位于下标为0处，如图所示
特殊情况
这样子判断队列是空还是满的就实现出来了

//判空，为空返回true
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    if(obj->head==obj->tail)
        return true;
    return false;
    
}

//判满，满了返回true
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    //if(obj->head==(obj->tail+1)%(obj->k+1))
        //return true;
    if((obj->head==obj->tail+1)||(obj->head==0&&obj->tail==obj->k))//当tail位于k处单独讨论，此时head位于下标为0处
        return true;
    else
        return false;
}

（2）具体代码实现

其余函数同样要注意head和tail的越界问题，解决好回绕的功能即可
具体题解如下

typedef struct 
{
    int*arr;
    int head;
    int tail;//指向最后一个元素的下一个位置
    int k;//数组的空间大小
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);
//创建循环队列
MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* queue=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    queue->arr=(int*)malloc(sizeof(int)*(k+1));
    queue->k=k;
    queue->head=queue->tail=0;
    return queue;
}

//向循环队列中尾插一个元素，如果成功则返回真
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))//判满
        return false;
    obj->arr[obj->tail]=value;
    if(obj->tail==obj->k)//直接obj->tail++会导致越界，要回绕到数组头部
        obj->tail=0;
    else
        obj->tail++;
    return true;
}

//头删
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))//空队列
        return false;
    else
        if(obj->head==obj->k)//解决回绕问题
            obj->head=0;
        else
            obj->head++;
    return true;
}

//获取队首元素，如果为空返回-1
int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->arr[obj->head];
}

//获取队尾元素，如果为空返回-1
int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))//判空
        return -1;
    if(obj->tail==0)//注意obj->tail的特殊情况(即回绕问题)
        return obj->arr[obj->k];
    else
        return obj->arr[obj->tail-1];
}   

//判空，为空返回true
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    if(obj->head==obj->tail)
        return true;
    return false;
    
}

//判满，满了返回true
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    //if(obj->head==(obj->tail+1)%(obj->k+1))
        //return true;
    if((obj->head==obj->tail+1)||(obj->head==0&&obj->tail==obj->k))//当tail位于k处单独讨论，此时head位于下标为0处
        return true;
    else
        return false;
}

//销毁队列
void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->arr);
    free(obj);
    obj=NULL;
    
}

二、用队列实现栈

1、题目描述

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
C语言本身并没有实现队列，需要将我们自己实现好的队列拿过来（在4.1中有队列的实现）

2、题目分析

（1）思路：保持只有一个队列有数据

  • 在不为空的队列入数据
  • 出数据时，把目标数据前面的数据导入到空队列里
    经过这两步操作，即可完成栈（即后进先出）的效果
    思路分析

（2）所有结构体之间的关系

所有结构体之间的关系
（3）具体代码实现

//Queue.h
// 链式结构：表示队列 
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;
//Queue.c
// 初始化队列 
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

// 队尾入队列 
void QueuePush(Queue* pq, QDataType data)
{
	assert(pq);
	if (pq->phead == NULL)//空队列
	{
		QNode* newnode = (QNode*)malloc(sizeof(QNode));
		if (newnode == NULL)
		{
			perror("malloc failed!");
			return;
		}
		newnode->next = NULL;
		newnode->data = data;

		pq->phead = newnode;
		pq->ptail = pq->phead;
		pq->size++;
	}
	else
	{
		QNode* newnode = (QNode*)malloc(sizeof(QNode));
		if (newnode == NULL)
		{
			perror("malloc failed!");
			return;
		}
		newnode->next = NULL;
		newnode->data = data;

		pq->ptail->next = newnode;
		pq->ptail = newnode;
		pq->size++;
	}
}

// 队头出队列（头删）
void QueuePop(Queue* pq)
{
	assert(pq);
	if (pq->phead->next == NULL)//只有一个节点
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
		pq->size = 0;
	}
	else
	{
		QNode* del = pq->phead;
		pq->phead = pq->phead->next;
		free(del);
		del = NULL;
		pq->size--;
	}
}

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

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

// 获取队列中有效元素个数 
int QueueSize(Queue* pq)
{
	return pq->size;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* pq)
{
	if (pq->size == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

// 销毁队列 
void QueueDestroy(Queue* pq)
{
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* del = pcur;
		pcur = pcur->next;
		free(del);
		del = NULL;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

typedef struct 
{
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() 
{
    MyStack*stack=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&stack->q1);
    QueueInit(&stack->q2);
    return stack;
}
//将元素x压入栈顶
void myStackPush(MyStack* obj, int x) 
{
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);

    }
}
//移除并返回栈顶元素
int myStackPop(MyStack* obj) 
{
    Queue* Empty=&(obj->q1);
    Queue* notEmpty=&(obj->q2);
    if(QueueEmpty(&obj->q2))
    {
        Empty=&(obj->q2);
        notEmpty=&(obj->q1);
    }
    //此时Empty是空队列，notEmpty是非空队列
    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))
    {
        return QueueBack(&obj->q2);
    }
    else
    {
        return QueueBack(&obj->q1);
    }
    
}
//判空
bool myStackEmpty(MyStack* obj) 
{
    if(QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2))
        return true;
    else
        return false;
}
//销毁栈
void myStackFree(MyStack* obj) 
{
    free(obj);
}

三、用栈实现队列

1、题目描述

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

2、题目分析

（1）思路

和上一道题类似，可以采用导数据的操作。建立两个栈pushst（用来入数据）和popst（用来出数据），本题也需要把自己实现好的栈拿过来（4.1中有栈的实现）

先来感受一下插入删除时数据的变化情况
数据变化情况
不难看出，在入数据的时候放入pushst，出数据在popst，若popst为空，则重新导入数据，这样子操作下来数据就满足了队列(后进后出)的要求

（2）具体代码实现

//Stack.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 
bool StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

//Stack.c
void StackInit(Stack* ps)// 初始化栈 
{
	assert(ps);
	ps->_a = NULL;
	ps->_top = 0;
	ps->_capacity = 0;
}

void StackPush(Stack* ps, STDataType data)//入栈
{
	assert(ps);
	if (ps->_capacity == ps->_top)
	{
		int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a,newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc failed!");
			return;
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
	ps->_a[ps->_top] = data;
	ps->_top++;
}

void StackPop(Stack* ps)//出栈
{
	assert(ps);
	assert(ps->_top > 0);
	ps->_top--;
}

STDataType StackTop(Stack* ps)//获取栈顶元素
{
	assert(ps);
    assert(ps->_top > 0);
	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 StackDestroy(Stack* ps)
{
	assert(ps);
	ps->_capacity =  0;
	ps->_top = 0;
	free(ps->_a);
	ps->_a = NULL;
}




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


MyQueue* myQueueCreate() //初始化自己的队列
{
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->pushst);
    StackInit(&obj->popst);
    return obj;
}

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

int myQueuePop(MyQueue* obj) //从队列的开头移除并返回元素
{
    //此处可以直接调用myQueuePeek函数来获取队列开头的元素
    int top = myQueuePeek(obj);
    StackPop(&obj->popst);//popst栈顶元素出栈
    return top;
}

int myQueuePeek(MyQueue* obj)//返回队列开头的元素 
{
    if(StackEmpty(&obj->popst))//popst中没有数据，此时要从pushst导入数据到popst当中
    {
        while(!StackEmpty(&obj->pushst))
        {
            int tmp =  StackTop(&obj->pushst);
            StackPush(&obj->popst, tmp);
            StackPop(&obj->pushst);
        }
    }
    int top = StackTop(&obj->popst);
    return top;
}

bool myQueueEmpty(MyQueue* obj) 
{
    if(StackEmpty(&obj->pushst)&&StackEmpty(&obj->popst))
    {
        return true;
    }
    return false;
    
}

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2071845.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

day39.动态规划+MySQL数据库复习

day39.动态规划+MySQL数据库复习

一.动态规划: 198.打家劫舍 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定…
阅读更多...
深入浅出消息队列----【Broker 集群】

深入浅出消息队列----【Broker 集群】

深入浅出消息队列----【Broker 集群】 单 master多 master多 master 多 slave 异步复制多 master 多 slave 同步复制Dledger 本文仅是文章笔记，整理了原文章中重要的知识点、记录了个人的看法 文章来源：编程导航-鱼皮【yes哥深入浅出消息队列专栏】 Brok…
阅读更多...
LeetCode100.删除链表的倒数第 N 个结点

LeetCode100.删除链表的倒数第 N 个结点

1. 题目大意 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。 进阶：你能尝试使用一趟扫描实现吗？ 2. 思路分析 输入：head [1,2,3,4,5], n 2 输出：[1,2,3,5]我们可以先遍历一遍链表求出…
阅读更多...
Data Localization Software Architecture - SAAS Localization CyberWin Future

Data Localization Software Architecture - SAAS Localization CyberWin Future

一、Future Window Industry Application Cross-platform Architecture The cross-platform architecture of Future Window adopts Hybird (hybrid mode mobile application), which is a mobile application development model that combines the characteristics of native …
阅读更多...
golang学习笔记——grom连接mysql

golang学习笔记——grom连接mysql

GORM 指南 The fantastic ORM library for Golang aims to be developer friendly. Golang的ORM库旨在对开发人员友好。 特性 全功能 ORM关联 (Has One，Has Many，Belongs To，Many To Many，多态，单表继承)Create&…
阅读更多...
【Redis】渐进式遍历和数据库管理

【Redis】渐进式遍历和数据库管理

渐进式遍历和数据库管理 渐进式遍历scan 数据库管理切换数据库清除数据库 渐进式遍历 Redis 使⽤ scan 命令进⾏渐进式遍历键，进⽽解决直接使⽤ keys 获取键时可能出现的阻塞问题。每次 scan 命令的时间复杂度是 O(1)，但是要完整地完成所有键的遍历&…
阅读更多...
数学建模笔记（三）：拟合算法

数学建模笔记（三）：拟合算法

前面介绍的插值方法，我们可以发现他的特点在于最终得到的曲线一定要经过已经给出的样本点的，而这次要介绍的拟合方法的区别在于，拟合不要求曲线一定要经过所有的样本点，只要这个曲线与样本点之间的误差足够小，距离足够…
阅读更多...
unity AssetBundle 使用_什么是AssetBundle_导入必要的插件_创建AssetBundles_AB包资源下载_大文件下载

unity AssetBundle 使用_什么是AssetBundle_导入必要的插件_创建AssetBundles_AB包资源下载_大文件下载

一、什么是AssetBundle？ 定义AssetBundle。 AssetBundle 是一个存档文件，包含可在运行时由 Unity 加载的特定于平台的非代码资源（比如模型、纹理、预制件、音频剪辑甚至整个场景）。AssetBundle 可以表示彼此之间的依赖关系&…
阅读更多...
PD取电快充协议方案

PD取电快充协议方案

PD快充协议是通过调整电压和电流来提供不同的充电功率。它采用了一种基于USB-C端口的通信协议，实现了充电器于设备之间的信息交换。在充电过程中设备会向充电器发出请求，要求提供不同的电压和电流，充电器接收到请求后，会根据设备的…
阅读更多...
数据本地化软件架构-SAAS本地化未来之窗行业应用跨平台架构

数据本地化软件架构-SAAS本地化未来之窗行业应用跨平台架构

一、未来之窗行业应用跨平台架构 未来之窗跨平台架构采用Hybird（混合模式移动应用）是一种结合了原生应用（Native App）和网页应用（Web App）特点的移动应用开发模式。 二、特点 2.1. 开发成本相对较低 - 与…
阅读更多...
C++码表之Unicode

C++码表之Unicode

今日诗词： 折花逢驿使，寄与陇头人。 江南无所有，聊赠一枝春。 ——《赠范晔诗》【南北朝】陆凯 引言： 上一期我们说到了ASCII码表，这是一种现如今不是那么通用的机制，随着计算机的普及，越来越…
阅读更多...
电脑ip地址为什么会自己变更？电脑ip怎么改

电脑ip地址为什么会自己变更？电脑ip怎么改

在当今这个高度依赖互联网的时代，IP地址作为网络设备的身份标识，其稳定性和可管理性对于网络通信的顺畅至关重要。然而，许多用户可能会遇到电脑IP地址自动变更的情况，这不仅可能影响到网络连接的稳定性，还可能给远程访…
阅读更多...
怎么使用win10录屏快捷键 ？分享三款录屏工具

怎么使用win10录屏快捷键 ？分享三款录屏工具

录屏软件在我们日常生活中越来越常见，无论是做教程、记录游戏精彩瞬间还是进行远程教学，一个好的录屏软件都能让我们的生活变得更加便捷。不少人也会选怎win10自带的录屏，使用WIN10 录屏快捷键【winG】，就可以唤出录屏工具&#x…
阅读更多...
【Node】【1】node和nvm安装

【Node】【1】node和nvm安装

安装nvm、node、npm 安装node 18 ，最简单的办法是使用nvm，就不用手动安装了，那么就得先安装nvm。 NVM 是Node Version Manager，用于管理 Node.js 版本。你设备上的不同项目可能使用不同版本的 Node.js。通过 nvm，用户…
阅读更多...
Redis | 非关系型数据库Redis的初步认识

Redis | 非关系型数据库Redis的初步认识

本节内容相对理论，着重看基础通用命令这一节 Redis 非关 kv型{字典} 概念应用ubuntu安装配置 windows添加密码 可能问题【ubuntu】远程连接 基础通用命令 ⭐ 概念 特点： 1、开源的，使用C编写，基于内存且支持持久化 2、没有表 支持…
阅读更多...
ssrf例题分析

ssrf例题分析

我们第一步先在ubuntu中解压web-ssrfme.zip，更新镜像后重启容器。 我们可以看到代码中成功拉取到ssrfme镜像 ig(preg_match(/file\:\/\/｜dict\:\/\/.｜\.\.\/｜127.0.0.1｜localhost/is,$url,$match)) 使用端口访问文件&…
阅读更多...
【Linux系列】SH 与 BASH 的区别：深入解析与使用案例

【Linux系列】SH 与 BASH 的区别：深入解析与使用案例

💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…
阅读更多...
Leetcode JAVA刷刷站（93）复原IP地址

Leetcode JAVA刷刷站（93）复原IP地址

一、题目概述 二、思路方向 为了解决这个问题，我们可以使用回溯算法。回溯算法在这里非常适用，因为我们需要尝试在字符串中的不同位置插入点（.）来分割出可能的IP地址段，并且需要验证每个段是否满足条件（即…
阅读更多...
如何使用ssm实现铁岭河医院医患管理系统+vue

如何使用ssm实现铁岭河医院医患管理系统+vue

TOC ssm077铁岭河医院医患管理系统vue 系统概述 进过系统的分析后，就开始记性系统的设计，系统设计包含总体设计和详细设计。总体设计只是一个大体的设计，经过了总体设计，我们能够划分出系统的一些东西，例如文件、文…
阅读更多...
从web.xml动态读取sunspringmvc.xml文件

从web.xml动态读取sunspringmvc.xml文件

文章目录 1.问题分析1.SunWebApplicationContext.java 中sunspringmvc.xml是写死的2.但是web.xml已经配置了init-param，所以应该是可以读取的 2.具体实现1.SunDispatcherServlet.java 得到ServletConfig传递给Spring容器完成初始化2.SunWebApplicationContext.java …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023