3.栈和队列

最新推荐文章于 2024-07-24 02:02:09 发布
最新推荐文章于 2024-07-24 02:02:09 发布
阅读量522 收藏
点赞数
分类专栏： 数据结构与算法 C 文章标签： 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a2076188013/article/details/123017581
版权

文章目录

栈

遵循LIFO原则
数据插入和删除的一端称为栈顶

栈的实现

数组,双向带头循环链表,单链表均可

image-20220210203249342

头文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDataType;
struct Stack
{
	STDataType* a;
	int top;//栈顶
	int capacity;//容量,方便增容
};
typedef struct Stack Stack;

void StackInit(Stack* pst);
void StackDestroy(Stack* pst);
//性质决定了只能在栈顶出入数据
void StackPush(Stack* pst, STDataType x);
void StackPop(Stack* pst);
STDataType StackTop(Stack* pst);
bool StackEmpty(Stack* pst);
int StackSize(Stack* pst);

初始化和销毁

void StackInit(Stack* pst)
{
	assert(pst);
	//初始时给一定空间大小方便增容
	pst->a = (STDataType*)malloc(sizeof(STDataType)*4);
	pst->top = 0;
	pst->capacity = 4;
}
void StackDestroy(Stack* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}

Push&Pop

//性质决定了只能在栈顶出入数据
void StackPush(Stack* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		STDataType* tmp = realloc(pst->a, sizeof(STDataType) * pst->capacity * 2);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);//结束整个程序,return是结束当前函数
		}
		pst->a = tmp;
		pst->capacity *= 2;
	}
	pst->a[pst->top] = x;
	pst->top++;
}
void StackPop(Stack* pst)
{
	assert(pst);
	//非空才能删除
	assert(!StackEmpty(pst));
	pst->top--;//无需取抹除原来空间的元素,只要访问不到就行
}

是否为空

bool StackEmpty(Stack* pst)
{
	assert(pst);
	return pst->top == 0;
}

求大小

int StackSize(Stack* pst)
{
	assert(pst);
	return pst->top;//top恰好就是size大小
}

取栈顶元素

//取栈顶元素
STDataType StackTop(Stack* pst)
{
	assert(pst);
	//非空才能取值
	assert(!StackEmpty(pst));
	return pst->a[pst->top-1];
}

Test文件

void Test()
{
	Stack st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	StackPush(&st, 5);

	//栈不支持print接口,因为只能后进先出
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}

	StackDestroy(&st);
}
int main()
{
	Test();
	return 0;
}

队列

FIFO先进先出

image-20220210221819040

队列的实现

用单链表更合适

头文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
//取队头数据
QDataType QueueFront(Queue* pq);
//取队尾数据
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);

初始化&销毁

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

Push&Pop

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	//如果没有节点
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
void QueuePop(Queue* pq)
{
	//对头出数据,即头删
	assert(pq);
	assert(!QueueEmpty(pq));//队列为空
	if (pq->head->next == NULL)
	{
		//只有一个节点的情况
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QueueNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}

取值

//取队头数据
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;
}

判空

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

求大小

int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

Test

void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	QueuePush(&q, 5);

	while (!QueueEmpty(&q))
	{
		//只能出队头
		printf("%d ",QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");
	QueueDestroy(&q);
}

练习

20. 有效的括号

bool isValid(char * s)
{
    Stack st;
    StackInit(&st);
    while(*s)
    {
        //左括号入栈
        //右括号找最近的左括号匹配
        if(*s == '[' || *s == '(' || *s == '{')
        {
            StackPush(&st,*s);
            s++;
        }
        else
        {
            //为空,说明没有前括号
            if(StackEmpty(&st))
            {
                //return之前一定要destroy,防止内存泄露
                //编译器自身检查不出来内存泄露
                StackDestroy(&st);
                return false;
            }
            char top = StackTop(&st);

            if((top =='[' && *s != ']')//不匹配
            ||  (top =='(' && *s != ')')
            ||  (top =='{' && *s != '}')
            )
            {
                StackDestroy(&st);
                return false;
            }
            else
            {
                //匹配的情况
                StackPop(&st);
                s++;
            }
        }
    }
    //如果只有左括号,stack不为空应该返回false
    bool ret = StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}

一定要防止内存泄露

225. 用队列实现栈

image-20220211113254747

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


MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    //->优先级更高
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
    return pst;
}

void myStackPush(MyStack* obj, int x) {
    //往不为空的队列入数据
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* pEmpty = &obj->q1;
    Queue* pNonEmpty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        pEmpty = &obj->q2;
        pNonEmpty = &obj->q1;
    }
    while(QueueSize(pNonEmpty)>1)
    {
        QueuePush(pEmpty,QueueFront(pNonEmpty));
        //插入到空队列后要pop掉
        QueuePop(pNonEmpty);
    }
    int front = QueueFront(pNonEmpty);
    QueuePop(pNonEmpty);
    return front;
}

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);
    //因为是值传递,不改变实参的值,置空也没用,需要在调用myStackFree接口之后手动置空
    //obj = NULL;
}

232. 用栈实现队列

image-20220211131219813

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

//remove the front element
int myQueuePop(MyQueue* obj) {
    int top = myQueuePeek(obj);
    StackPop(&obj->popST);
    return top;
}

//Get the front element
int myQueuePeek(MyQueue* obj) {
    //先判断popST是否为空
    if(StackEmpty(&obj->popST))
    {
        //from pushST to popST
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            //pop the element of pushST
            StackPop(&obj->pushST);
        }
    }
    //popST 不为空 直接Top the element
    return StackTop(&obj->popST);
}

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

void myQueueFree(MyQueue* obj) {
    //要销毁stack先
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
    //还需要在接口外面将obj置为NULL
}

622. 设计循环队列

  • 如果front和tail指向同一个位置,那么空满条件都相同
  • 解决:永远空一个位置 tail-> next== front 表示满 头尾相等表示空

image-20220211134927472

typedef struct {
    int* a;//数组
    int k;//队列最多能存储的元素
    int front;
    int tail;//尾(队尾数据的下一个)
} MyCircularQueue;

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    int tailNext = obj->tail+1;
    //小心越界
    if(tailNext == obj->k+1)
    {
        tailNext = 0;
    }
    return tailNext == obj->front;
}
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1));//k+1个空间
    obj->front = 0;
    obj->tail = 0;
    obj->k = k;
    return obj;
}


//入数据
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{   
    //判断是否满
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->tail] = value;
        obj->tail++;
        //超出范围回到0
        if(obj->tail == obj->k+1)
        {
            obj->tail = 0;
        }
        //取模也行,但尽量不要用% CPU只有加法器
        return true;
    }
}

//删数据    
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //判断是否空
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front++;
        //超出范围回到0
        if(obj->front == obj->k+1)
        {
            obj->front = 0;
        }
        //取模也行,但尽量不要用% CPU只有加法器
        return true;
    }
}

//get front element
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->front];
    }
}
//get rear element
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        int tailPrev = obj->tail-1;
        if(tailPrev == -1)
        {
            tailPrev = obj->k;
        }
        return obj->a[tailPrev];
    }
}



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

注意复用函数时要注意是否有声明

TauCeti0207
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3.栈和队列.ppt
09-02
栈和队列知识点 栈和队列是两种非常重要的数据结构，在软件设计中应用很多。它们都是线性结构，线性表、栈和队列这三种数据结构的数据元素以及数据元素间的逻辑关系完全相同，差别是线性表的操作不受限制，而栈和...
02-栈和队列.zip
01-31
栈与队列.pptx可能是课程的幻灯片，详细地展示了这两个数据结构的特性、操作以及相关算法的实现。幻灯片可能包含示例代码、图解和习题。 作业.txt可能包含了一些练习题目，要求学生实践栈和队列的操作，或者解决...
数据结构复习（3.栈和队列）
qq_53635710的博客
12-29 1939
3.1栈 重点：逻辑结构唯一 两种特殊的线性表：栈和队列 首先从数据结构的角度来看：栈和队列是操作受限的线性表。他们的逻辑结构都是一对一的关系。 3.1.1栈的逻辑结构 栈：限定仅在表尾进行插入和删除操作的线性表。 （a1, a2, ……, an） 空栈：不含任何数据元素的栈。 允许插入和删除的一端称为栈顶，另一端称为栈底。 栈的示意图 栈的插入：入栈，进栈，压栈 栈的删除：出栈，...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
8.栈和队列
ziyu2020的博客
11-27 1742
队列两端开口，栈一端开口，因此用栈来模拟队列时需要用两个栈来实现，一个按照正常的入队顺序入栈a。另一个栈b按照a出栈的顺序将元素放入栈b，就实现了对栈a元素的逆序。这样出栈b顶端的元素就相当于出队头的元素。对于pop操作，需要记录队头元素，作为返回值。
5.栈与队列
weixin_43831098的博客
06-17 1475
个人根据代码随想录刷题的思路和笔记整理
JavaScript【栈和队列】
m0_63077733的博客
03-20 1528
数组是一个线性结构，并且可以在数组的任意位置插入和删除元素。而栈和队列就是比较常见的受限的线性结构。如下图所示：栈的特点为先进后出，后进先出程序中的栈结构：函数调用栈：A（B（C（D（））））：即A函数中调用B，B调用C，C调用D；在A执行的过程中会将A压入栈，随后B执行时B也被压入栈，函数C和D执行时也会被压入栈。所以当前栈的顺序为：A->B->C->D（栈顶）；函数D执行完之后，会弹出栈被释放，弹出栈的顺序为D->C->B->A;递归：为什么没有停止条件的递归会造成栈溢出？
栈和队列的概念
stormsunshine的博客
04-14 4195
文章目录栈、队列和双端队列栈队列双端队列Java 中的栈、队列和双端队列单调栈和单调队列二叉堆和优先队列二叉堆优先队列 栈、队列和双端队列 栈和队列是常见的数据结构。栈的特点是后进先出，添加元素、删除元素和查看元素都在栈顶操作。队列的特点是先进先出，添加元素在队尾操作，删除元素和查看元素在队首操作。 双端队列比栈和队列更加灵活，可以在双端队列的两端添加元素、删除元素和查看元素。 栈、队列和双端队列都满足每次添加元素、删除元素和查看元素的时间复杂度是 O(1)O(1)O(1)。 栈、队列和双端队列都可以基于数
栈和队列的区别
qq_64008726的博客
05-18 3254
队列 (Queue) 是一种先进先出 (First-In-First-Out, FIFO) 的数据结构，允许在两端进行插入和删除操作，插入在队尾，删除在队头。插入和删除性能不同：由于栈的操作顺序是后进先出，因此在栈中插入或删除操作只涉及到栈顶元素，而在队列中因为是先进先出，每一次插入或删除操作都可能影响到队头或队尾的元素。空间分配不同：在栈中，所有元素都在同一个连续的内存块中，因此栈的空间分配比较简单。而在队列中，元素通常分布在不同的内存块中，因此队列的空间分配比较复杂。
栈和队列经典面试题
bit_zyx的博客
04-07 3099
目录 1、括号匹配问题 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 1、括号匹配问题 链接直达： 有效的括号 题目： 思路： 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 ...
数据结构~07.栈和队列的基本概念
qq_41424688的博客
07-28 3万+
数据结构学习~07.栈和队列的基本概念 本文是上一篇文章的后续,详情点击该链接~ 栈的定义:        栈是一种只能在一端进行插入或删除的线性表。其中,允许插入或删除的一端为栈顶(TOP)。栈顶由一个称为栈顶指针的位置指示器来指示。它是动态变化的 ...
zhanheduilie.zip_fogju3_栈和队列
09-24
栈和队列是两种最基本且常用的数据结构，它们在编程和算法设计中扮演着重要角色。让我们深入探讨这两种数据结构及其基本操作。 **栈（Stack）** 栈是一种后进先出（Last In First Out, LIFO）的数据结构。想象一个...
zhanheduilie.rar_栈和队列
09-24
栈和队列是计算机科学中基础且重要的数据结构，它们在程序设计中有着广泛的应用。在本资料"zhanheduilie.ppt"中，详细讲述了这两种数据结构的原理、特性以及实际应用。 栈（Stack）是一种后进先出（LIFO, Last In ...
14.栈和队列.pdf
04-26
14.栈和队列.pdf
C语言 | Leetcode C语言题解之第278题第一个错误的版本
m0_59237910的博客
07-23 469
C语言 | Leetcode C语言题解之第278题第一个错误的版本
【C语言】分支和循环（上）
最新发布
weixin_74076508的博客
07-24 640
C语⾔是结构化的程序设计语⾔，这⾥的结构指的是顺序结构、选择结构、循环结构，C语⾔是能够实现这三种结构的，其实我们如果仔细分析，我们⽇常所⻅的事情都可以拆分为这三种结构或者这三种结构的组合。在C语言中，我们就可以使⽤实现分⽀结构，使⽤实现循环结构。这期博客先来看看 分支结构中的if switch语句。
C语言日常练习Day13
m0_65544927的博客
07-23 223
tips：此处还是使用的冒泡排序。
【C语言】概念汇总（笔试面试题常问）
2301_77133426的博客
07-23 423
笔试题面试题1、什么是野指针，野指针出现的情况有哪些，怎么避免？ 2、介绍一下static关键字和const关键字 3、描述一下栈和队列 4、define和typedef的区别 5、#include< >和#include" "的区别
栈和队列基础与实现
"本资源是关于课堂练习，主要涉及栈和队列这两种数据结构，特别是循环队列的入队和出队算法。同时，提供了链式队列的定义以及栈的详细描述，包括栈的抽象数据类型、顺序栈的结构和操作实现。" 在计算机科学中，栈和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值