栈与队列实现与练习

最新推荐文章于 2024-06-12 21:47:26 发布
最新推荐文章于 2024-06-12 21:47:26 发布
阅读量925 收藏 24
点赞数 22
分类专栏： 数据结构 刷题 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53117402/article/details/135177699
版权

栈Stack与队列Queue详解

栈

一.栈的基本概念

1.栈的定义

栈(stack):是允许在一端进行插入或者删除的线性表。栈是一种线性表。只是限定了条件为在一端进行操作。

image-20231223172055210

栈顶(TOP):是栈在操作那一段的第一个元素，为图中的a5
栈底(Bottom):栈的最低部,是最后一个弹出的元素，为a1，图中情况中，a1一定是最后一个弹出的。
空栈(Empty):没有任何元素存储的栈就是空栈，上图弹出a1后不压入任何元素，就成了空栈。

栈是后进先出的顺序表 因为栈顶是一直是后进的，优先弹出。

二.栈的接口设计以及实现

1.结构体的设计

采用顺序结构存储的栈称为顺序栈。栈的主要操作时压栈和出栈，需要频繁对尾部进行增删。那么就不方便采用链式结构了，因为链式结构删除队尾的效率是很低的。所以数组来实现栈。数组在队尾增删的效率是比较可观的。栈结构体设置了三个属性

typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;

a用来存储元素的一位数组，_top指向栈顶元素的下一位，也是元素的个数。_capacity用来控制一维数组容量

image-20231224002517021

空栈

image-20231224002703461

栈不为空

2.接口以及实现
// 初始化栈 
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 StackD
(1)初始化
void StackInit(Stack* ps) {
	assert(ps);
	ps->_a = NULL;
	ps->_top = 0;
	ps->_capacity = 0;
}

将结构体的属性设置为默认值(NULL或0)

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

在添加栈元素前检查存储栈元素的顺序表的空间是否满足，如果不满足则进行扩容，在返回一个新的顺序表。

(3)出栈
void StackPop(Stack* ps) {
	assert(ps&&ps->_a&&ps->_top);
	ps->_top--;
}

如果栈不为空直接返回栈顶位置-1,下次添加元素的时候会覆盖这个位置。查询元素访问不到这个元素。

(4)获得栈顶元素
STDataType StackTop(Stack* ps) {
	assert(ps&&ps->_top);
	return ps->_a[ps->_top - 1];
}

因为top指针指向的是栈顶元素的下一个，所以要返回top-1位置的元素。

(5)判断是否为空栈
int StackEmpty(Stack* ps) {
	assert(ps);
	return ps->_top == 0;
}

返回元素是否为0

(6)返回栈元素个数
int StackSize(Stack* ps) {
	assert(ps);
	return ps->_top;
}

直接返回size

队列

一.队列的基本概念

1.栈的定义

队列(queue)是只允许在一端进入，另一端删除的线性表。
队列的特点是先进先出，就像日常排队，先来的在前，先排到。

image-20231224013612262

二.队列的设计以及实现

1.结构体的设计
typedef int QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	int size;
}Queue;

队列的操作是入队和出队。入队是对尾进行操作，出队是对头进行操作，所以就不采用顺序结构进行存储了，因为顺序表对删除的效率太低。入队是尾插，出队是头删。可以使用链表进行存储，时间复杂度都是O(1)。队列元素的属性有存储的值和下一个节点。队列的属性有队列的头还有尾，还有队列的元素。要出队时将队列的头的指针进行改变，要入队时将队列的尾的指针的next改变，再将尾指针改变。

2接口以及实现
// 初始化队列 
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);
(1)初始化
void QueueInit(Queue* q) {
	q->_front = q->_rear = NULL;
	q->size = 0;
}

将队列指针中的所有属性都设为默认值

(2)元素入队操作
void QueuePush(Queue* q, QDataType data) {
	assert(q);
	QNode* p = (QNode*)malloc(sizeof(QNode));
	if (p == NULL)
	{
		perror("malloc failed");
		return;
	}
	p->_data = data;
	p->_next = NULL;
	if (q->size == 0)
	{
		q->_front = q->_rear = p;
	}
	else {
		q->_rear->_next = p;
		q->_rear = p;
	}
	q->size++;
}

先申请一个新节点，将新节点的next置空。如果队列没有元素，那么加入元素后队列的头和尾就会指向同一元素。所以将头和尾都指向新节点。如果队列已经有了元素，那只需要将新节点设置rear的next，并将新节点更新尾rear。

(3)元素出队操作
void QueuePop(Queue* q) {
	assert(q && q->size);
	QNode* p = q->_front;
	q->_front = q->_front->_next;
	q->size--;
	free(p);
}

直接将队列指针的front更新为front的next。出队必须保证队列不为空。

(4)获得队列头部元素
QDataType QueueFront(Queue* q) {
	assert(q && q->size);
	return q->_front->_data;
}

直接返回队列头部指针指向的值。

(5)获得队尾元素
QDataType QueueBack(Queue* q) {
	assert(q && q->size);
	return q->_rear->_data;
}

直接返回队列尾部指针指向的值。

(6)获得队列长度
int QueueSize(Queue* q) {
	assert(q );
	return q->size;
}

队列结构有定义，直接返回。

(7)判断队列是否为空
int QueueEmpty(Queue* q) {
	assert(q);
	return q->size == 0;
}

返回队列长度是否等于0。

栈与队列练习

20. 有效的括号 - 力扣(https://leetcode.cn/problems/valid-parentheses/description/)

使用栈来实现。依次遍历字符串s的每一个字符k。如果k为左括号**“[ ( {“直接入栈，如果k为右括号”] } )”**,不匹配的情况

  1. 栈为空
  2. 括号无法匹配(分类写出三种情况进行逻辑与)

如果匹配的话则需要弹出栈顶元素，继续遍历s。当s遍历完后，返回栈的是否为空。(如果栈不为空，那么就有括号没有匹配，所以为false)。

typedef char STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
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->_top == ps->_capacity)
	{
		int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		Stack* st = realloc(ps->_a, sizeof(STDataType) * newCapacity);
		if (st == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->_a = st;
        ps->_capacity=newCapacity;
	}
	ps->_a[ps->_top++] = data;
}
void StackPop(Stack* ps) {
	assert(ps&&ps->_a&&ps->_top);
	ps->_top--;
}
STDataType StackTop(Stack* ps) {
	assert(ps&&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;
}
void StackDestroy(Stack* ps) {
	assert(ps);
	free(ps->_a);
	ps->_capacity = 0;
	ps->_top = 0;
}
bool isValid(char* s) {
    Stack st;
    StackInit(&st);
//    if(sizeof(s)%2)return false; s是指针变量,长度固定为8
while(*s)
{
 if(*s=='('||*s=='['||*s=='{')
 {
     StackPush(&st,*s);
 }   else
 {
     if(StackEmpty(&st)||(*s==']'&&StackTop(&st)!='[')||(*s=='}'&&StackTop(&st)!='{')||(StackTop(&st)!='('&&*s==')')){
         return false;
     }
     StackPop(&st);
 }
 s++;
}
    int ans = StackEmpty(&st);
    StackDestroy(&st);
    return ans;
}

225. 用队列实现栈

队列的特点是先进先出，栈的特点是先进后出。可以使用两个队列。一个负责加入元素,另一个负责弹出元素。这两个队列的身份可以交换。(例如 A负责加入元素时，B就要负责元素的弹出)

  1. 栈的压入 如果队列A为空就向队列B中添加元素，否则就像A中添加元素。
  2. 栈的弹出 找到不为空的队列 将不为空的队列中的所有元素(不包括最后一个)依次出队并入队队列B，弹出队列A中的最后一个元素。
  3. 栈的初始化 将两个队列指针初始化即可。
  4. 返回栈顶 返回不为空队列的队尾元素
  5. 判断是否为空栈 返回两个队列长度逻辑与的结果
typedef int QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	int size;
}Queue;
void QueueInit(Queue* q) {
	q->_front = q->_rear = NULL;
	q->size = 0;
}
void QueuePush(Queue* q, QDataType data) {
	assert(q);
	QNode* p = (QNode*)malloc(sizeof(QNode));
	if (p == NULL)
	{
		perror("malloc failed");
		return;
	}
	p->_data = data;
	p->_next = NULL;
	if (q->size == 0)
	{
		q->_front = q->_rear = p;
	}
	else {
		q->_rear->_next = p;
		q->_rear = p;
	}
	q->size++;
}
void QueuePop(Queue* q) {
	assert(q && q->size);
	QNode* p = q->_front;
	q->_front = q->_front->_next;
	q->size--;
	free(p);
}
QDataType QueueFront(Queue* q) {
	assert(q && q->size);
	return q->_front->_data;
}
QDataType QueueBack(Queue* q) {
	assert(q && q->size);
	return q->_rear->_data;
}
int QueueSize(Queue* q) {
	assert(q );
	return q->size;
}
int QueueEmpty(Queue* q) {
	assert(q);
	return q->size == 0;
}
void QueueDestroy(Queue* q) {
	assert(q);
	while (!QueueEmpty(q))
	{
		QueuePop(q);
	}
	q->_rear = q->_front;
}

typedef struct {
        Queue queue1;
         Queue queue2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* m = ( MyStack*)malloc(sizeof(MyStack));
    QueueInit(&m->queue1);
    QueueInit(&m->queue2);
    //   printf("%d\n", &m);
    return m;
}

void myStackPush(MyStack* obj, int x) {
    // printf("%d\n",obj);
    if(QueueEmpty(&obj->queue1))
    {
        QueuePush(&obj->queue2,x);
    }else
    {
         QueuePush(&obj->queue1,x);
    }
}

int myStackPop(MyStack* obj) {
    Queue *queue = &obj->queue1;
    Queue *nonequeue = &obj->queue2;
    if(QueueEmpty(queue))
    {
        queue=&obj->queue2;
        nonequeue=&obj->queue1;
    }
    QNode* rear = queue->_rear;
    while(queue->size>1)
    {
        // printf("%d\n",1);
        QueuePush(nonequeue,QueueFront(queue));
        QueuePop(queue);
    }
    int ans = QueueFront(queue);
QueuePop(queue);
    return ans;
}

int myStackTop(MyStack* obj) {
     Queue *queue = &obj->queue1;
    Queue *nonequeue = &obj->queue2;
    if(QueueEmpty(queue))
    {
        queue=&obj->queue2;
        nonequeue=&obj->queue1;
    }
     return queue->_rear->_data;
}

bool myStackEmpty(MyStack* obj) {
     return QueueEmpty(&obj->queue1) &&  QueueEmpty(&obj->queue2) ;
}

void myStackFree(MyStack* obj) {
    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);
*/

232. 用栈实现队列

队列时按顺序先进先出的。栈是后进先出。用栈实现的时候有两种思路

  1. 两个栈 添加向A添加，出队时将A弹出到B，弹出B的栈顶，在将B弹出到A。单次出队的时间复杂度为O(n)
  2. 依旧两个栈 A负责入队，B负责出队。添加时向A添加，弹出时查看B是否为空，B为空将A的每个元素弹出并压入B，最后弹出B的栈顶，B不为空直接弹出B的栈顶。
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
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->_top == ps->_capacity)
	{
		int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* st = realloc(ps->_a, sizeof(STDataType) * newCapacity);
		if (st == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->_a = st;
		ps->_capacity = newCapacity;
	}
	ps->_a[ps->_top++] = data;
}
void StackPop(Stack* ps) {
	assert(ps&&ps->_a&&ps->_top);
	ps->_top--;
}
STDataType StackTop(Stack* ps) {
	assert(ps&&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;
}
void StackDestroy(Stack* ps) {
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

typedef struct {
    Stack* in;
    Stack* out;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue *m = (MyQueue*)malloc(sizeof(MyQueue));
    m->in =(Stack*) malloc(sizeof(Stack));
     m->out =(Stack*) malloc(sizeof(Stack));
    StackInit(m->in);
    StackInit(m->out);
    return m;
}
         
void myQueuePush(MyQueue* obj, int x) {
    StackPush(obj->in,x);
}

int myQueuePop(MyQueue* obj) {
    if(StackEmpty(obj->out))
    {
        while(!StackEmpty(obj->in))
        {

            StackPush(obj->out,StackTop(obj->in));
            StackPop(obj->in);
        }
    }
    int ans = StackTop(obj->out);
    StackPop(obj->out);
    return ans;
}

int myQueuePeek(MyQueue* obj) {
     if(StackEmpty(obj->out))
    {
        while(!StackEmpty(obj->in))
        {
            StackPush(obj->out,StackTop(obj->in));
            StackPop(obj->in);
        }
    }
    return StackTop(obj->out);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(obj->in) && StackEmpty(obj->out);
}

void myQueueFree(MyQueue* obj) {
StackDestroy(obj->in);
StackDestroy(obj->out);
    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);
*/
Paradox_M
关注
  • 22
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈和队列题目合集
Jeloys的博客
03-19 1299
复习栈的知识，然后做了一下精选的几道LeetCode题目：20,155,232,844,224,682,496 栈的知识总结 什么是栈？ 1.后进者先出，先进者后出，这就是典型的“栈”结构。 2.从栈的操作特性来看，是一种“操作受限”的线性表，只允许在端插入和删除数据。 什么时候需要用到栈？ 当某个数据集合只涉及在某端插入和删除数据，且满足后进者先出，先进者后出的操作特性时，我们...
栈和队列基本操作及练习
08-05
栈和队列基本操作及练习
数据结构练习题-3栈和队列
沐雨风栉
05-08 1089
数据结构练习题-栈和队列
栈和队列习题整理
m0_49991895的博客
02-19 646
一、括号匹配问题 题目描述如下： 解题思路：使用栈来解决，扫描字符串，当碰到左括号时直接入栈，当扫描到右括号时，弹出栈顶元素查看是否匹配，不匹配直接false，否者重复上述流程。 两个边界问题： 扫描完字符串，栈不为空时，说明左括号多了，没有相匹配的右括号，直接false。 扫描到第一个右括号时，发现栈为空，说明右括号是该字符串的第一个字符，没有相匹配的左括号，直接false。 代码如下： public class Num20 { public boolean isValid...
LeetCode栈和队列经典例题
m0_70811813的博客
01-09 708
这里有四道关于栈和队列的经典题型
栈与队列c++算法练习
wenjinjie1的博客
11-17 782
Type是要存放的数据类型Container是实现底层堆的容器，必须是数组实现的容器，如vector、dequeFunctional是比较方式/比较函数/优先级此时默认的容器是vector，默认的比较方式是大顶堆less举例//小顶堆//大顶堆//默认大顶堆//paira.push(d);a.push©;a.push(b);while (!}//输出结果为：2 51 3。
栈与队列编程练习
withbeginner的博客
03-30 767
对抽象数据结构类型的一些练习题，应用class自定义Stack，queue等抽象数据类型，并解决一些问题
C语言用栈和队列实现的回文检测功能示例
01-20
本文实例讲述了C语言用栈和队列实现的回文功能。分享给大家供大家参考，具体如下： #include #include<malloc>//内存分配头文件 #include<math.h>//在math.h中已定义OVERFLOW的值为3 #define SIZE 100 #...
C语言-数据结构-栈队列实现
03-10
C语言-数据结构-栈队列实现
数据结构第三章栈和队列练习及答案.doc
10-10
"数据结构第三章栈和队列练习及答案" 本资源摘要信息将详细介绍栈和队列的知识点，包括栈和队列的定义、特点、操作和应用。 一、栈的定义和特点 栈是一种特殊的线性表，它只能在一端进行插入和删除操作。栈的特点...
栈和队列习题
03-30
对于棧和队列部分的基础运用，你需要进行系统的基础复习，和对于小程序的实现
队列和栈的练习
weixin_41712723的博客
04-16 114
1. 括号匹配问题 //顺序表实现栈 typedef char Type; typedef struct Stack { Type* _array; size_t _size; size_t _capacity; }Stack; void stackInit(Stack* st, size_t n); void stackPush(Stack* st, Type data); void...
C++:十大排序
2301_80418172的博客
06-12 990
十大排序CPP
ACM算法学习路线、清单
qq_45477639的博客
06-10 1921
算法与数据结构学习路线
C语言刷题（函数）
2303_82176667的博客
06-09 798
一个数如果恰好等于它的所有因子(不包括它本身)之和，这个数就称为“完数”。
C数据结构：排序
2301_80655639的博客
06-12 994
若按照错误方法来：例如：begin = 0，end = 3，那么mid = 1，begin1 = 0，end1 = 2，递归左右区间为[0，2]也就是begin = 0，end = 2，那么mid = 1，begin1 = 0，end1 = 2，这样又递归就会出现栈溢出的情况，所以必须要按照 上面代码的方式走。然后这个for循环做的就是遍历原数组，将原数组的值减去最小值，这个值映射到count数组中，让这个下标的值++，这样就会统计这个值出现的次数，而与原数组建立的关系就是减去一个min的关系。
【高阶数据结构】红黑树详解
最新发布
liuty0125的博客
06-12 1083
在前面我们学习了平衡二叉树，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现，除了AVL树，下面我们要学习的红黑树也是处理二叉树自身缺陷的一种方式RED,BLACK,_kv(kv),_col(RED){}
数据结构--第九章--查找
2302_80052051的博客
06-09 667
插入过程：（1）若二叉排序树T为空，则创建一个key域为k的节点，将它作为根节点；（2）否则将k和根节点的关键字比较，若两者相等，则说明树中已有此关键字k，无须插入，直接返回0；（3）若Kkey，则将k插入根节点的左子树中，否则将它插入右子树中。哈希表又称散列表，是除顺序表存储结构，链表存储结构和索引存储结构之外的又一种存储线性表的存储结构。对于n个元素，二分查找成功时最多的关键字比较次数为：log2（n+1）不成功时最多的关键字比较次数为log2（n+1）等概率条件下ASL成功=
educoder数据结构栈和队列作业
04-10
educoder是一个在线编程学习平台，提供了丰富的编程题目和学习资源。在educoder上，你可以学习和练习各种编程语言和数据结构算法。...这些题目会涉及到栈和队列的基本操作、应用场景以及相关算法的实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值