栈和队列(附oj题)

最新推荐文章于 2024-09-13 17:05:05 发布
最新推荐文章于 2024-09-13 17:05:05 发布
阅读量94 收藏 1
点赞数 3
分类专栏： 初阶数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64404343/article/details/128351579
版权

栈的实现

 

接口函数：

// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

通过栈的接口函数我们发现栈在栈顶插入和删除元素，如果采用链式结构，每次插入删除都要找尾，因此效率较低，而采用顺序结构效率较高，所以顺序结构更优。

顺序结构：

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;

完整代码： 

typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
void check(Stack* ps);
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a =(STDataType*) malloc(sizeof(STDataType) * 4);
	ps->_capacity = 4;
	ps->_top = 0;
}
void check(Stack* ps)
{
	assert(ps);
	if (ps->_capacity == ps->_top)
	{
		STDataType* tmp = (STDataType*)realloc(ps->_a, sizeof(STDataType) * (ps->_capacity) * 2);
		if (tmp == NULL)
		{
			perror("malloc:");
			exit(-1);
		}
		ps->_a = tmp;
		ps->_capacity *= 2;
	}
}
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	check(ps);
	ps->_a[ps->_top] = data;
	ps->_top++;
}
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top);
	ps->_top--;
}
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top);
	return ps->_a[ps->_top - 1];
}
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0 ? 1 : 0;
}
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_capacity = ps->_top = 0;
}

队列的实现 

 

接口函数：

void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

队列要实现头插和尾删操作，由于队列有队头和队尾，因此采用顺序结构效率较低，而采用链式结构效率高，所以链式结构更优。

 队列结构：

typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;//队头
	QNode* _rear;//队尾
}Queue;

完整代码： 

typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

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

总结：栈的规则是后进先出，而队列规则是先进先出。 

栈和队列oj题 

 用队列实现栈

解题思路：

采用两个队列，保持一个队列为空，另一个不为空，向不为空的队列插入元素实现压栈操作，

出栈：把不为空的队列中元素移到为空的队列中，直到只剩一个元素为止，然后删除这个元素。 

/用队列实现栈
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* s = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&s->q1);
    QueueInit(&s->q2);
    return s;
}

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* nonempty = &obj->q2;
    if (!QueueEmpty(empty))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }
    //设置空和非空队列
    while (QueueSize(nonempty) > 1)
    {
        QueuePush(empty, QueueFront(nonempty));
        QueuePop(nonempty);
    }
    int top = QueueFront(nonempty);//保存栈顶元素
    QueuePop(nonempty);
    return top;
}

int myStackTop(MyStack* obj) {
    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->q2);
    free(obj);
    obj = NULL;
}

用栈实现队列 

 

解题思路：

用两个栈，一个为插入栈，另一个为删除栈。

入队：向插入栈中插入元素。

出队：若删除栈为空，则把插入栈中的元素全部移到删除栈，然后进行删除；

若删除栈不为空，则直接删除删除栈的元素。 

//用栈实现队列
typedef struct {
    Stack pushST;
    Stack popST;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushST);
    StackInit(&q->popST);
    return q;
}

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

int myQueuePop(MyQueue* obj) {
    if (StackEmpty(&obj->popST))
    {
        while (!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int top = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return top;
}

int myQueuePeek(MyQueue* obj) {
    if (StackEmpty(&obj->popST))
    {
        while (!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int top = StackTop(&obj->popST);
    return top;
}

bool myQueueEmpty(MyQueue* obj) {
    if (StackEmpty(&obj->pushST) && StackEmpty(&obj->popST))
    {
        return true;
    }
    else
    {
        return false;
    }
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
    obj = NULL;
}

设计循环队列 

循环队列空间是固定的，但是要多开一个空间来区分空和满！

顺序结构

判空：head==tail

判满：（tail+1）%（k+1）=head 

//MyCircularQueue(k) : 构造器，设置队列长度为 k 。
//Front : 从队首获取元素。如果队列为空，返回 - 1 。
//Rear : 获取队尾元素。如果队列为空，返回 - 1 。
//enQueue(value) : 向循环队列插入一个元素。如果成功插入则返回真。
//deQueue() : 从循环队列中删除一个元素。如果成功删除则返回真。
//isEmpty() : 检查循环队列是否为空。
//isFull() : 检查循环队列是否已满。
typedef struct {
    int* _a;
    int head;
    int tail;
    int _k;

} MyCircularQueue;
bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueIsEmpty(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    q->_a = (int*)malloc(sizeof(int) * (k + 1));
    q->head = q->tail = 0;
    q->_k = k;
    return q;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->_a[obj->tail] = value;
    obj->tail++;
    obj->tail %= (obj->_k) + 1;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->head++;
    obj->head %= (obj->_k) + 1;
    return true;

}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->_a[obj->head];

}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    int tail = (obj->tail + obj->_k) % (obj->_k + 1);
    return obj->_a[tail];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->tail + 1) % (obj->_k + 1) == obj->head;

}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->_a);
    free(obj);
}

链式结构 

判空：head==tail 

判满：tail->next==head

typedef struct QuqueNode
{
    int _val;
    struct QuqueNode* next;
}QuqueNode;

typedef struct {
    QuqueNode* head;
    QuqueNode* tail;
    int _k;
} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    q->_k = k;
    QuqueNode* phead = (QuqueNode*)malloc(sizeof(QuqueNode));
    q->head = q->tail = phead;
    for (int i = 0; i < k; i++)
    {
        QuqueNode* next = malloc(sizeof(QuqueNode));
        phead->next = next;
        phead = next;
    }
    phead->next = q->head;
    //创建k+1个空间，并将他们链接
    return q;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->tail->_val = value;
    obj->tail = obj->tail->next;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->head = obj->head->next;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->head->_val;

}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    QuqueNode* cur = obj->head;
    while (cur->next != obj->tail)
    {
        cur = cur->next;
    }
    return cur->_val;

}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head == obj->tail;

}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->tail->next == obj->head;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    QuqueNode* cur = obj->head;
    while (cur->next != obj->head)
    {
        QuqueNode* next = cur->next;
        free(cur);
        cur = next;
    }
    free(cur);
    obj->head = obj->tail = NULL;
    free(obj);

}

 本篇文章到此结束。

嚞譶
关注
专栏目录
栈和队列经典OJ题
MEANSWER的博客
10-05 518
栈和队列经典OJ题1. LeetCode第225题---用队列实现栈2. LeetCode第232题---用栈实现队列3. LeetCode第20题---有效的括号4. LeetCode第150题---逆波兰表达式5. LeetCode第155题---最小栈6. 牛客网剑指offer21题---栈的压入、弹出序列 1. LeetCode第225题—用队列实现栈 链接: https://leetcode-cn.com/problems/implement-stack-using-queues/ 题解：用队列
栈与队列OJ题
Odfogy的博客
08-21 196
1、栈与队列的实现 //队列 ListNode*BuyListNode(LTDataType x) { ListNode *node = (ListNode*)malloc(sizeof(ListNode)); node->data = x; node->next = NULL; node->prev = NULL; return node; } ListNode*ListCreate() { ListNode*head = (ListNode*)malloc(sizeof(
栈和队列OJ
weixin_42438990的博客
11-08 137
2. 3. 4. 5.
栈和队列（OJ题思路分析+图解）
qq_54469537的博客
10-03 785
针对栈和队列一些相关OJ题的详细思路分析以及图解+完整代码
栈和队列的部分OJ题目
H48530的博客
03-24 526
部分栈和队列的OJ题目总结
栈与队列的3个oj题
编程SHARE的博客
05-20 501
栈与队列225.用队列实现栈解题思路代码232.用栈实现队列解题思路代码622.设计循环队列解题思路代码 225.用队列实现栈 解题思路 代码 232.用栈实现队列 解题思路 代码 622.设计循环队列 解题思路 代码 ...
栈和列队OJ题
m0_46669532的博客
05-10 125
1.括号匹配问题。 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 实现思路： 需要使用栈来完成 [ ( { } ) ] 1.遍历字符串，如果当前是左括号，就入栈 2.如果当前是右括号，就拿这个右括号和当前的栈顶元素进行比较，看看是不是匹配的括号。（如果匹配，就把栈顶元素出栈； 如果不匹配，就说明当前的字符串是非法的） 3.当字符串遍历结束之后，并且栈同时也为空，此时就
蓝桥杯历年试题（附完整测试数据和题目描述，可导入Oj)
03-15
这些题目是提高编程基本功的重要途径，通过解决这些题目，学习者可以熟悉常见的算法思想和数据结构，如快速排序、二分查找、深度优先搜索（DFS）和广度优先搜索（BFS），以及如何使用栈、队列、树和图等数据结构解决...
王道C语言督学营oj练习附个人学习感受（持续更新ing）
qq_43498726的博客
02-23 7479
初级阶段 个人感受分享： 初级阶段比较基础，但像龙哥说的那样，即使是科班出身，也需要听课。龙哥讲课把C语言以及之后考研用到的数据结构、计算机组成原理都有融合，也带着一步一步进行进行调试，在代码运行和问题解决方面有很大的收获。 这里建议大家上完课立马去写作业进行巩固，否则会对知识有所遗忘，有条件的朋友可以多刷几次课程加深记忆与理解。 关于oj，有时候确实很烦人。但现在BAT企业以及考研复试都是使用oj系统，所以也是刚好的帮助大家适应。我也曾多次被oj折磨的痛不欲生，但在这个过程中也是有提升自己的耐心，当你听到
一起玩转算法面试，保姆级攻略（附高清无码算法总结导图）,建议收藏
启舰
06-29 1万+
本文已收录至启舰的电子书《逆天改命—程序员的成神之路》，github地址：https://github.com/harvic/FightingCoder 欢迎star。点击【阅读原文】也可直达。 我大学时候也很傻，为了校招，看了不下于五本算法书，加上LeetCode，刷了大半年。 总共一两千道题啊……不刷怕考到……忘了刷，刷了忘……毛都快掉没了…… 现在工作近十年，辗转几个大厂，由当年的应试者变成了出题人，才知道，完全不必这么辛苦。 任何事情都遵循28原则，我们只要把握住那20%，就能拿到80..
大数据工程师面试题(附答案)
热门推荐
weixin_42142987的博客
05-02 1万+
MapReduce 1. 不指定语言，写一个WordCount的MapReduce 我：最近刚学了scala，并且就有scala版本的WordCount，刚好学以致用了一下： 对大数据【数据分析，数据挖掘】概念都是模糊不清的，该按照什么线路去学习，学完往哪方面发展，想深入了解，想学习的同学欢迎加入大数据学习qq群：458345782，有大量干货（零基础以及进阶的经典实战）分享给大家，并且...
大数据开发工程师面试题(附答案)
jiawoxuexiqq30294961的博客
12-27 1万+
之前采访毕业生的时候，有小伙伴提出意见，想看小编分享一些面试的干货，于是小编不负众望，今天给大家带来了一篇大神级面经，希望可以帮助即将毕业或正在找工作的小伙伴儿们，祝你们早日找到心仪的工作！ 在这里我还是要推荐下我自己建的大数据学习交流qq裙：458345782， 裙 里都是学大数据开发的，如果你正在学习大数据 ，小编欢迎你加入，大家都是软件开发党，不定期分享干货（只有大数据开发相关的），包...
栈和队列常见oj题
weixin_59551524的博客
02-16 780
栈和队列 栈是先进后出（在栈顶进行删除和插入），所以你可以用在一些特殊的地方，比如逆序打印链表等等。 比如判断栈出数据的顺序，中缀表达式 转 后缀表达式 （后缀表达式也叫作逆波兰表达式） 现将转换成后缀表达式，通过这个表达式去计算。那么如何去转换成后缀表达式 需要用到栈 栈中的一些方法，可以查看api，比较常用的：peek,pop,push,isEmpty，search public static void main(String[] args) { MyStack s
【数据结构】栈和队列&&OJ练习
大三小白C++进阶之路
11-18 1449
栈和队列的实现及其OJ练习
21_动态规划与数据结构结合
刘炫320的博客
09-11 573
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 971
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 688
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
数据结构之红黑树的 “奥秘“
robin_suli的博客
09-09 1092
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
数据结构 - 栈
最新发布
kaneki_lh的博客
09-13 503
/指向栈的指针int maxlen;//表示栈的最大长度int top;//栈顶元素的下标，用来指明栈顶的位置}s//数据域名//指针，指向栈下一个元素。
C++数组实现栈与队列操作详解
本资源是一份C++编程训练营中的代码片段，涉及两个数据结构实现：栈（Stack）和队列（Queue）。首先，我们来看第一个文件`stack.cpp`： 标题："训练营OJ完整版1" 描述："这是关于C++实现一个基于数组的栈（Stack）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

嚞譶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值