栈和队列（C语言实现）

最新推荐文章于 2024-11-08 07:46:55 发布
最新推荐文章于 2024-11-08 07:46:55 发布
阅读量792 收藏 3
点赞数 1
文章标签： 栈 队列 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43419412/article/details/107602735
版权

栈和队列（C语言实现）

文章目录

栈的原理

​ 栈的原理，我觉着通过图的解释可能更为好理解。可以想象到一个饼干盒，当手上有多余的饼干不吃的时候要把它放回去，放回去之后，最先放进去的在饼干盒底下，最后放入的在饼干盒顶部，很明显你要想拿到最底下的饼干只要，把上面的饼干一个个取出来之后才能取到最底下的。所以栈的原理也是这样，只能访问栈定的元素，不能直接访问其他元素。
在这里插入图片描述

栈的实现

​ 参考C++中容器stack的接口函数，我们也写出相应的函数，便于操作栈这种数据结构，所以我们要实现以下几个函数，发现他们都是通过对象，调用成员函数实现的，所以我们借助于结构体和函数指针实现。本文通过多文件编写形式，其中mystack.h文件是一些成员变量的定义和函数的定义 mystack.c文件用于函数的实现。

/* 参考C++容器中栈的函数接口，然后使用C语言创建对应的数据结构
 * 1.stack.push(); //往栈头添加元素
 * 2.stack.pop();      //从栈头移除第一个元素
 * 3.stack.top();      //返回栈顶元素
 * 4.stack.empty();    //判断堆栈是否为空
 * 5.stack.size();     //返回堆栈的大小
 */

​ 首先，构建一个链表的数据结构，用于存储栈中的数据：

typedef struct listnode{
    struct listnode *next;
    int val;
}listnode;

​ 然后构建栈的结构体，其中函数指针指向具体实现操作的函数即可，在使用之前调用init函数，然后使用结构体中的函数指针即可完成栈的相关操作。

typedef struct mystack{
    int (*pop)(void);//函数指针，指向对应的函数
    int (*top)(void);
    int (*empty)(void);
    int (*size)(void);
    int (*push)(int);
    listnode head;
} mystack;

​ 首先看以下 mystack.h文件

#ifndef MYSTACK_H
#define MYSTACK_H

/* 参考C++容器中栈的函数接口，然后使用C语言创建对应的数据结构
 * 1.stack.push(); //往栈头添加元素
 * 2.stack.pop();      //从栈头移除第一个元素
 * 3.stack.top();      //返回栈顶元素
 * 4.stack.empty();    //判断堆栈是否为空
 * 5.stack.size();     //返回堆栈的大小
 */
 int stack_pop(void);
 int stack_top(void);
 int stack_push(int x);
 int stack_empty(void);
 int stack_size(void);

/*链表数据节点*/
typedef struct listnode{
    struct listnode *next;
    int val;
}listnode;

typedef struct mystack{
    int (*pop)(void);
    int (*top)(void);
    int (*empty)(void);
    int (*size)(void);
    int (*push)(int);
    listnode head;
} mystack;

 mystack stack;

 int stack_init(void);

#endif // MYSTACK_H

​ 看一下 mystack.c文件

#include"mystack.h"
#include<stdio.h>
#include<stdlib.h>

/*栈的初始化*/
int stack_init(void)
{
    stack.pop=stack_pop;
    stack.top=stack_top;
    stack.push=stack_push;
    stack.empty=stack_empty;
    stack.size=stack_size;
    stack.head.next=NULL;
    stack.head.val=0;


    return 0;
}

/*删除栈的首个元素*/
int stack_pop(void)
{
    if(stack.head.val==0)
    {
        printf("the stack is empty\n");
        exit(-1);
    }
    else
    {
        listnode *p=stack.head.next;
        stack.head.next=stack.head.next->next;
        free(p);
        stack.head.val--;
    }
    return 0;
}

/*返回的首个元素*/
int stack_top(void)
{
    if(stack.head.val==0)
    {
        printf("the stack is empty\n");
        exit(-1);
    }
    else
    {
        return stack.head.next->val;
    }
}
/*栈中添加元素*/
int stack_push(int x)
{
    if(stack.head.val==0)
    {
        stack.head.next=(listnode *)malloc(sizeof (listnode));
        stack.head.next->val=x;
        stack.head.next->next=NULL;
        stack.head.val++;
    }
    else
    {
        /*使用头插法向链表中插入元素*/
        listnode *p=(listnode *)malloc(sizeof (listnode));
        p->val=x;
        p->next=stack.head.next;
        stack.head.next=p;
        stack.head.val++;
    }
    return 0;
}

/* stack_empty为空时返回1，否则返回0 */
int stack_empty(void)
{
    if(stack.head.val==0)
        return 1;
    else
        return 0;
}
/*返回栈的大小*/
int stack_size(void)
{
    return stack.head.val;
}

队列的原理

​ 队列，顾名思义，很好的可以理解为一个正在排队的队伍，在排队打饭，新来的人要站在队伍后面（入队），打完饭的人就离开队伍（出队），看下面这张图应该可以很好的理解，**队列在内核中使用还是挺频繁的，**尤其是休眠唤醒，异步通知，线程什么的。

在这里插入图片描述

队列的实现

​ 参考C++中容器queue的接口函数，我们也写出相应的函数，便于操作队列这种数据结构，所以我们要实现以下几个函数，发现他们都是通过对象，调用成员函数实现的，所以我们借助于结构体和函数指针实现。本文通过多文件编写形式，其中myqueue.h文件是一些成员变量的定义和函数的定义 myqueue.c文件用于函数的实现。

/* 参考C++容器中栈的函数接口，然后使用C语言创建对应的数据结构
 * queue.back() 返回最后一个元素
 * queue.empty() 如果队列空则返回真
 * queue.front() 返回第一个元素
 * queue.pop() 删除第一个元素
 * queue.push() 在末尾加入一个元素
 * queue.size() 返回队列中元素的个数
 */

​ 首先，和栈一样，构建一个链表的数据结构，用于存储队列中的数据：

typedef struct listnode{
    struct listnode *next;
    int val;
}listnode;

​ 然后构建队列的结构体，其中函数指针指向具体实现操作的函数即可，在使用之前调用init函数，然后使用结构体中的函数指针即可完成队列的相关操作。

typedef struct myqueue{
    int (*back)(void);
    int (*front)(void);
    int (*pop)(void);
    int (*empty)(void);
    int (*size)(void);
    int (*push)(int);
    listnode *end; //指向队首的指针
    listnode head; //队尾的前一个节点
} myqueue;

​ 首先看以下 myqueye.h文件

#ifndef MYQUEUE_H
#define MYQUEUE_H

/* 参考C++容器中栈的函数接口，然后使用C语言创建对应的数据结构
 * queue_back 返回最后一个元素
 * queue_empty 如果队列空则返回真
 * queue_front 返回第一个元素
 * queue_pop 删除第一个元素
 * queue_push 在末尾加入一个元素
 * queue_size 返回队列中元素的个数
 */
 int queue_back(void);
 int queue_front(void);
 int queue_push(int x);
 int queue_empty(void);
 int queue_size(void);
 int queue_pop(void);



typedef struct listnode{
    struct listnode *next;
    int val;
}listnode;


typedef struct myqueue{
    int (*back)(void);
    int (*front)(void);
    int (*pop)(void);
    int (*empty)(void);
    int (*size)(void);
    int (*push)(int);
    listnode *end;
    listnode head;
} myqueue;

 myqueue queue;

 int queue_init(void);

#endif // MYQUEUE_H

看一下 myqueue.c文件

#include"myqueue.h"
#include<stdio.h>
#include<stdlib.h>


/*对队列的初始化*/
int queue_init(void)
{
    queue.pop=queue_pop;
    queue.back=queue_back;
    queue.push=queue_push;
    queue.size=queue_size;
    queue.empty=queue_empty;
    queue.front=queue_front;


    queue.head.next=NULL;
    queue.head.val=0;
    queue.end=NULL;

    return 0;
}
/*返回队尾部元素*/
int queue_back(void)
{
    if(queue.head.next==NULL)
    {
        printf("queue is empty\n");
        exit(-1);
    }
    return queue.head.next->val;
}
/*返回队首部元素*/
int queue_front(void)
{
    if(queue.head.next==NULL)
    {
        printf("queue is empty\n");
        exit(-1);
    }
    return queue.end->val;
}
/*往队列添加元素*/
int queue_push(int x)
{

    if(queue.head.next==NULL)
    {
        listnode *p=(listnode *)malloc(sizeof (listnode));
        p->val=x;
        p->next=NULL;
        queue.head.next=p;
        queue.end=p;
    }
    else
    {
        listnode *p=(listnode *)malloc(sizeof (listnode));
        p->val=x;
        p->next=queue.head.next;
        queue.head.next=p;
    }
    return 0;
}
/*队列是否为空，空返回1，不为空返回0*/
int queue_empty(void)
{
    return queue.head.val==0;
}

/*返回队列的有多少元素*/
int queue_size(void)
{
    return queue.head.val;
}

/*删除队列首个元素*/
int queue_pop(void)
{
    if(queue.head.next==NULL)
    {
        printf("queue is empty\n");
        exit(-1);
    }
    listnode *p=queue.head.next;
    while(p->next!=queue.end)
    {
        p=p->next;
    }
    queue.end=p;
    free(p->next);
    return 0;
}
岩枭～
关注
C语言栈和队列代码实现
08-08
包含内容：栈、队列、循环队列的数组实现方式和链表实现方式
C语言-栈与队列
Silence_Fall的博客
11-02 644
1栈的定义，特点 定义：栈（stack）是限定仅在表尾进行插入和删除操作的线性表。 特点：先入后出，后入先出2 栈的注意点首先它是一个线性表，也就是说，栈元素具有线性关系，即前驱后继关系。只不过它是一种特殊的线性表而已。定义中说是在线性表的表尾进行插入和删除操作，这里表尾是指栈顶，而不是栈底。它的特殊之处就在于限制了这个线性表的插入和删除位置，它始终只在栈顶进行。这也就使得：栈底是固定的，最先
栈和队列（C 语言）
潇雪的博客
11-08 983
本篇讲述了栈和队列的基本概念、结构以及实现这两种数据结构的思路。接着也给出了实现这两种结构的代码，最后介绍了循环队列并且给出了实现思路。
C语言栈和队列的实现
weixin_51263328的博客
01-23 219
struct Stack { int data; struct Stack* next; }; struct Stack* createStack() { struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack)); stack->next = NULL; return stack; } bool isEmpty(struct Stack* stack) { return (stack->next == NU
C语言-栈和队列
m0_73605503的博客
07-22 1448
欢迎来到HanLop博客的C语言数据结构初阶系列。在之前的文章中，我们详细介绍了链表及其操作方法。在本篇文章中，我们将深入探讨栈和队列这两种常见的数据结构。栈和队列虽然都是线性数据结构，但它们在数据的存取方式上有着显著的区别。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。通过理解和掌握这两种数据结构，您将能更有效地管理数据，并为后续更复杂的数据结构和算法的学习打下坚实的基础。让我们一起开始探
数据结构栈和队列C语言实现.pdf
09-30
根据提供的文件内容，该文件涉及了数据结构中栈和队列的概念，并以C语言为工具来实现这些数据结构的操作。我们将详细介绍栈和队列的基本概念，以及它们在C语言中的实现方式。 ### 栈（Stack） 栈是一种后进先出...
栈和队列C语言代码栈和队列C语言代码.doc
07-03
栈和队列C语言代码 栈和队列是计算机科学中的两个基本数据结构，栈是一种后进先出（LIFO）的数据结构，而队列是一种先进先出（FIFO）的数据结构。本文将详细介绍栈和队列的C语言代码实现。 一、顺序栈的类型定义 ...
手搓栈和队列的C语言实现项目
最新发布
01-16
该项目是用C语言实现的栈和队列的代码，里面有包括入栈、出栈、入队、出队等等代码，可以让初学数据结构的同学更好的理解栈和队列
C语言实现栈与队列
05-17
本项目是用C语言实现的栈和队列，提供了可加载和使用的源代码，这对于理解这两种数据结构的工作原理以及在C语言中如何实现它们非常有帮助。 首先，让我们详细了解栈和队列的概念： 1. 栈（Stack）：栈是一种后进先...
C语言中栈和队列实现表达式求值的实例
08-29
C语言中栈和队列实现表达式求值的实例 栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值...
c语言实现栈
09-01
c语言实现栈
C语言栈和队列（栈）
weixin_44630656的博客
12-03 175
栈 一、栈的顺序存储 顺序存储（法一） 存储结构（一） typedef struct{ ElemType elem[MAXSIZE]; int top; }SqStack; //当top == -1时，栈为空，当top == MAXSIZE-1时，该栈为满 存储结构（二） int elem[MAXSIZE]; int top; 进栈操作 //进栈 Status Push(Sq...
c语言--栈和队列
weixin_61558111的博客
09-24 2026
栈的入栈和出栈操作 通常用指针top指向栈顶的位置，用指针bottom指向栈底，栈顶指针top动态反映栈的当前位置。栈是一种特殊的线性表，因此栈可采用顺序存储结构存储，也可以使用链式存储结构存储。栈中的数据元素用一个预设的足够长的一维数组来实现：。栈底位置可以设置在数组的任意端点，用来作为栈顶指针。 若现在有一个栈，StackSize是5，则栈的普通情况、空栈、满栈的情况分别如下图所示： 通常将0下标端设为栈底，这样空栈时栈顶指针s->top = -1；入栈时，栈顶指针s->top++；出栈时，s->
C语言---栈和队列
qq_62743629的博客
05-01 3337
严格来说,栈和队列都属于线性表 "一对一" 栈:"先进后出" 队列: "先进先出" 栈 栈只能从一端存取,另一端是封闭的 在栈中,不论是存还是取,都必须遵循"先进后出"的原则 ==>栈是一种只能从表的一端存取数据,且遵循"先进后出"原则的线性存储结构 进栈和出栈 进栈:将数据存储到栈里面去 出栈:将数据从栈中间取出来 栈的实现方法 栈:有点"特殊"的线性存储结构 顺序表==>顺序栈 (顺序存储结构) 链表==>链栈 (链式存储结构)
c语言的栈和队列
qq_45949060的博客
12-29 251
栈是一种先进后出的数据结构。它被限定为只能在一端进行插入和删除操作。它是一种运算受限的线性表，它的能进行插入和删除的一端被称为栈顶，另一端被称为栈底。向一个栈插入新元素又称进栈，入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 栈的实现很简单，只需要一个一维数组和一个指向栈顶的变量top即可，...
C语言栈和队列（队列）
weixin_44630656的博客
12-03 237
队列 队列的顺序存储 队列的链式存储
栈和队列（C语言版）
坚持是一种品质
02-18 6893
栈和队列是在程序中最常被用到的数据结构，其重要性不言而喻。栈： 定义：限定仅在表尾进行插入和删除操作的线性表，因此表尾称之为栈顶,表头为栈底，重要特点是后进先出（LIFO）操作： InitStack(&S) 初始化一个栈 DestoryStack(&S)销毁一个已经存在的栈 ClearStack(&S)清空一个栈 StackEmpty(S)判断已存在的栈是否为空 St
数据结构 - 栈和队列（C语言实现）
C橘子
04-13 7785
一. 栈 栈的定义  栈（Stack）是一种只能在一端进行插入或删除操作的线性表。                     图一 栈的示意图 顺序栈的基本操作   初始化 void InitStack(Stack *S){ //初始化顺序栈即使栈顶指针为-1 S->Top = -1; }   栈判空 int StackEmpty(Stack *S) { //栈判空函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值