入栈、出栈与队列

已于 2025-08-07 17:16:28 修改
阅读量668 收藏 3
点赞数 23
CC 4.0 BY-SA版权
文章标签： 开发语言 数据结构 算法 linux
于 2025-08-06 20:08:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2403_88096060/article/details/149973197

1.二级指针

1.在被调函数中需要修改主调函数的指针变量时，需传递其指针地址；

2.指针数组的数组名作为参数传递时；

2.内核链表

（1）定义

内核链表：本质为循环双向链表，其没有数据域

存储形式：将节点嵌于结构体内（数据中），而不是将数据存于节点内；

（2）内核链表的相关宏

offset_of

作用:获取节点到结构体首地址的偏移量；

原理：假设结构体的首地址为0，则节点的首地址即为其到结构体首地址的偏移量；

container_of

作用：通过偏移量，获取结构体的首地址；

原理：用节点首地址减去偏移量；

一般定义内核链表时，将节点置于结构体首部，此时节点首地址即为结构体首地址；

3.栈

先进后出的存储方式；

满栈、空栈：栈顶是否存储数据；

增栈：入栈时，栈顶由内存地地址-->内存高地址，出栈反之；

减栈：栈顶的运动方式与增栈相反；

对象：包含头地址与元素个数；

节点：包含元素与指向下一个节点的指针；

栈相关的代码练习：


typedef int Data_type_t;

typedef struct stnode 
{
    Data_type_t data;
    struct stnode *pnext;
}Stnode_t;

typedef struct stack
{
    Stnode_t *ptop;
    int clen;
}Stack_t;
Stack_t *c_stack()
{
    Stack_t *stack = malloc(sizeof(Stack_t));
    if(NULL == stack)
    {
        printf("error\n");
        return NULL;
    }

    stack->ptop = NULL;
    stack->clen = 0;

    return stack;
}

int is_empty_stack(Stack_t *stack)
{
    return NULL == stack->ptop ;
}

void stack_for_each(Stack_t *stack)
{
    Stnode_t *ptmp = stack->ptop;

    while (ptmp)
    {
        printf("%d ", ptmp->data);
        ptmp = ptmp->pnext;
    }
    puts("");
    
}

//入栈
int push_stack(Stack_t *stack, Data_type_t data)
{
    Stnode_t *pinst = malloc(sizeof(Stnode_t));
    if(NULL == pinst)
    {
        printf("error\n");
        return -1;
    }

    pinst->pnext =NULL;
    pinst->data = data;

    if(is_empty_stack(stack))
    {
        stack->ptop = pinst;
    }
    else
    {
        pinst->pnext = stack->ptop;
        stack->ptop = pinst;
    }

    stack->clen++;
    return 0;
}

//出栈
int pop_stack(Stack_t *stack, Data_type_t *pdata)
{
    if(is_empty_stack(stack))
    {
        return -1;
    }

    Stnode_t *ptmp = stack->ptop;
    stack->ptop = ptmp->pnext;
    if(pdata)
    {
        *pdata = ptmp->data;
        printf("pop : %d\n", *pdata);
    }

    free(ptmp);
    stack->clen--;
    
    return 0;
}

//获取栈元素
int get_top_stack(Stack_t *stack, Data_type_t *pdata)
{
    if(is_empty_stack(stack))
    {
        return -1;
    }
    if(pdata && stack->ptop->data)
    {
        *pdata = stack->ptop->data;
        printf("top : %d\n", *pdata);
        return *pdata;
    }
}

//销毁
void destroy_stack(Stack_t **stack, Data_type_t *pdata)
{
    if(is_empty_stack(*stack))
    {
        return ;
    }
    while ((*stack)->ptop)
    {
        pop_stack(*stack, pdata);
    }

    free(*stack);
    stack =NULL;
    
    return ;
}

4.队列

（1）链式队列

定义：允许从一段进行数据的插入，从另一端进行数据的删除的线性存储结构；

插入：称为入队，插入的一端即为队尾；

删除：称为出队，删除的一端即为队头；

特点：先进先出；

应用：应用于缓存数据；

对象：包含头地址、尾地址与元素个数；

节点：包含元素个数与指向下一个节点的指针；

代码练习

#ifndef __LQUEUE_H__
#define __LQUEUE_H__

typedef int Data_type_t;

typedef struct lqnode
{
    Data_type_t data;
    struct lqnode *pnext;
}Lqnode_t;

typedef struct lqueue
{
    Lqnode_t *phead;
    Lqnode_t *ptail;
    int clen;
}Lqueue_t;

extern Lqueue_t *c_lqueue();
extern int is_lqueue_empty(Lqueue_t *lqueue);
extern int insert_lqueue_tail(Lqueue_t *lqueue, Data_type_t data);
extern void lqueue_for_each(Lqueue_t *lqueue);
extern int delet_lqueue_head(Lqueue_t *lqueue, Data_type_t *pdata);
extern int get_top_lqueue(Lqueue_t *lqueue, Data_type_t *hdata);
extern void destroy_lqueue(Lqueue_t **lqueue);


#endif

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

//创建
Lqueue_t *c_lqueue()
{
    Lqueue_t *lqueue = malloc(sizeof(Lqueue_t));
    if(NULL == lqueue)
    {
        printf("malloc error\n");
        return NULL;
    }

    lqueue->phead = NULL;
    lqueue->ptail = NULL;
    lqueue->clen = 0;  

    return lqueue;
}

//判断队列是否为空
int is_lqueue_empty(Lqueue_t *lqueue)
{
    return NULL == lqueue->phead;
}

//遍历
void lqueue_for_each(Lqueue_t *lqueue)
{
    if(is_lqueue_empty(lqueue))
    {
        return ;
    }

    Lqnode_t *ptmp = lqueue->phead;
    while(ptmp)
    {
        printf("%d ", ptmp->data);
        ptmp = ptmp->pnext;
    }
    puts("");
}

//入队（尾插）
int insert_lqueue_tail(Lqueue_t *lqueue, Data_type_t data)
{
    Lqnode_t *pinset = malloc(sizeof(Lqnode_t));
    if(NULL == pinset)
    {
        printf("malloc error\n");
        return -1;
    }

    pinset->pnext  = NULL;
    pinset->data = data;

    if(is_lqueue_empty(lqueue))
    {
        lqueue->phead = pinset;
        lqueue->ptail = pinset;
    }
    else
    {
        lqueue->ptail->pnext = pinset;
        lqueue->ptail = pinset;
    }
    lqueue->clen++;

    return 0;
}

//出队(头删）
int delet_lqueue_head(Lqueue_t *lqueue, Data_type_t *pdata)
{
    if(is_lqueue_empty(lqueue))
    {
        return -1;
    }
    
    Lqnode_t *pdet = lqueue->phead;
    if(NULL != pdata)
    {
        *pdata = lqueue->phead->data;
    }

    lqueue->phead = pdet->pnext;
    if(NULL == pdet->pnext)
    {
        lqueue->ptail = NULL;
    }
    
    free(pdet);
    lqueue->clen--;
    
    return 0;
}

//获取队头元素
int get_top_lqueue(Lqueue_t *lqueue, Data_type_t *hdata)
{
    if(is_lqueue_empty(lqueue))
    {
        return -1;
    }

    if(hdata && lqueue->phead->data)
    {
        *hdata = lqueue->phead->data;
        printf("top : %d\n", *hdata);
    }
    return 0;
}

//销毁
void destroy_lqueue(Lqueue_t **lqueue)
{
    while((*lqueue)->phead)
    {
        delet_lqueue_head(*lqueue, NULL);
    }

    free(*lqueue);
    *lqueue =  NULL;
}


int main(void)
{
    Lqueue_t *lqueue = c_lqueue();
    if(NULL == lqueue)
    {
        printf("malloc error\n");
        return -1;
    }
    Data_type_t hdata;
    insert_lqueue_tail(lqueue, 1);
    insert_lqueue_tail(lqueue, 2);
    insert_lqueue_tail(lqueue, 3);
    insert_lqueue_tail(lqueue, 4);
    insert_lqueue_tail(lqueue, 5);
    
    lqueue_for_each(lqueue);

    delet_lqueue_head(lqueue, &hdata);
    lqueue_for_each(lqueue);
   
   
    get_top_lqueue(lqueue, &hdata);

    destroy_lqueue(&lqueue);

    return 0;
}

（2）循环队列

代码练习


#define SEQQUE_MAX_LEN 10

typedef int Data_type_t;

typedef struct seqque
{
    Data_type_t *pbase;
    int head;
    int tail;
}Seqque_t;



Seqque_t *create_seqque()
{
    Seqque_t *psq = malloc(sizeof(Seqque_t));
    if (NULL == psq)
    {
        printf("malloc error\n");
        return NULL;
    }
    psq->head = 0;
    psq->tail = 0;
    psq->pbase = malloc(sizeof(Data_type_t) * SEQQUE_MAX_LEN);
    if (NULL == psq->pbase)
    {
        printf("malloc error\n");
        return NULL;
    }

    return psq;
}

int is_full_seqque(Seqque_t *psq)
{
    if ((psq->tail+1)%SEQQUE_MAX_LEN == psq->head)
    {
        return 1;
    }
    return 0;
}

int is_empty_seqque(Seqque_t *psq)
{
    if (psq->head == psq->tail)
    {
        return 1;
    }
    return 0;
}

int push_seqque(Seqque_t *psq, Data_type_t data)
{
    if (is_full_seqque(psq))
    {
        printf("seqque is full\n");
        return -1;
    }

    psq->pbase[psq->tail] = data;
    psq->tail = (psq->tail+1) % SEQQUE_MAX_LEN;

    return 0;
}

void seqque_for_each(Seqque_t *psq)
{
    for (int i = psq->head; i != psq->tail; i = (i+1)%SEQQUE_MAX_LEN)
    {
        printf("%d ", psq->pbase[i]);
    }
    printf("\n");
}

//获取队头元素
int get_top_seqque(Seqque_t *psq, Data_type_t *data)
{
    if(is_empty_seqque(psq))
    {
        return -1;
    }
    
    if(NULL != data)
    {
        *data = psq->pbase[psq->head];
        printf("top : %d\n", *data);
    }

    return 0;
}

//出队
int pop_seqque(Seqque_t *psq, Data_type_t *data)
{
    if(is_empty_seqque(psq))
    {
        return -1;
    }

    if(NULL != data)
    {
        *data = psq->pbase[psq->head];
    }
    
    psq->head = (psq->head + 1) % SEQQUE_MAX_LEN;

    return 0;
}

//销毁
void destroy_seqque(Seqque_t **psq)
{
    free((*psq)->pbase);
    free(*psq);
    *psq = NULL;
}

int main(void)
{
    Seqque_t *psq = create_seqque();
    if (NULL == psq)
    {
        return -1;
    }

    for (int i = 0; i < 10; i++)
    {
        push_seqque(psq, i);
    }

    seqque_for_each(psq);
    
    Data_type_t data;
    get_top_seqque(psq, &data);

    pop_seqque(psq, &data);
    pop_seqque(psq, &data);
    seqque_for_each(psq);
    push_seqque(psq, 9);
    seqque_for_each(psq);
    
    destroy_seqque(&psq);
    
    return 0;
}

（3）队列与栈的区别

核心操作原则

  • 栈 (Stack):
    后进先出 (LIFO - Last In First Out)

    • 像一摞盘子：最后放上去的盘子（栈顶），总是最先被取走。

    • 操作只在一端（栈顶）进行：push（压栈/入栈）、pop（弹栈/出栈）、peek/top（查看栈顶）。

  • 队列 (Queue):
    先进先出 (FIFO - First In First Out)

    • 像排队：最早排队的人（队头），最先被服务离开。

    • 操作在两端进行：enqueue（入队）在队尾，dequeue（出队）在队头，peek/front（查看队头）。

操作位置

  • 栈： 所有有效操作（增、删、查）都集中在同一端（栈顶）。

  • 队列： 插入（enqueue）发生在队尾 (Rear)，删除（dequeue）发生在队头 (Front)。

【华为OD机考真题】- 入栈出栈(B卷-100分)（Python版）
**My Coding Family**
04-21 877
🔔本文收录于「最新最全华为OD机试真题(Python版)」专栏，手把手带你零基础教学华为OD机试。本题集提供最优题解思路，解题步骤，代码解析，复杂度分析及最优题解源码等，支持多语言题解，助你轻松拿捏OD机考，一举上岸！安利大家关注&&收藏&&订阅！题库正在疯狂收录中，up！up！up！！ 🚫提醒：拒绝一切代考/替考，违法必究！本人所写题库均精心搜集于互联网。    💗订阅福利：一次订阅，可永久免费阅读，提供在线答疑解惑，后续题库更新皆可阅读使用！
c语言堆栈基本代码入栈出栈_栈，C语言实现
weixin_36031304的博客
12-10 4810
什么是数据结构？数据结构是什么？要了解数据结构，我们要先明白数据和结构，数据就是一些int char 这样的变量，这些就是数据，如果你是一个篮球爱好者，那么你的球鞋就是你的数据，结构就是怎么把这些数据排列组合，怎么把数据摆放好才能方便你找到这些数据，把数据和结构合在一起理解就是所谓的数据结构，简单点，就是处理数据的方式方法。平时在家里面，你有没有随便摆放自己的鞋子，然后要找鞋子的时候要花...
华为OD机试真题 Python，简单的解压缩算法，入栈出栈，队列
L_goodboy的博客
05-27 331
华为OD机试真题 Python，简单的解压缩算法，入栈出栈，队列
c语言 循环队列出栈入栈,C语言实现,顺序队列，循环队列，和栈！
weixin_28686915的博客
05-22 1276
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端(front)进行删除操作，而在表的后端(rear)进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故...
栈与队列-之出栈和入栈
qq_41542141的博客
10-13 8329
栈的基本概念，以及出栈和入栈的对应顺序分析
c语言堆栈基本代码入栈出栈_数据结构定义一个栈并实现入栈和出栈操作的程序c语言完整版...
weixin_33318720的博客
12-23 1476
展开全部如下：#include"stdio.h"structstackNode{intdata;structstackNode*nextPtr;};typedefstructstackNodeLISTSTACK;typedefLISTSTACK*STACKNODEPTR;voidpush(STACKNODEPTR*,int);intpop(STACKNODEPTR*);...
数据结构——入栈，出栈，队列相关操作（C语言实现）
欢迎来到Gorit的博客
11-30 9587
阅读过程之中可能会花费比较多的时间：建议直接翻到最后，有完整的代码可以使用 （tips：仅供学习使用） 程序准备工作 #include <stdio.h> #include <malloc.h> #include <stdlib.h> #include<process.h> #define MaxSize 100 //最大元素个...
【数据结构2】第三章（1） 栈、入栈出栈、顺序栈和链栈、栈的递归、顺序栈的初始化
weixin_45991687的博客
04-05 2036
【数据结构2】第三章（1） 栈、入栈出栈、顺序栈和链栈、栈的递归、顺序栈的初始化
栈的建立【包括入栈出栈显示】（基于单链表实现）
weixin_51578598的博客
10-02 663
一般来说，c++有专门的STL，可以直接调用接口。怕自己忘记，我还是po出来了 C++标准库（STL）栈（stack）、队列（queue）、双向队列（deque）、容器（vector）的基本操作_云帆之路Tony的博客-CSDN博客 上面那个博客很赞很简洁，上面这些也不用刻意记，因为用多了自然熟。。。 现在我们看看通过单链表建立栈的操作（如有问题请指正！） 目录 建立链式栈（声明） 清空栈 入栈 出栈（删除栈顶元素） 取栈顶元素（不删除栈顶元素） 输出栈所有元素（递归） //基本栈
深入理解Deque队列入栈出栈
huawangxin
11-20 1414
import java.util.Deque; import java.util.LinkedList; /** * Deque是双端队列，队列的两端均可以入队与出队 * 当我们限制程序只能从队列的一段出队与入队 * 就形成了经典的数据结构“栈” * 栈存储元素遵循先进先出原则 * （FILO First Input last output） * @author h
Python 数据结构揭秘：栈与队列
qq_40025337的博客
01-04 1070
栈是一种后进先出（Last In First Out, LIFO）的数据结构。它类似于一个容器，只能在一端进行插入和删除操作。push（入栈）和pop（出栈）.队列是一种先进先出（First In First Out, FIFO）的数据结构。它类似于一个队列，元素从一端进入，从另一端出去。enqueue（入队）和dequeue（出队）.栈：适合需要回溯或撤销操作的场景，如函数调用、表达式求值等.队列：适合需要保持元素顺序的场景，如任务调度、缓冲处理等.
php线性表的入栈与出栈实例分析
12-18
本文将通过实例来探讨PHP中线性表的入栈（Push）与出栈（Pop）操作。 首先，入栈操作是将一个元素添加到线性表的末尾，这个过程在PHP中通常使用`array_push()`函数来完成。例如： ```php $stack = array("Simon", ...
栈的基本概述，生活中的栈，栈的创建，入栈出栈方式。
yhxz1的博客
03-21 696
栈的基本概述，生活中的栈，栈的创建，入栈出栈方式
数据结构算法-顺序表、栈和队列-顺序栈的出栈和入栈（适用考研408）
m0_46708584的博客
11-15 1068
栈是限定仅在表尾进行插入和删除操作的线性表，是特殊的线性表。栈顶(top)是允许插入和删除的一端，栈底(bottom)则是另一端。栈又称为后进先出的线性表（Last In First Out）简称LIFO结构。栈是一个线性表，具有线性关系，即前驱后继关系，在表尾中进行插入和删除操作时，这表尾指的是栈顶。
入栈出栈之间的关系
06-17
### 栈中入栈与出栈的操作关系 栈是一种后进先出（LIFO, Last In First Out）的线性数据结构，其操作主要集中在栈顶进行。栈的基本操作包括入栈（`push`）和出栈（`pop`）。入栈操作是指将一个元素添加到栈顶，而...
开发语言的优劣势对比及主要应用领域分析
qq_39980997的博客
07-13 1963
开发语言是构建数字世界的核心工具，不同语言各有专长。Python主导AI与数据科学，​JavaScript为Web前端基石，​Java/C#​掌控企业级系统，​Go领跑云原生开发，​C/C++​制霸高性能领域，​Kotlin/Swift引领移动生态。选型需聚焦三要素：​场景适配性​（Web/移动/系统/数据）、性能需求层级​（从脚本到内核优化）、开发生态成熟度​（团队技术栈与。选型需关注四个维度：​应用场景​（Web/移动/系统/数据）、性能要求、团队技术栈及开发效率。理解语言特性比追求“万能语言”更重要。
数据结构2.（双向链表，循环链表及内核链表）
2401_89312016的博客
08-05 587
本文详细介绍了三种链表的实现方法：双向链表、循环链表和内核链表。双向链表部分包含节点定义、创建、头插/尾插法、遍历、查找、修改、删除等操作实现；循环链表在双向链表基础上增加了循环特性，调整了遍历条件；内核链表部分分析了Linux内核中的链表实现，包括节点定义、初始化、插入/删除操作以及各类遍历宏定义。全文通过代码示例展示了链表的核心操作，重点比较了不同链表类型在实现上的差异，特别是循环链表和内核链表在结构设计和操作实现上的优化技巧。
数据结构04 栈和队列
最新发布
LI1109hd的博客
08-05 218
/队列: 先进先出。
排序算法-快速排序
Shenqialong的博客
08-02 444
快速排序摘要 快速排序是一种基于分治策略的高效排序算法，由Tony Hoare于1960年提出。其核心思想是：1)选择基准值；2)将数组划分为小于和大于基准值的两部分；3)递归排序子数组。Go语言实现展示了基础版本（时间复杂度O(n log n)）和优化版本（采用随机基准、三路分区和小数组插入排序优化）。算法演示版本详细展示了排序过程的分区和递归步骤。快速排序在实际应用中性能优异，是常用的排序算法之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值