4.2较难的栈和队列OJ

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

本篇博客来手撕三道稍有难度的栈和队列相关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);
}
E_han
关注
  • 12
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[05数据结构](初阶)二叉树的基本理解、堆的概念和结构及二叉树OJ面试题
再吃一个橘子
11-16 909
满二叉树是特殊的完全二叉树
《代码随想录1-7章》二刷题解及心得体会
qq_44732492的博客
03-15 2604
0 前言   昨天结束了《代码随想录》一刷（只看不上机操作，目的是对算法建立初步的认识），历时一个多月。在第一遍阅读之后，有许多不理解的地方，在书中用问号标识。第二遍阅读本书目的就是想通过上机训练将之前的疑惑解开。另外，本书题解和内容仍有一小部分错误，希望在此更正。 1 第一章 面试要知己知彼   本章主要介绍面试流程、如何写简历及代码规范。本书中的C++代码严格按照Google C++编程规范：     1.操作符左右一定有空格。     2.分隔符（,和;)的前一位没有空格，后一位有空格。     3.
实验大纲：数据结构
zhrb
03-19 861
目录一. 入门1. 数据结构入门1.1 CodeBlocks的使用(或直接使用DEV C++、Visual Studio)1.2 C++语言基础2. Git入门二.线性表1. 顺序表2. 链表3. 栈和队列4.字符串(自行完成)三.树四.查找与排序4.1 查找4.2 排序4.3 综合4.4 参考资料资料1:STL中set、map容器的用法资料2:倒排索引五.图任务1：图的创建与遍历任务2：最小生...
about云大数据面试宝典 大公司面试一般用不到
okbin1991的博客
10-19 4119
阿里四轮面试总结 第一轮面试电话(**5** 月 6 号)： 1.自我介绍，包括做过项目。 2.有看过哪些 JDK 源码，了解哪些常用库。 3.集合框架 HashMap 的扩容机制，ConcurrnetHashMap 的原理 4.jvm 内存模型与 gc 内存回收机制 5.classloader 结构，是否可以自己定义一个 java.lang.String 类，为什么？ 双亲代理机制。 ...
【算法入门】广度/宽度优先搜索(BFS)
谙忆-陈浩翔
08-28 1802
广度/宽度优先搜索(BFS) 【算法入门】 1.前言 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域，故得名。  一般可以用它做什么呢？一个最直观经典的例子就是走迷宫，我们从起点开始，找出到终点的最短路程，很多最短路径算法就是基于广度优先的思想
基于开放式云平台的开源在线评测系统设计与实现
热门推荐
zhblue的专栏
02-14 1万+
基于开放式云平台的开源在线评测系统设计与实现 张浩斌 ZHANG Hao-Bin 浙江传媒学院 新媒体学院 浙江省 杭州市 310018 Department of New Media, Zhejiang University of Mediaand Communications, Hanzhou 310018, China   Design and Implementation of
数据结构学习(用c语言实现)
qq_62123793的博客
09-23 280
数据结构自学笔记
广度/宽度优先搜索(BFS) 【算法入门】
Calix_Guo的博客
05-30 777
1.前言广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域，故得名。 一般可以用它做什么呢？一个最直观经典的例子就是走迷宫，我们从起点开始，找出到终点的最短路程，很多最短路径算法就是基于广度优先的思想成立的。算法导论里边会给出不少严格的证明，我想尽量写得通俗一点，因此采用一些直观的讲法来伪装成证...
Zookeeper
木易三水良
10-24 1453
Zookeeper 2020-4-28 ——https://www.bilibili.com/video/BV1M741137qY?p=74 https://zookeeper.apache.org/ 一、简介/快速入门 ZooKeeper is a centralized service for maintaining configuration information, naming, providing distributed synchronization, and providing group
"异步方法调用：面向对象并发模型的运行时环境和操作语义
理论计算机科学电子笔记117（2005）375-392www.elsevier.com/locate/entcs具有异步方法调用的并发对象运行时环境Einar Broch Johnsen，Olaf Owe，and Eyvind W.阿克塞尔森信 息 学 系 ， 奥 斯 陆 大 学 POBox 1080...
【大总结2】大学两年，写了这篇几十万字的干货总结_万字 cndn
2401_84617533的博客
04-27 757
这部分在我看来是最有意思的，我们有必要了解底层数据结构的实现，这也是我最感兴趣的。比如，你知道redis中的字符串怎么实现的吗？为什么这么实现？你知道redis压缩列表是什么算法吗？你知道redis为什么抛弃了红黑树反而采用了跳表这种新的数据结构吗？你知道hyperloglog为什么用如此小的空间就可以有这么好的统计性能和准确性吗？你知道布隆过滤器为什么这么有效吗？有没有数学证明过？你是否还能很快写出来快排？或者不断优化性能的排序？是不是只会调库了甚至库函数怎么实现的都不知道？真的就是快排？
嵌入式软件
qq_44394562的博客
10-22 531
static限制作用域在C语言中，关键字static有三个明显的作用：1）、用static修饰局部变量：使其变为静态存储方式，那么这个局部变量执行完成时不会被释放，继续保留在内存中。2）、用static修饰全局变量：使其在本文件内部有效，而其他文件不可以被引用或链接该变量。3）、用static修饰函数：使函数只在本文件内部有效，对其他文件不可见，这样的函数又叫静态函数；使用静态函数的好处，不用担心与其他文件的同名函数产生干扰，也是对函数本身保护的一种机制。
计算机网络知识点
weixin_44705725的博客
01-03 1296
1518，头信息有14字节，尾部校验和FCS占了4字节，所以真正留给上层协议传输数据的大小就是：1518 - 14 - 4 = 1500，那么，1518这个值又是从哪里来的呢？MSL（最大分段寿命），即一个 TCP 分段可以存在于互联网系统中的最大时间，TCP允许不同的实现可以设置不同的MSL值。通常为4分钟。
数据结构——树的三种表示方法
2301_80401288的博客
08-24 1285
数据结构——树的三种表示方法 求点赞收藏关注！！！
数据结构之链表
WSH2012ffff的博客
08-27 354
本文从链表的定义、创建、遍历、插入、删除等多个方面进行了详细讲解，希望能够帮助大家更好地理解和掌握c/c++语言中的链表操作。链表是一种动态数据结构，由节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表是计算机科学中常见的一种数据结构，c/c++语言中也有着丰富的链表操作函数库。在c/c++中，可以使用结构体来定义一个节点，并用指针来表示节点之间的关系，从而实现链表。链表遍历是指按照一定的顺序依次访问链表中的每一个节点。链表删除是指在链表中删除一个节点。
Java-数据结构-包装类和认识泛型 !!!∑(ﾟДﾟノ)ノ
最新发布
2303_80388948的博客
08-27 841
对于泛型就是：使用与许多许多类型。从代码上来说呢，就是对类型实现了参数化。对于引出泛型，我们来实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。在这里呢，我们用 Object类 来进行创建数组，Object是所有类的父类，但是呢，我们在这里呢就有一些问题，我们来看看：1、在这里呢，我们这个数组当中可以存放任何类型2、我们每次进行的到值时候呢，都要进行强转。
数据结构（邓俊辉）学习笔记】优先级队列 08——左式堆：结构
weixin_44399845的博客
08-23 1383
学习左式堆的结构
初阶数据结构之计数排序
Mr_Xuhhh的博客
08-21 417
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，⽽在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；A:通俗点来说就是 ，举一个例子，2，1，3，4，2 稳定的情况是排完序后相同的数字前后顺序一致，不稳定则相反。2）根据统计的结果将序列回收到原来的序列中。直接选择排序：5 8 5 2 9。空间复杂度： O(range)希尔排序：5 8 2 5 9。堆排序：2 2 2 2。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值