初阶数据结构——栈和队列习题

最新推荐文章于 2024-10-16 22:43:21 发布
最新推荐文章于 2024-10-16 22:43:21 发布
阅读量706 收藏
点赞数
分类专栏： 数据结构初阶学习笔记 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Adz1119/article/details/130727804
版权

目录

括号匹配问题

OJ链接
在这里插入图片描述

思路

是左括号则入栈，是右括号则出栈然后两两比较
在这里插入图片描述

代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<string.h>

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

void STInit(ST* pst);
void STDestroy(ST* pst);
void STPush(ST* pst,STDataType x);
void STPop(ST* pst);
STDataType STTop(ST* pst);
bool STEmpty(ST* pst);
int STSize(ST* pst);

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;//top指向栈顶元素的下一个位置
	pst->capacity = 0;
}

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}

void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity*sizeof(STDataType));
		if (tmp == NULL)
		{
			//printf("error: %s\n", strerror(errno));
            perror("realloc fail\n");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top++] = x;
}

void STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

bool isValid(char * s){
    ST st;
    STInit(&st);
    //左括号入栈
    //右括号则出栈
    while(*s)
    {
        if(*s == '{'
        || *s == '('
        || *s == '[')
        {
            STPush(&st,*s);
        }
        else
        {
            if(STEmpty(&st)) 
            {
               STDestroy(&st);
               return false;
            }
            int top=STTop(&st);
            STPop(&st);
            if(*s == '}' && top != '{'
            || *s == ')' && top != '('
            || *s == ']' && top != '[')
            {
                STDestroy(&st);
                return false;
            }
        }
        s++;
    }
    bool ret=STEmpty(&st);
    STDestroy(&st);
    return ret;
}

用队列实现栈

OJ链接
在这里插入图片描述

思路

push数据的时候push到非空的那个队列
pop数据的时候把非空队列的数据转移到空的队列，直到只剩最后一个，然后pop
在这里插入图片描述

注意点

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
局部结构体变量出了作用域销毁，还去返回它的地址，就是野指针了，所以这样写是不对的
应该malloc一个节点后再返回
在这里插入图片描述
不要为了不想把&obj->q1传递给Init而在MyStack中写成队列的指针，这时候这两个指针没有初始化，到Init函数中就有野指针问题。如果实在想在MyStack中写成队列的指针，可以q1和q2再去malloc

在这里插入图片描述

只free(obj)那么链表中的节点就会出现内存泄漏的问题
在这里插入图片描述

代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int QDataType;

//链表队列
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

//为了方便尾插头插和个数的记录
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

//初始化队列
void QueueInit(Queue* pq);
//入队列，尾插
void QueuePush(Queue* pq, QDataType x);
//出队列，头删
void QueuePop(Queue* pq);
//销毁
void QueueDestroy(Queue* pq);
//获取队列中有效元素个数
int QSize(Queue* pq);
//检测队列是否为空
bool QueueEmpty(Queue* pq);
//取队头元素
QDataType QueueFront(Queue* pq);
//取队尾元素
QDataType QueueBack(Queue* pq);

//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;

	pq->size = 0;
}
//入队列，尾插
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
	{
		perror("malloc fail\n");
		return;
	}
	tmp->data = x;
	tmp->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = tmp;
	}
	else
	{
		pq->tail->next = tmp;
		pq->tail = tmp;
	}
	pq->size++;
}
//出队列，头删
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	pq->size--;
}
//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	//while (!QueueEmpty(pq))
	//{
	//	QNode* next = pq->head->next;
	//	free(pq->head);
	//	pq->head = next;
	//}

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
//获取队列中有效元素个数
int QSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}
//检测队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL && pq->tail==NULL;
}
//取队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}
//取队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

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


MyStack* myStackCreate() {
    MyStack* ST=(MyStack*)malloc(sizeof(MyStack));
    if(ST==NULL)
    {
        perror("malloc fail\n");
        return NULL;
    }
    
    QueueInit(&ST->q1);
    QueueInit(&ST->q2);

    return ST;
}

void myStackPush(MyStack* obj, int x) {
    assert(obj);
    //插入非空的那个队列，两个都空则无所谓
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }

}

int myStackPop(MyStack* obj) {
    assert(obj);
    Queue* EmptyQ=&obj->q1;
    Queue* NonEmptyQ=&obj->q2;
    if(!QueueEmpty(EmptyQ))
    {
        NonEmptyQ=&obj->q1;
        EmptyQ=&obj->q2;
    }
    //将非空队列的元素放到空队列，留下一个，然后Pop
    while(QSize(NonEmptyQ)>1)
    {
        QueuePush(EmptyQ,QueueFront(NonEmptyQ));
        QueuePop(NonEmptyQ);
    }
    int top=NonEmptyQ->head->data;
    QueuePop(NonEmptyQ);
    return top;
}

int myStackTop(MyStack* obj) {
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    assert(obj);

    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

用栈实现队列

OJ链接
在这里插入图片描述

思路

一个栈负责push
一个栈负责pop

push时放进pushst
pop时如果popst为空，则将pushst中数据都放入popst，然后对popst中数据进行pop
如果popst不为空，则直接对popst中数据进行pop
在这里插入图片描述

代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<string.h>

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

void STInit(ST* pst);

void STDestroy(ST* pst);

void STPush(ST* pst,STDataType x);

void STPop(ST* pst);

STDataType STTop(ST* pst);

bool STEmpty(ST* pst);

int STSize(ST* pst);

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;//top指向栈顶元素的下一个位置
	pst->capacity = 0;
}

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}

void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail\n");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top++] = x;
}

void STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

typedef struct {
    ST s1;//第一个栈用来存数据
    ST s2;//第二个栈用来出数据
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    if(obj==NULL)
    {
        perror("malloc fail\n");
        return NULL;
    }

    STInit(&obj->s1);
    STInit(&obj->s2);

    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    //放到存数据的栈
    STPush(&obj->s1,x);
}

int myQueuePop(MyQueue* obj) {
    int front=myQueuePeek(obj);
    STPop(&obj->s2);

    return front;
}

int myQueuePeek(MyQueue* obj) {
    //如果用来出数据的栈(s2)为空，那么将s1栈中数据移动到s2的栈
    if(STEmpty(&obj->s2))
    {
        while(STSize(&obj->s1)>0)
        {
           STPush(&obj->s2,STTop(&obj->s1));
           STPop(&obj->s1);
        }
    }
    
    return STTop(&obj->s2);
}

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

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

设计循环队列

OJ链接
在这里插入图片描述

思路

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
无法确定满的时候的状态
解决方案：

1.多开一个空间。满：real+1 == front

2.增加一个size变量记录数据个数

空：size==0

满：size==8

这里展示多开一个空间的方案
在这里插入图片描述
循环队列可以用链表实现也可以用数组实现

链表实现思路：
空：front == rear
满：rear->next == front
在这里插入图片描述

在这里插入图片描述
由于需要获取队尾元素，
解决思路有：1.双向链表 2.增加一个prev指针 3.遍历获得队尾数据

数组实现思路：
空：front == real
满：(rear+1)%(k+1) == front
在这里插入图片描述
相比来说数组实现会简单一些，因为链表实现起来结构更复杂

数组实现代码

typedef struct {
    int* a;
    int front;
    int real;
    int k;
} MyCircularQueue;

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

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));//多开一个空间方便判满
    obj->front=0;
    obj->real=0;
    obj->k=k;

    return obj;
}

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

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

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return -1;

    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return -1;

    if(obj->real==0)
    return obj->a[obj->k];
    else
    return obj->a[obj->real-1];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->real;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->real+1)%(obj->k+1)==obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->real=obj->front=obj->k=0;
    free(obj);
}

链表实现代码

typedef struct QueueNode
{
    struct QueueNode*next;
    int data;
}QNode;

typedef struct {
    QNode*front;
    QNode*real;
    QNode*prev;
} MyCircularQueue;

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

QNode* QueueInit(int k)
{
    QNode*phead=(QNode*)malloc(sizeof(QNode));
    QNode*cur=phead;
    while(k--)
    {
        QNode*next=(QNode*)malloc(sizeof(QNode));
        cur->next=next;
        cur->data=0;
        next->next=phead;
        cur=next;
    }
    return phead;
}

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if(obj==NULL)
    {
        perror("malloc fail\n");
        return NULL;
    }

    QNode*phead=QueueInit(k);
    obj->front=phead;
    obj->real=phead;
    obj->prev=NULL;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    return false;

    obj->real->data=value;
    obj->prev=obj->real;//记录前一个
    obj->real=obj->real->next;

    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return false;

    obj->front=obj->front->next;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return -1;


    return obj->front->data;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return -1;

    return obj->prev->data;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
   return obj->front==obj->real;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->real->next==obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    QNode*cur=obj->front;
    QNode*next=cur->next;
    while(next!=obj->front)
    {
        free(cur);
        cur=next;
        next=cur->next;
    }
    free(cur);

    obj->front=NULL;
    obj->real=NULL;
    obj->prev=NULL;
    free(obj);
}
Adz1119
关注
专栏目录
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
m0_62171658的博客
03-29 4182
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
初阶数据结构——顺序表和链表(单链表)
Adz1119的博客
04-28 852
初阶数据结构——顺序表和链表
栈和队列的初阶知识与基础OJ练习
CS_boy的博客
11-01 405
  本文仅使用了两种常见的实现方法——动态数组栈、链队列，如果要看更多的队列和栈的实现方法，可以看我的下面这篇文章中有关队列和栈的部分：图的五种接口的实现，   本文的有关队列和栈的实现均已上传码云，可以来关注呀~：我的Gitee star一下再走啊 文章目录????一、栈????1. 存储结构和接口????️2.初始化栈????️3. 入栈????4.判断栈是否为空????5.出栈????6.返回栈顶元素????7.判断栈的大小????8.销毁队列????二、队列????1.存储结构与接口????2.初
数据结构初阶——树和二叉树/堆
weixin_73870552的博客
04-26 915
int size;// 当前数据个数// 容量}HP;数据类型是inta记录一段连续的地址空间，就是数组。普通二叉树的增删查改没有意义，真正有意义的是搜索树，平衡树，红黑树这些复杂的二叉树。但是学习控制普通二叉树的结构，是有意义的。在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。
【数据结构初阶】队列经典习题两道
稻草人
08-14 680
用队列实现栈，用栈实现队列
初阶数据结构——二叉树
Adz1119的博客
06-01 728
初阶数据结构——二叉树
数据结构初阶之二叉树——概念篇
Britney_dark的博客
05-08 3178
就算有一天，离别的时刻来临，但那也不一定意味着永别。
【初阶数据结构】二叉树（附题）
2401_82610555的博客
06-21 887
二叉树是：1. 空树2. 非空：根结点，根结点的左子树、根结点的右子树组成的。从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。
【初阶数据结构与算法】第六篇：栈和队列（各个功能实现+练习题包含多种方法）
YQ20210216的博客
03-29 847
⭐️本篇博客我要给大家分享一下算法中的双链表。希望对大家有所帮助。 ⭐️ 博主码云gitee链接：码云主页 前言 🌏一、栈 🍯1.栈的概念和结构 🍤栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 🍤压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 🍤出栈：栈的删除操作叫做出栈。出数据也在栈顶。 ...
初阶数据结构—排序
Awkwardx的博客
07-10 924
3. 空间复杂度：O(logN)4. 稳定性：不稳定。
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"包含了使用C和C++语言实现的数据结构实例，旨在帮助初学者和进阶者深化对数据结构的理解。 首先，让我们从初阶数据结构开始。基础的数据结构通常包括...
数据结构初阶数据结构初阶
02-12
2. **栈和队列**：栈是后进先出（LIFO）的数据结构，常用于函数调用、表达式求值等；队列是先进先出（FIFO）的数据结构，常用于任务调度和消息传递。 3. **树形数据结构**：包括二叉树、平衡树、堆等。二叉树每个...
数据结构常考基础代码题-顺序表有序插入
qq_52291558的博客
10-16 330
根据题目中的“顺序表递增有序”，我们需要定义一个顺序表结构体，用于存储元素和顺序表的相关信息。
Python 数据结构和算法面试题，使用 Jupyter Notebook 编写
hallo128的博客
10-16 418
【代码】Python 数据结构和算法面试题，使用 Jupyter Notebook 编写。
数据结构与算法：高级数据结构与实际应用
weidl001的博客
10-16 714
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
数据结构(8.1)——排序的基本概念
最新发布
m0_65240792的博客
10-16 136
排序的定义 排序算法的评价指标 排序算法的分类 总结：
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 501
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构编程实践20讲(Python版)—09B树
AnFany
10-12 1132
数据结构编程实践20讲(Python版)—09B树
【AcWing】算法基础课-数据结构
2301_80277275的博客
10-16 638
AcWing算法基础课---数据结构笔记
初学者的《数据结构》学习指南
- 栈(Stack)：一种后进先出(LIFO)的数据结构，支持push和pop操作，常用于函数调用栈、撤销操作等。 - 队列(Queue)：一种先进先出(FIFO)的数据结构，支持enqueue和dequeue操作，用于实现缓冲、进程调度等。 - 双端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值