数据结构：栈和队列

最新推荐文章于 2024-11-04 13:52:23 发布
最新推荐文章于 2024-11-04 13:52:23 发布
阅读量59 收藏
点赞数
文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69587991/article/details/130779913
版权
本文介绍了栈和队列这两种基本数据结构，包括它们的概念、特点以及使用数组和链表的实现方式。栈遵循后进先出（LIFO）原则，提供了压栈和出栈操作；队列遵循先进先出（FIFO）原则，支持入队和出队操作。文中还给出了C语言实现栈和队列的详细代码示例。
摘要由CSDN通过智能技术生成

文章目录

提示：以下是本篇文章正文内容，下面案例可供参考

一、栈

🍎栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

1⃣️压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
2⃣️出栈：栈的删除操作叫做出栈。出数据也在栈顶。

在这里插入图片描述

🍎栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

在这里插入图片描述栈的结构

typedef int STDataType;//方便类型切换

typedef struct Stack
{
    STDataType* a;
    int top; // 栈顶
    int capacity; // 容量
}Stack;

1.初始化

// 初始化栈
void StackInit(Stack* ps)
{
    assert(ps);

    ps->a=NULL;
    ps->top=0;      //指向 栈顶数据的下一个位置
    //ps->top=-1;   //指向 栈顶数据
    ps->capacity=0;
}

2.入栈(插入)

// 入栈
void StackPush(Stack* ps, STDataType data)
{
    assert(ps);
    
	//检查容量，满了就扩容
    if(ps->top==ps->capacity)
    {
    	//每次容量+2
        STDataType *p=(STDataType *)realloc(ps->a,(ps->capacity+2)*sizeof(STDataType));
        //检查realloc 是否成功
        if(p==NULL)
        {
            perror("realloc fail");
            return ;
        }
        ps->a=p;
        ps->capacity+=2;
    }
    //入栈
    ps->a[ps->top++]=data;
}

3.出栈(删除)

// 出栈
void StackPop(Stack* ps)
{
    assert(ps);//判断ps是否为空指针
    assert(!StackEmpty(ps));//判断栈是否为空

    ps->top--; 
}

4.获取栈顶元素

// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    return ps->a[ps->top-1];  //根据初始化来判断返回 top-1，还是top
}

5.获取有效元素个数

// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
    assert(ps);

    return ps->top;
}

6.判空

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
    assert(ps);

    return ps->top==0;
}

7.销毁栈

// 销毁栈
void StackDestroy(Stack* ps)
{
    assert(ps);

    free(ps->a);
    ps->a=NULL;
    ps->top=0;
    ps->capacity=0;
}

🍎完整代码

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->top=-1;   //指向 栈顶数据
    ps->capacity=0;
}
// 入栈
void StackPush(Stack* ps, STDataType data)
{
    assert(ps);

    if(ps->top==ps->capacity)
    {
        //int new=ps->capacity==0? 2:ps->capacity+2  

        STDataType *p=(STDataType *)realloc(ps->a,(ps->capacity+2)*sizeof(STDataType));
        if(p==NULL)
        {
            perror("realloc fail");
            return ;
        }
        ps->a=p;
        ps->capacity+=2;
    }
    ps->a[ps->top++]=data;
}
// 出栈
int StackEmpty(Stack* ps);
void StackPop(Stack* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    ps->top--;
}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    return ps->a[ps->top-1];       
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
    assert(ps);

    return ps->top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
    assert(ps);

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

    free(ps->a);
    ps->a=NULL;
    ps->top=0;
    ps->capacity=0;
}



int main()
{
    Stack stack;
    StackInit(&stack);

    StackPush(&stack,1);
    StackPush(&stack,2);

    printf("stack :%d\n",StackTop(&stack));
    StackPop(&stack);

    StackPush(&stack,3);
    StackPush(&stack,4);

    printf("stacksize = %d\n",StackSize(&stack));
    while(!StackEmpty(&stack))
    {
        printf("stack :%d\n",StackTop(&stack));
        StackPop(&stack);
    } 
    printf("stacksize = %d\n",StackSize(&stack));
    

    StackDestroy(&stack);
    return 0;
}

二、队列

🍏队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)

入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头
在这里插入图片描述

🍏队列的实现
队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
在这里插入图片描述

队列的结构

// 链式结构：表示队列
typedef int QDataType;

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

// 队列的结构
typedef struct Queue
{ 
    QNode* front; 
    QNode* rear; 
}Queue;

1.初始化

// 初始化队列
void QueueInit(Queue* q)
{
    assert(q);

    q->front=NULL;
    q->rear=NULL;
}

2.入列

// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
    assert(q);

    QNode *tail =(QNode *)malloc(sizeof(QNode));
    if(tail==NULL)
    {
        perror("malloc fail");
        return;
    }
    tail->data=data;
    tail->pNext=NULL;
    
    //第一次入列
    if(q->front==NULL)
    {
        assert(q->rear==NULL);
         
        q->front=q->rear=tail;
    }
    //非第一次
    else
    {
        q->rear->pNext=tail;
        q->rear=tail;
    }
}

3.出列

// 队头出队列
void QueuePop(Queue* q)
{
    assert(q);//判断是否为空指针
    assert(!QueueEmpty(q));//判断队列是否为空列表

    if(q->front->pNext==NULL)  //考虑只有一个节点
    {
        free(q->front);
        q->front=q->rear=NULL;
    }
    else //多个节点
    {
        QNode *head=q->front;
        q->front=head->pNext;
        free(head);
    }
}

4.获取队列头部元素

// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));

    return q->front->data;
}

5.获取队列尾部元素

// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));

    return q->rear->data;
}

6.获取队列有效元素个数

// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
    assert(q);

    QNode *temp=q->front;
    int count =0;
    while(temp)
    {
        count++;
        temp=temp->pNext;
    }
    return count;
}

7.判空

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
    assert(q);

    return q->front==NULL&&q->rear==NULL;
}

8.销毁队列

void QueueDestroy(Queue* q)
{
    assert(q);

    QNode *temp=q->front;
    while(temp)
    {
        QNode *next=temp->pNext;
        free(temp);
        temp=next;
    }
    q->front=q->rear=NULL;
}

🍏完整代码

typedef int QDataType;

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

// 队列的结构
typedef struct Queue
{ 
    QNode* front; 
    QNode* rear; 
}Queue; 
// 初始化队列
void QueueInit(Queue* q)
{
    assert(q);

    q->front=NULL;
    q->rear=NULL;
}
// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
    assert(q);

    QNode *tail =(QNode *)malloc(sizeof(QNode));
    if(tail==NULL)
    {
        perror("malloc fail");
        return;
    }
    tail->data=data;
    tail->pNext=NULL;
    
    if(q->front==NULL)
    {
        assert(q->rear==NULL);
         
        q->front=q->rear=tail;
    }
    else
    {
        q->rear->pNext=tail;
        q->rear=tail;
    }

}
// 队头出队列
int QueueEmpty(Queue* q);
void QueuePop(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));

    if(q->front->pNext==NULL)  //考虑只有一个元素
    {
        free(q->front);
        q->front=q->rear=NULL;
    }
    else
    {
        QNode *head=q->front;
        q->front=head->pNext;
        free(head);
    }

    // if(q->front==NULL)
    // {
    //     q->rear=NULL;
    // }
    

}
// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));

    return q->front->data;
}
// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));

    return q->rear->data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
    assert(q);

    QNode *temp=q->front;
    int count =0;
    while(temp)
    {
        count++;
        temp=temp->pNext;
    }
    return count;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
    assert(q);

    return q->front==NULL&&q->rear==NULL;
}
// 销毁队列
void QueueDestroy(Queue* q)
{
    assert(q);

    QNode *temp=q->front;
    while(temp)
    {
        QNode *next=temp->pNext;
        free(temp);
        temp=next;
    }
    q->front=q->rear=NULL;
}

int main()
{
    Queue queue;
    QueueInit(&queue);
    
    QueuePush(&queue,1);
    QueuePush(&queue,2);
    
    // printf("%d ",QueueFront(&queue));
    // QueuePop(&queue);

    QueuePush(&queue,3);
    QueuePush(&queue,4);
    printf("size : %d\n",QueueSize(&queue));

    while(!QueueEmpty(&queue))
    {
        printf("%d ",QueueFront(&queue));
        QueuePop(&queue);
    }

    printf("\nsize : %d\n",QueueSize(&queue));

    QueueDestroy(&queue);
    return 0;
}
小菜鸟02
关注
C++实战篇(数据结构)：栈、队列
08-03
C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)...
数据结构： 栈和队列
11-03
数据结构中 栈 队列 算法 得讲解。欢迎大家下载，学习。
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 25万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
Java 数据结构：栈和队列
2301_78864183的博客
06-15 965
栈是一种遵循后进先出（LIFO, Last In First Out）原则的数据结构。想象一个叠放的盘子堆，你只能从顶部添加或移除盘子。栈的操作也类似，元素从栈顶添加（压栈）和移除（弹栈）。队列是一种遵循先进先出（FIFO, First In First Out）原则的数据结构。队列就像排队买票，先到的人先买票。队列的操作分别在两端进行：一端用于添加元素（入队），另一端用于移除元素（出队）。在Java中，我们可以利用Stack类、Queue接口及其各种实现类（如LinkedListArrayDeque。
C语言数据结构：栈和队列
qq_42319810的博客
07-02 2148
define MaxSzie 10 //定义栈中元素的最大个数//静态数组存放栈中元素int top;//栈顶指针}SqStack;//初始化栈S.top = -1;//初始化栈顶指针SqStack S;//声明一个顺序栈（分配空间）.....//判空操作else//数据域//指针域}*LiStack;//栈类型定义队列（Queue）是只允许在一端进行插入，在另一端删除的线性表重要术语：队头、队尾、空队列。
C++数据结构：栈和队列的应用
攻城狮的博客
05-29 2131
C++ 是一种面向对象的编程语言，它提供了多种数据结构，前面文章已介绍过数组、链表、hash表，并用自己的方法实现。用于存储和操作数据的结构在STL中还有很多，其中两种常用的数据结构是栈和队列。本文将介绍栈和队列的概念，特点，实现方式和应用场景。
数据结构:栈和队列
WangSir
10-26 2118
队列是在一端进行插入数据，另一端进行删除数据操作的特殊线性表，队列遵循先进先出原则。从集合框架中，Stack继承了Vector，Vector和ArrayList类似，都是动态顺序表。在使用中我们还会用到一种队列叫循环队列。栈、虚拟机栈、栈帧有什么区别呢？是一种特殊的线性表，只允许在。循环队列通常使用数组实现。
数据结构：栈和队列（详细讲解）
xiaoyubuhuiqiche的博客
01-07 7021
详细的讲解了栈和队列，内容理解轻松适合初学者学习
图解数据结构：栈和队列
Sicimike的博客
10-22 4908
前言 上一篇 图解数据结构：数组和单链表 主要讲解了数组和链表这两种线性结构的特点、区别、时间复杂度分析等。对数组和链表的划分，实际上是物理结构（存储结构）的划分。 物理结构有两种基本的结构：顺序存储结构、链式存储结构。而本篇说讲解的栈和队列属于逻辑结构上的划分。逻辑结构分为线性结构、非线性结构。 线性结构：有且仅有一个开始节点和一个终端节点，每个节点最多只有一个直接前驱和一个直接后继。代表结构...
数据结构：栈和队列的实现附上源代码（C语言版）
2301_79171011的博客
02-27 1313
这篇文章是关于栈和队列的C语言实现，干货满满，大家可以边看边手写代码，最后附上栈和队列的参考代码。栈和队列的实现其实相较于链表的实现简单一些，是因为其结构的特殊要求。之后会出一篇关于栈和队列的OJ题目。多多重复，百炼成钢！创作不易，希望这篇文章能给你带来启发和帮助，如果喜欢这篇文章，请留下你的三连，你的支持的我最大的动力！！！
数据结构：栈和队列 思维导图
weixin_43808478的博客
12-22 1668
数据结构精解：栈和队列
07-16
简述了栈和队列两种数据结构的基本构成和方法
C语言实现数据结构：栈和队列操作详解
资源摘要信息: 本文档详细介绍了数据结构中栈和队列的概念、操作及C语言实现。栈是一种后进先出（LIFO）的数据结构，支持两种主要操作：push（入栈）和pop（出栈），以及辅助操作如获取栈顶元素和打印栈内容。队列是...
C++ 数据结构 静态顺序表、动态顺序表。
qq_50373827的博客
11-01 681
静态顺序表（Static Array List）是一种线性数据结构，通常用数组实现。它具有固定的大小，并在编译时分配内存。以下是静态顺序表的一些基本概念和实现示例。
探索数据结构：数组与链表
最新发布
qq_36287830的博客
11-04 440
数组和链表是两种基本但重要的数据结构。选择合适的数据结构对于优化程序性能至关重要。理解它们的特点和适用场景可以帮助开发者做出更好的设计决策。希望本文能为你提供有关数组和链表的清晰认识。
线性数据结构之数组
m0_61840987的博客
10-31 393
数组是一种数据结构，用于存储多个相同类型的元素。在许多编程语言中，数组是最基本的数据结构之一，常用于管理和处理数据。数组的元素在内存中是连续存储的，可以通过索引直接访问。
数据结构————map,set详解
2301_79083481的博客
10-29 1095
详解map,set
数据结构模拟题［五］
mufengzhiyu666的博客
11-01 972
8．设连通图 G 中的边集 E={(a ，b)，(a，e)，(a，c)，(b， e)， (e， d)，(d，f) ，(f， c)}，则从顶点 a 出发可。4. 设散列表的长度为 8，散列函数 H(k)=k mod 7，初始记录关键字序列为 (25 ，31，8，27，13，68) ，要。3．设一组初始记录关键字序列为 (25，50，15， 35，80，85，20，40，36，70)，其中含有 5 个长度为 2 的。4．函数 substr( “DATASTRUCTURE”， 5，9) 的返回值为（ ）。
数据结构：栈和队列的判空操作
"判断链队列是否为空-数据结构 栈和队列" 在数据结构中，栈和队列是两种基本的线性数据结构，它们各有特定的操作规则和应用场景。本节主要聚焦于栈（Stack）和队列（Queue）的概念、表示以及它们在实际操作中的实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值