c-数据结构（栈和队列）

最新推荐文章于 2024-10-05 15:32:05 发布
最新推荐文章于 2024-10-05 15:32:05 发布
阅读量464 收藏
点赞数 3
文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LHB15173352347/article/details/141781025
版权

栈与队列

概念

栈：只能在固定的一端进行操作；“先进后出”

  • 栈顶：可以进行插入删除的一端

  • 栈底：栈顶的对端

  • 入栈（压栈）：将节点插入栈顶之上

  • 出栈（弹栈）：将节点从栈顶剔除

队列：

  • 队头：可以删除节点的一端

  • 队尾：可以插入节点的一端

  • 入队：将节点插入到队尾之后

  • 出队：将队头节点从队列中剔除

顺序栈
顺序栈数据操作代码
//math3文件
----------------------------------------------------------------------------
sstack.h
----------------------------------------------------------------------------
#ifndef __SSTACK_H
#define __SSTACK_H
    
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//定义数据的类型，可以是复杂的结构体，本案例使用int
/*
typedef struct Book
{
    int id;
    char *name;
    int bookId;
    char *author;
}DATA;
*/

typedef int DATA;

//顺序栈结构体
typedef struct
{
    DATA *pData;	//栈中元素的地址
    int size;		//顺序栈的大小（数组的大小）
    int top;		//栈顶元素下标
}SeqStack;

//初始化栈
int SStack_init(SeqStack* s, int size);

//判断是否栈满
int SStack_isFull(SeqStack* s);

//判断是否栈空
int SStack_isEmpty(SeqStack* s);

//入栈|压栈
int SStack_push(SeqStack* s, DATA data);

//出栈|弹栈（指定元素）
int SStack_pop(SeqStack* s, DATA *data);

//回收栈
int SStack_free(SeqStack* s);

#endif
----------------------------------------------------------------------------
sstack.c
----------------------------------------------------------------------------
#include "sstack.h"

//初始化栈
int SStack_init(SeqStack* s, int size)
{
    //给栈中元素申请空间
    s->pData = (DATA*)calloc(sizeof(DATA), size);
    //校验
    if(s->pData == NULL)
    {
        perror("内存申请失败！");
        return -1;
    }
    //初始化
    s->size = size;
    s->top = -1;	//空栈(元素个数为 top+1 )
    
    return 0;
}


//判断是否栈满
int SStack_isFull(SeqStack* s)
{
    return s->top + 1 == s->size;
}


//判断是否栈空
int SStack_isEmpty(SeqStack* s)
{
    return s->top == -1;
}


//入栈|压栈
int SStack_push(SeqStack* s, DATA data)
{
    if(SStack_isFull(s))
    {
        printf("栈满！\n");
        return -1;
    }
    //操作栈
    s->top++;	//类似于顺序表的插入
    s->pData[s->top] = data;	//在更新后的top放数据		
    
    return 0;
}


//出栈|弹栈
int SStack_pop(SeqStack* s, DATA *data)
{
    if(SStack_isEmpty(s))
    {
        printf("栈空!\n");
        return -1;
    }
    //操作栈
    *data = s->pData[s->top];
    s->top--;
    
    return 0;
}


//回收栈
int SStack_free(SeqStack* s)
{
    if(s->pData)
    {
        free(s->pData);
        s->pData = NULL;
    }
    s->top = -1;
}
----------------------------------------------------------------------------
sstack_main.c
----------------------------------------------------------------------------
#include "sstack.h"

int main(void)
{
   SeqStack  st;
  
   SStack_init(&st,10);
   register int i = 1;
   
    for(; i <=9; i++)
    {
    	SStack_push(&st,i);
    }
    
    if(-1 == SStack_push(&st,1024))
    {
    	fprintf(stderr,"满栈,插入失败\n");
    }
    
    while(!SStack_isempty(&st))
    {
         DATA data = 0;
         SStack_pop(&st,&data);
         printf("%4d",data);         
    }
    
    printf("\n");
    
    SStack_free(&st);
   
    return 0;
}
链式栈
链式栈数据操作代码
//math4文件
----------------------------------------------------------------------------
linkstack.h
----------------------------------------------------------------------------
#ifndef __LINKSTACK_H
#define __LINKSTACK_H
   
#include <stdio.h>
#include <stdlib.h>

//定义数据存储类型
typedef int DATA;

//定义链式栈节点
typedef struct node
{
    DATA data;			//数据域
    struct node *next;	//指向下一个节点指针
} NODE;
   
//定义链式栈（就是一个装链式表的容器）
typedef struct
{
    NODE *pHead;	//栈顶指针
    int size;		//元素个数
    int sum;		//记录节点个数
}LinkStack;

//初始化链式栈
int LStack_init(LinkStack *s, int num);

// 判断栈是否已满
int LStack_isfull(LinkStack *s);

// 判断栈是否为空
int LStack_isempty(LinkStack *s);

// 压栈/入栈
int LStack_push(LinkStack *s,DATA data);

// 弹栈/出栈
int LStack_pop(LinkStack *s,DATA *data);

// 回收栈
int LStack_free(LinkStack *s);

#endif
----------------------------------------------------------------------------
linkstack.c
----------------------------------------------------------------------------
#include "linkstack.h"

    
//初始化链式栈
int LStack_init(LinkStack *s, int num)
{
    s->pHead = NULL;
    s->size = num;
    s->num = 0;		//用来计数
    
    return 0;
}


// 判断栈是否已满
int LStack_isfull(LinkStack *s)
{
    return s->num == s->size;
}


// 判断栈是否为空
int LStack_isempty(LinkStack *s)
{
    return s->num == 0;
}


// 压栈/入栈
int LStack_push(LinkStack *s,DATA data)
{
    //判断是否栈满
    if(LStack_isfull(s))
    {
        return -1;
    }
    
    NODE* p = s->pHead;
    if(!p)
    {
        return -1;
    }
    //给新节点赋初值，采用头插法
    p->data = data;
    p->next = s->pHead;
    s->pHead = p;
    
    (s->num)++;	//计数
    
    return 0;
}


// 弹栈/出栈
int LStack_pop(LinkStack *s,DATA *data)
{
    //判断是否栈空
    if(LStack_isempty(s))
    {
        return -1;
    }
    //创建一个空节点指向栈顶
    NODE* p = s->pHead;
    
    if(!p)
    {
        return -1;
    }
    //取出栈顶数据，然后栈顶向下移动
    //注意区分 pHead：栈顶指针	next：链表指针	s：栈		p：链表
    *data = p->data;
    s->pHead = p->next;
    free(p);	//思考：为什么不是free(s)
    //取出后可以释放空间
    (s->num)--;
    
    return 0;
}


// 回收栈(本质：回收链表节点)
int LStack_free(LinkStack *s)
{
    NODE* p = s->pHead, *q = NULL;
    
    while(p)
    {
        q = p;
        p = p->next;
        free(q);
    }
    s->pHead = NULL;
    s->num = 0;
    
    return 0;
}
----------------------------------------------------------------------------
linkstack_main.c
----------------------------------------------------------------------------
#include "linkstack.h"

int main(void)
{
    LinkStack  st;
    LStack_init(&st,10);
    register int i = 1;
   
    //入栈
    for(; i <= 10; i++)
    {
       LStack_push(&st,i);
    }
    
    if(-1 == LStack_push(&st,1024))
    {
       fprintf(stderr,"满栈,插入失败\n");
    }
    
    //出栈
    while(!LStack_isempty(&st))
    {
         DATA   data = 0;
         LStack_pop(&st,&data);
         printf("%4d",data);         
    }
    
    printf("\n");
    
    //回收栈
    LStack_free(&st);
    
    return 0;  
}
顺序队列
顺序队列数据操作代码
//math5文件
--------------------------------------------------------------------------------------------------
squeue.h
--------------------------------------------------------------------------------------------------
#ifndef __SQUEUE_H
#define __SQUEUE_H
   
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef int DATA;

//创建顺序队列
typedef struct
{
    DATA *pData;	//队列入口
    int size;		//队列总容量
    int head;		//队头元素下标
    int tail;		//队尾元素下标
}SQueue;

//初始化队列
int SQ_init(SQueue *q, int num);

// 判断顺序队列是否队满
int SQ_isfull(SQueue *q);

// 判断顺序队列是否队空
int SQ_isempty(SQueue *q);

// 顺序队列插入数据
int SQ_push(SQueue *q,DATA data);

// 顺序队列输出数据
int SQ_pop(SQueue *q,DATA *data);

// 回收顺序队
int SQ_free(SQueue *q);
    
#endif
--------------------------------------------------------------------------------------------------
squeue.c
--------------------------------------------------------------------------------------------------
#include "squeue.h"


//初始化队列
int SQ_init(SQueue *q, int num)
{
    //创建队列空间
    q->pData = (DATA*)calloc(sizeof(DATA),num);
    
    if(q->pData == NULL)
    {
        return -1;
    }
    q->size = num;
    q->head = q->tail = 0;	//空的队列，后期再插入元素
    
    return 0;
}


// 判断顺序队列是否队满
int SQ_isfull(SQueue *q)
{
    //队头下标始终为0
    return (q->tail + 1) % q->size == q->head;
}


// 判断顺序队列是否队空
int SQ_isempty(SQueue *q)
{
    return q->head == q->tail;
}


// 顺序队列插入数据
int SQ_push(SQueue *q,DATA data)
{
    //判断是否满队
    if(SQ_isfull(q))
    {
        return -1;
    }
    
    类似于栈，看图，先全部集中到队头，插入时 tail 会变化（逐步往后移动），然后打印的时候从 head 开始（依次往后移动）
    其实本质就是尾插法
    q->pData[q->tail] = data;
    //(q->tail+1)：下标加1
    //(q->tail+1) % q->size：防止越界
    q->tail = (q->tail + 1) % q->size;
    //若不循环：
    
    return 0;
}


// 顺序队列输出数据
int SQ_pop(SQueue *q,DATA *data)
{
    if(SQ_isempty(q))
    {
        return -1;
    }
    
    *data = q->pData[q->head];
    q->head = (q->head + 1) % q->size;
    
    return 0;
}


// 回收顺序队
int SQ_free(SQueue *q)
{
    if(q->pData)
    {
        free(q->pData);
        q->pData = NULL;
    }
    q->head = q->tail = 0;
}
链式队列
链式队列数据操作代码
//math6文件
--------------------------------------------------------------------------------------------------
linkSqueue.h
--------------------------------------------------------------------------------------------------
#ifndef __SQUEUE_H
#define __SQUEUE_H
   
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef int DATA;

//定义链式队列节点
typedef struct node
{
    DATA data;
    struct node *next;
}NODE;

//定义链式队列
typedef struct
{
    NODE *pHead;	//头指针
    NODE *pTail;	//尾指针
    int size;		//队列当前元素个数
    int num;		//计数
}LinkQueue;

//初始化链式队列
void LQ_init(LinkQueue *, int);

//判断链式队列是否队满
int  LQ_isfull(LinkQueue *);

//判断链式队列是否队空
int  LQ_isempty(LinkQueue *);

//链式队列插入数据
int  LQ_push(LinkQueue *, DATA);

//链式队列输出数据
int  LQ_pop(LinkQueue *, DATA *);

//回收链式队列
int LQ_free(LinkQueue *);

#endif
--------------------------------------------------------------------------------------------------
linkSqueue.c
--------------------------------------------------------------------------------------------------
#include "linkSqueue.h"


//初始化链式队列
void LQ_init(LinkQueue *q,int size)
{
    q->pHead = q->pTail = NULL;
    q->size = size;
    q->num = 0;
}


//判断链式队列是否队满
int  LQ_isfull(LinkQueue *q)
{
    return q->num == q->size;
}


//判断链式队列是否队空
int  LQ_isempty(LinkQueue *q)
{
    return q->num == 0;
}


//链式队列插入数据
int  LQ_push(LinkQueue *q,DATA data)
{
    //检验是否队满
    if(LQ_isfull(q))
    {
        return -1;
    }
    //创建新节点并且初始化
    NODE* pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
    {
        return -1;
    }
    pNew->data = data;
    pNew->next = NULL;
    参考顺序队列思想
    //第一种情况，链表为空
    if(!(q->pTail))
    {
        q->pHead = q->pTail = pNew;
    }
    else	//第二种情况，链表不为空
    {
        q->pTail->next = pNew;
        q->pTail = pNew;
    }
    q->num++;
    
    return 0;
}


//链式队列输出数据
int  LQ_pop(LinkQueue *q,DATA *data)
{
    //判断是否队空
    if(LQ_isempty(q))
    {
        return -1;
    }
    
    //只要队列非空，就取首节点以及数据
    NODE* pNew = q->pHead;
    *data = pNew->data;
    
    //第一种情况，队列只有一个节点
    if(pNew == q->pTail)
    {
        q->pHead = q->pTail = NULL;
    }
    else	//第二种情况，队列有多个节点
    {
        p->pHead = pNew->next;
    }
    
    free(pNew);
    q->num--;
    
    return 0;
}


//回收链式队列
int LQ_free(LinkQueue *q)
{
    NODE* pNew = q->pHead, *p = NULL;
    
    while(pNew)
    {
        p  = pNew;
        pNew = pNew->next;
        free(p);
    }
    q->pHead = q->pTail = NULL;
    q->num = 0;
    
    return 0;
}
--------------------------------------------------------------------------------------------------
linkSqueue_main.c
--------------------------------------------------------------------------------------------------
#include "LinkSqueue.h"
    
int main()
{
    LinkQueue queue;
    
    LQ_init(&queue,10);
    register  int i = 1; 
    
    for(; i <= 10 ; i++)
    {
       LQ_push(&queue, i);
    }
    
    if( -1 == LQ_push(&queue,1024))
    {
      fprintf(stderr,"满队,入队失败!\n");
    }
    
    while(!LQ_isempty(&queue))
    {
        DATA   data;
        LQ_pop(&queue,&data);
        printf("%4d",data);
    }
    printf("\n");
    
    LQ_free(&queue);
    
    return 0; 
}

奋斗的小 Tiger
关注
C语言-数据结构-栈队列实现
03-10
这些文件共同构成了一个完整的C语言数据结构库，实现了栈和队列的基本操作，可以用于各种需要此类数据结构的计算机程序中。了解并熟练掌握这些基础知识对于任何想深入学习C语言或计算机科学的人来说都是至关重要的。
数据结构不挂科-3-栈和队列.pdf
07-17
栈（Stack）和队列（Queue）是数据结构中两种非常重要的线性数据结构。在计算机科学与程序设计中，它们都用于处理元素的集合，但是它们的处理方式有显著的不同。栈是一种后进先出（Last In First Out，LIFO）的数据...
数据结构----栈和队列
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
05-19 1867
栈篇 1.1栈 栈，线性表的一种特殊的存储结构。与学习过的线性表的不同之处在于栈只能从表的固定一端对数据进行插入和删除操作，另一端是封死的。由于栈只有一边开口存取数据，称开口的那一端为“栈顶”，封死的那一端为“栈底”（类似于盛水的木桶，从哪进去的最后还得从哪出来）。 1.2.栈操作数据元素的两种动作： 数据元素用栈的数据结构存储起来，称为“入栈”，也叫“压栈”。 数据元素由于某种原因需要从栈结构中提取出来，称为“出栈”，也叫“弹栈”。 注意：栈遵循先进后出原则 1.3.栈的表示方式 既然栈
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 24万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
C语言数据结构：栈和队列
qq_42319810的博客
07-02 2072
define MaxSzie 10 //定义栈中元素的最大个数//静态数组存放栈中元素int top;//栈顶指针}SqStack;//初始化栈S.top = -1;//初始化栈顶指针SqStack S;//声明一个顺序栈（分配空间）.....//判空操作else//数据域//指针域}*LiStack;//栈类型定义队列（Queue）是只允许在一端进行插入，在另一端删除的线性表重要术语：队头、队尾、空队列。
C语言---栈和队列
qq_62743629的博客
05-01 3280
严格来说,栈和队列都属于线性表 "一对一" 栈:"先进后出" 队列: "先进先出" 栈 栈只能从一端存取,另一端是封闭的 在栈中,不论是存还是取,都必须遵循"先进后出"的原则 ==>栈是一种只能从表的一端存取数据,且遵循"先进后出"原则的线性存储结构 进栈和出栈 进栈:将数据存储到栈里面去 出栈:将数据从栈中间取出来 栈的实现方法 栈:有点"特殊"的线性存储结构 顺序表==>顺序栈 (顺序存储结构) 链表==>链栈 (链式存储结构)
【C语言 - 数据结构】浅析栈和队列
qq_62662919的博客
05-21 1202
对于线性表，我们可能要执行下列操作：访问表的第k个结点、在k这个结点之前或者之后插入一个新结点，抑或是删除第k个结点等等操作，其中我们会遇到值对第一个或者最后一个结点插入、删除、和访问值的线性表，我们给它们以特殊的名称：栈、队列或是双端队列。
c语言-数据结构-栈和队列的实现和解析
安权_code的博客
11-12 776
栈和队列都是一种特殊的线性表，线性表是一种被广泛应用的数据结构。之所以叫线性表是因为其在逻辑上是连续的，可以将他想象成一条线把数据都连了起来，但在物理上并不一定是连续的。在用线性表存储数据的时候，通常以链式结构和数组形式来进行数据的存储。本文介绍的栈和队列就是使用数组和链表实现的。
【数据结构】栈和队列
小羊的博客
07-12 2606
栈超超超详解
数据结构(七)---C语言实现栈和队列
cainiaochufa2021的博客
04-12 2473
1. 队列和栈都是线性表类型的数据结构，两个结构都可以从一端存入数据，区别是栈结构只能从存入数据的一端取出数据，而队列结构只能从出入数据的另一端取出数据。 2. 队列和栈都可以用数组和链表来实现。不管是哪种实现方式，都应该尽可能高效的找到几个特殊的位置（栈顶、队列头、队列尾）。
C语言-栈和队列
m0_73605503的博客
07-22 1287
欢迎来到HanLop博客的C语言数据结构初阶系列。在之前的文章中，我们详细介绍了链表及其操作方法。在本篇文章中，我们将深入探讨栈和队列这两种常见的数据结构。栈和队列虽然都是线性数据结构，但它们在数据的存取方式上有着显著的区别。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。通过理解和掌握这两种数据结构，您将能更有效地管理数据，并为后续更复杂的数据结构和算法的学习打下坚实的基础。让我们一起开始探
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 2155
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构---栈和队列之共享栈（C语言）
05-05
数据结构---栈和队列之共享栈（C语言）完整代码，可以运行
数据结构---栈和队列之顺序栈（C语言）
05-05
在这个主题中，我们将专注于两种基本的线性数据结构：栈和队列，特别是C语言实现的顺序栈。顺序栈是一种在内存中连续分配空间的抽象数据类型，它具有后进先出（LIFO）或先进后出（FILO）的特性。 ### 栈的基本概念 ...
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 384
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1124
本文介绍了数据结构中的AVL树，给出了C++的代码实现
【笔记】数据结构12
m0_52024881的博客
09-29 530
看到的社区的一个知识总结，这里记录一下。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1253
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
数据结构栈和队列：顺序队列的理解与应用
"本资源主要介绍了数据结构中的栈和队列，特别是重点讲解了队列的顺序存储结构，即顺序队列。同时，通过实例展示了栈的后进先出（LIFO）特性，并探讨了不同进栈顺序下可能的出栈序列情况。" 在计算机科学中，数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值