数据结构 | 详解栈实现队列&队列实现栈

最新推荐文章于 2024-06-05 08:55:52 发布
最新推荐文章于 2024-06-05 08:55:52 发布
阅读量397 收藏 7
点赞数 11
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mooridy/article/details/138868368
版权

1. 232. 用队列实现栈

⛱️

🌴深度剖析

1️⃣最关键的push和pop过程如何模拟？

pop:

step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正

step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作

step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。

🥳代码实现

typedef int QDataType;

typedef struct QListNode {
    struct QListNode* next;
    QDataType data;
} QNode;

// 队列的结构
typedef struct Queue {
    QNode* phead;
    QNode* ptail;
    int size;
} Queue;
// 初始化队列
void QueueInit(Queue* q) {
    assert(q);
    q->phead = q->ptail = NULL;
    q->size = 0;
}
// 队尾入队列
void QueuePush(Queue* q, QDataType data) {
    assert(q);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL) {
        perror("malloc fail!");
        exit(1);
    } else {
        newnode->data = data;
        newnode->next = NULL;
        if (q->ptail == NULL) {
            q->phead = q->ptail = newnode;
            q->size++;
        } else {
            q->ptail->next = newnode;
            q->ptail = newnode;
            q->size++;
        }
    }
}
// 队头出队列
void QueuePop(Queue* q) {
    assert(q);
    assert(q->size != 0);
    if (q->phead->next == NULL) {
        free(q->ptail);
        q->ptail = q->phead = NULL;
        q->size--;
    } else {
        QNode* next = q->phead->next;
        free(q->phead);
        q->phead = next;
        q->size--;
    }
}
// 获取队列头部元素
QDataType QueueFront(Queue* q) {
    assert(q);
    return q->phead->data;
}
// 获取队列队尾元素
QDataType QueueBack(Queue* q) {
    assert(q);
    return q->ptail->data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q) {
    assert(q);
    return q->size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q) {
    assert(q);
    return !QueueSize(q);
}
// 销毁队列
void QueueDestroy(Queue* q) {
    assert(q);
    while (q->size) {
        QueuePop(q);
    }
    q->phead = NULL;
    q->ptail = NULL;
}

typedef struct {
    Queue Q1;
    Queue Q2;
} MyStack;

MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->Q1);
    QueueInit(&obj->Q2);
    return obj;
}

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(notempty)) {
        empty = &obj->Q2;
        notempty = &obj->Q1;
    }
    // 把notempty中前size-1个一到empty
    while (QueueSize(notempty) > 1) {
        QueuePush(empty, QueueFront(notempty));
        QueuePop(notempty);
    }
    int ret = QueueFront(notempty);
    QueuePop(notempty);
    return ret;
}

int myStackTop(MyStack* obj) {
    if (!QueueEmpty(&obj->Q2)) {
        return QueueBack(&obj->Q2);
    }else{
        return QueueBack(&obj->Q1);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->Q2)&&QueueEmpty(&obj->Q1);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->Q1);
    QueueDestroy(&obj->Q2);
    free(obj);
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);

 * int param_2 = myStackPop(obj);

 * int param_3 = myStackTop(obj);

 * bool param_4 = myStackEmpty(obj);

 * myStackFree(obj);
*/

2. 232. 用栈实现队列

⛱️试题链接戳这里！

🌴深度剖析

1️⃣最关键的push和pop过程如何模拟？

🥳代码实现

方法一（推荐）

typedef int STDataType;

typedef struct stack {
	STDataType* a;
	int capacity;
	int top;
}Stack;

void StackInit(Stack* ps) {
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

void StackPush(Stack* ps, STDataType data){
	assert(ps);
	int newcapacity = 0;
	if (ps->top ==ps->capacity) {
		newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp==NULL) {
			perror("realloc fail");
			exit(1);
		}
		else {
			ps->a = tmp;
		}
	}
	ps->a[ps->top] = data;
	ps->capacity = newcapacity;
	ps->top++;
	
}

void StackPop(Stack* ps) {
	assert(ps);
	assert(ps->top>0);
	ps->top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps) {
	assert(ps);
	
	int top = ps->top - 1;
	return ps->a[top];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps) {
	assert(ps);
	return ps->top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps) {
	assert(ps);
	if (StackSize(ps) == 0) 
	{
		return true;
	}
	else {
		return false;
	}

	
}
// 销毁栈 
void StackDestroy(Stack* ps) {
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;

}


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);
   return;
}

int myQueuePop(MyQueue* obj) {
  int ret=myQueuePeek(obj);
  StackPop(&obj->popst);
  return ret;
}

int myQueuePeek(MyQueue* obj) {
       if (StackEmpty(&obj->popst)) {//如果popst空了的话，我们就要往里面导入pushst中的数据
    while(StackSize(&obj->pushst)){
         StackPush(&obj->popst, StackTop(&obj->pushst));
        StackPop(&obj->pushst);
    } 
    }
    int ret=StackTop(&obj->popst);

    return ret;
    }
    


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

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

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

方法二

typedef int STDataType;

typedef struct stack {
	STDataType* a;
	int capacity;
	int top;
}Stack;

void StackInit(Stack* ps) {
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

void StackPush(Stack* ps, STDataType data){
	assert(ps);
	int newcapacity = 0;
	if (ps->top ==ps->capacity) {
		newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp==NULL) {
			perror("realloc fail");
			exit(1);
		}
		else {
			ps->a = tmp;
		}
	}
	ps->a[ps->top] = data;
	ps->capacity = newcapacity;
	ps->top++;
	
}

void StackPop(Stack* ps) {
	assert(ps);
	assert(ps->top>0);
	ps->top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps) {
	assert(ps);
	
	int top = ps->top - 1;
	return ps->a[top];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps) {
	assert(ps);
	return ps->top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps) {
	assert(ps);
	if (StackSize(ps) == 0) 
	{
		return true;
	}
	else {
		return false;
	}

	
}
// 销毁栈 
void StackDestroy(Stack* ps) {
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;

}


typedef struct {
    Stack s1;
    Stack s2;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->s1);
    StackInit(&obj->s2);
    return obj;
}

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

int myQueuePop(MyQueue* obj) {
    Stack* empty = &obj->s1;
    Stack* notempty = &obj->s2;
    if (StackEmpty(notempty)) {
        empty = &obj->s2;
        notempty = &obj->s1;
    }
    
    while(StackSize(notempty)>1){
         StackPush(empty, StackTop(notempty));
        StackPop(notempty);
    }
    int ret=StackTop(notempty);
    StackPop(notempty);
    while(StackSize(empty)){
         StackPush(notempty, StackTop(empty));
        StackPop(empty);
    }
    return ret;
}

int myQueuePeek(MyQueue* obj) {
     Stack* empty = &obj->s1;
    Stack* notempty = &obj->s2;
    if (StackEmpty(notempty)) {
        empty = &obj->s2;
        notempty = &obj->s1;
    }
    
    while(StackSize(notempty)>1){
         StackPush(empty, StackTop(notempty));
        StackPop(notempty);
    }
    int ret=StackTop(notempty);
    while(StackSize(empty)){
         StackPush(notempty, StackTop(empty));
        StackPop(empty);
    }
    return ret;
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->s1)&&StackEmpty(&obj->s2);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->s1);
    StackDestroy(&obj->s2);
    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

mooridy
关注
  • 11
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java实现队列数据结构代码详解
08-28
主要介绍了java实现队列数据结构代码详解，简单介绍了队列结构以应用场景，涉及详细实现代码，还是比较不错的，这里分享给大家，需要的朋友可以参考下。
详解数据结构C语言实现之循环队列
09-01
在我们生活中有很多队列的影子，可以说与时间相关的问题，一般都会涉及到队列问题；本文详细介绍了如何使用C语言实现循环队列，下面一起来看看。
java 数据结构中栈和队列的实例详解
08-29
主要介绍了java 数据结构中栈和队列的实例详解的相关资料,主要使用数组与线性表的方法来实现，需要的朋友可以参考下
C++ 数据结构实现两个栈实现一个队列
08-31
主要介绍了详解C++ 数据结构实现两个栈实现一个队列的相关资料,需要的朋友可以参考下
数据结构栈和队列详解.zip
04-03
栈和队列是两种非常基础且重要的数据结构，它们在计算机科学和软件开发中都有着广泛的应用。下面我将详细解释这两种数据结构。 栈（Stack） 栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。这一端通常被称为栈顶，而另一端则称为栈底。栈中的数据元素遵守后进先出（LIFO，Last In First Out）的原则。也就是说，最后进入栈的元素将最先被取出。 栈的基本操作主要有两种：入栈（push）和出栈（pop）。入栈操作就是在栈顶添加一个新的元素，而出栈操作则是移除栈顶的元素。另外，栈通常还提供了查看栈顶元素的操作，但不移除它。
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
[详解栈和队列]数据结构之栈与队列
Philosophy7的博客
05-12 3605
✅作者简介：大家好,我是Philosophy7？让我们一起共同进步吧！🏆 📃个人主页：Philosophy7的csdn博客 🔥系列专栏： 👑哲学语录: 承认自己的无知，乃是开启智慧的大门 💖如果觉得博主的文章还不错的话，请点赞👍+收藏⭐️+留言📝支持一下博>主哦🤞 文章目录栈和队列1.物理结构和逻辑结构2.什么是栈2.1栈的基本操作3.什么是队列队列的基本操作小结 栈和队列 1.物理结构和逻辑结构 再了解栈和队列之前，我们要先知道什么是逻辑结构和物理结构。 逻辑结构: 按照逻辑结构划分:数据结.
数据结构——栈的详解
晴空๓
04-20 7万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
[数据结构] 用两个栈实现队列详解
weixin_67596609的博客
03-22 3619
在数据结构中，栈和队列是较为常见的两种数据结构。。那怎么用栈去实现队列呢？此问题在面试中也是高频出现的问题。本篇文章会给出详细解释。
【C语言数据结构】详解栈与队列（下）（栈与队列相互实现、循环队列）
dhgiuyawhiudwqha的博客
05-04 644
我们已经知道，队列遵循FIFO（先进先出）原则，而栈遵循FILO（先进后出）原则，想用栈来实现队列的先进先出，可以用两个栈，一个来模拟入队列，一个来模拟出队列。我们从空栈来入队列，假设我们先入1，2，3三个数，此时我们要出队列，要出两个数，该怎么做呢。首先我们把栈1中的数全部挪到栈2中，挪动方式遵循出入栈的原则。然后把S2栈顶的两个数据出栈即可我们可以验证一下，1先入队，然后是2和3，出队列的先是1，然后是2，符合先进先出原则。
数据结构之栈与队列详解
Ruiren_的博客
01-20 1794
栈和队列是一种特殊的线性结构，他与之前学的线性结构不同，栈和队列是拥有一种特殊规则的线性结构，虽然它是用数组或者链表实现，但是只有符合这种规则才能被称作栈或者队列
十分钟手撕栈与队列——栈与队列实现详解
qq_61500888的博客
03-27 2634
十分钟带你一命通关栈与队列 既然选择远方，只顾风雨兼程！
数据结构——二叉树
2301_80097874的博客
06-04 695
二叉树如其名，就是有两个分岔树枝的树，如下图。每个节点下面都有两个及两个以下的节点，就被称为二叉树。现实中的二叉树二叉树。
二叉树及其在C语言中的实现A
2301_79642159的博客
06-01 358
本文介绍了二叉树的基本概念、特性以及在C语言中的实现方式。通过定义二叉树节点的结构体，我们可以轻松地实现二叉树的插入、遍历等操作。二叉树作为数据结构的重要组成部分，对于理解树形结构、递归算法等方面都有着重要意义。更多实现在另一篇文章,希望能够帮助读者更好地掌握二叉树的相关知识。
【数据结构】二叉搜索树--BST，Binary Search Tree
Z1tai的博客
06-04 781
二叉搜索树是一种重要且常用的数据结构，其节点具有左子树和右子树，且左子树所有节点值小于根节点，右子树所有节点值大于根节点，这种特性使得查找、插入和删除操作非常高效。然而，如果树结构不平衡，会导致性能下降。因此，对于实现二叉搜索树的算法和数据结构有深入了解是至关重要的，同时也需要了解其他优化的数据结构如AVL树、红黑树等。
数据结构-哈希表
weixin_42035282的博客
06-01 476
哈希表是一种高效的数据结构，它可以提供快速的插入、删除和查找操作。哈希表的基本思想是将键通过一个哈希函数映射到一个连续的地址空间上，然后在这个地址空间上进行查找、插入和删除操作。下面将详细介绍哈希表的相关概念和实现方法。
Go 语言中的切片：灵活的数据结构
最新发布
栗筝i的博客
06-05 1403
切片是对底层数组的连续片段的引用，使得切片成为了引用类型。它的长度可以在运行时改变，其长度永远不会超过其容量，即。切片的灵活性在于，你可以使用切片来访问数组的任何连续部分，而无需复制其元素。
数据结构之快速排序算法（快排）【图文详解】
LiU11e的博客
06-04 672
本文所展示内容位数据结构排序算法之快速排序，其可分类为四种排序方法，并附有快速排序的优化，图文详解
数据结构-队列的应用
07-28
- *1* *2* *3* [算法与数据结构-队列的详解以及应用](https://blog.csdn.net/qq_53283658/article/details/122463796)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值