数据结构栈和队列的操作（创建、入、出、遍历）

最新推荐文章于 2024-07-23 16:53:03 发布
最新推荐文章于 2024-07-23 16:53:03 发布
阅读量539 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62318298/article/details/131887773
版权

栈

  • 栈：在表尾进行插入和删除的操作受限的线性表

  • 逻辑结构：线性结构【一对一的关系】

  • 存储结构：顺序存储【顺序栈】、链式存储【链栈】

  • 栈的特点：
    先进后出【first in last out FILO表】
    后进先出【last in first out LIFO表】

  • 栈的入栈和出栈

顺序栈

  • 认识栈空、栈满
    在这里插入图片描述
    在这里插入图片描述

栈的插入

/*
 * function:    入栈
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int list_stack_push(datatype e,StackList *stack)
{
    //1,判断栈是否创建
    //2，判断栈是否为满
    if(NULL==stack || stack->top==MAXSIZE-1)
    {
    puts("push  stack  error");
    return -1;
    }
    //3,入栈：先加后压
    //stack->top++;
stack->data[++stack->top]=e;
    return 0;
}

栈的删除

/*
 * function:    出栈
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int list_stack_pop(StackList *stack)
{
    //1,判断栈是否创建
    //2，判断栈是否为空
    if(NULL==stack || stack->top==-1)
    {
    puts("pop error");
    return -1;
    }
    //3,出栈：先弹后减
    printf("pop data is:%d\n",stack->data[stack->top--]);
//    stack->top--;
    return 0;
}

栈的遍历

/*
 * function:    顺序栈的输出
 * @param [ in] 
 * @param [out] 
 * @return      无
 */
void stack_output(StackList *stack)
{
    //1,判断栈是否创建
    //2，判断栈是否为空
    if(NULL==stack || stack->top==-1)
    {
    puts("output error");
    return;
    }
    //3,输出
    for(int i=0;i<=stack->top;i++)
    {
    printf("%d\t",stack->data[i]);
    }
    puts("");
}

栈的创建

/*
 * function:    创建栈
 * @param [ in] 
 * @param [out] 
 * @return      
 */
StackList *create_stack()
{
StackList *stack=(StackList *)malloc(sizeof(StackList));
    if(NULL == stack)
    {
    return NULL;
    }
    //栈顶置空
stack->top=-1;
    memset(stack->data,0,sizeof(stack->data));
    return stack;
}

链栈

  • 顺序栈存在栈满、并且存储数据量小，所以引出链栈，链栈采用链式存储结构，没有栈满，动态申请空间，多适用于数据量较大的情况
    在这里插入图片描述

链栈节点创建【单链表节点创建】

/*
 * function:    创建一个节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
LinkStack create_node()
{
LinkStack node=(LinkStack)malloc(sizeof(struct Node));
    if(NULL==node)
    return NULL;
node->data=0;
node->next=NULL;
    return node;//0x10
}

链栈插入

/*
 * function:    链栈的入站
 * @param [ in] 
 * @param [out] 
 * @return      
 */

LinkStack link_stack_push(datatype e,LinkStack top)
{
    //在堆区创建一个节点
LinkStack node=create_node();//在堆区申请一个节点
node->data=e;//数据域赋值为e
    //node节点链接到链表中
node->next=top;
top=node;
    return top;//因为自定义函数指针的改变不影响实参，需要返回
}

链栈删除

/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
LinkStack link_stack_pop(LinkStack top)
{
    //判断链表是否为空
    if(NULL==top)
    {
    return top;
    }
    if(top->next==NULL)
    {
    free(L);
    L=NULL;
    }
    else
    {
    LinkStack q=top->next;
    top->data=q->data;
    top->next=q->next;
    free(q);
    q=NULL;
    }
return top;


}

链栈遍历

/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int link_output(LinkStack top)

{
    //判断是否创建
    //判断是否为空
    if(NULL==top )
    {
    return -1;
    }
    while(top!=NULL)
    {
    printf("%d\t",top->data);
    top=top->next;
    }
    puts("");
}

队列

  • 线性表长度：数组长度（不变）
  • 队头：第一个元素的下标
  • 队尾：最后一个元素后面的下标（方便下一个元素的插入）
  • 队空：队头==队尾
  • 队满：rear=MAXSIZE
  • 结构体定义
    在这里插入图片描述

顺序队列

创建

/*
 * function:    在堆区申请空间
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
QueueList *create_queue()
{
QueueList  *queue=(QueueList *)malloc(sizeof(QueueList));
    if(NULL==queue)
    return NULL;

queue->front=queue->rear=0;
    memset(queue->data,0,sizeof(queue->data));
    return queue;
}

入队

/*
 * function:    入队
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int enqueue(datatype e,QueueList *queue)
{
    //1,判断是否创建
    //2，判断是否满
    if(NULL==queue || queue->rear==MAXSIZE)
    {
    puts("enqueue error");
    return -1;
    }
    //3,入队：在队尾插入
queue->data[queue->rear++]=e;
//    queue->rear++;
    return 0;
    
}

出队

/*
 * function:    出队
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delqueue(QueueList *queue)
{
    //1,判断是否创建
    //2，判断是否为空
    if(NULL==queue || queue->front==queue->rear)
    {
    puts("delqueue error");
    return -1;
    }
    //3,出队：出队在队头
    printf("delqueue data is:%d\n",queue->data[queue->front++]);
//    queue->front++;

}

遍历

/*
 * function:    循环输出队列
 * @param [ in] 
 * @param [out] 
 * @return      无
 */
void output(QueueList *queue)
{
    //1,判断是否创建
    //2，判断是否为空
    if(NULL==queue || queue->front==queue->rear)
    {
    puts("output error");
    return;
    }
    //3,从队头到队尾输出
    for(int i=queue->front;i<queue->rear;i++)
    {
    printf("%d\t",queue->data[i]);
    }
    puts("");
}

循环队列

  • 因为顺序队列的使用是一次性的，会出现假溢问题，因此引出循环队列，解决溢出问题。
    在这里插入图片描述

入队

/*
 * function:    循环队列入队
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int enqueue(datatype e,QueueList *queue)
{
    //1,判断是否创建
    //2，判断是否满
    if(NULL==queue ||queue->front==(queue->rear+1)%MAXSIZE)
    {
    puts("enqueue error");
    return -1;
    }
    //3,入队：在队尾插入
queue->data[queue->rear]=e;
queue->rear=(queue->rear+1)%MAXSIZE;
    return 0;
    
}

出队

/*
 * function:    出队
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delqueue(QueueList *queue)
{
    //1,判断是否创建
    //2，判断是否为空
    if(NULL==queue || queue->front==queue->rear)
    {
    puts("delqueue error");
    return -1;
    }
    //3,出队：出队在队头
    printf("delqueue data is:%d\n",queue->data[queue->front]);
queue->front=(queue->front+1)%MAXSIZE;
    return 0;

}

遍历

/*
 * function:    循环输出队列
 * @param [ in] 
 * @param [out] 
 * @return      无
 */
void output(QueueList *queue)
{
    //1,判断是否创建
    //2，判断是否为空
    if(NULL==queue || queue->front==queue->rear)
    {
    puts("output error");
    return;
    }
    //3,从队头到队尾输出
    for(int i=queue->front;i!=queue->rear;i=(i+1)%MAXSIZE)
    {
    printf("%d\t",queue->data[i]);
    }
    puts("");
}

个数计算

/*
 * function:    计算循环队列个数
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int loop_queue_count(QueueList *queue)
{
 return (MAXSIZE-queue->front+queue->rear)%MAXSIZE;
}

链式队列

  • 因为循环队列存在队满的情况，且适用于数据量较小的时候，因此引出了链式队列，存储类型不同，不存在队满，可以存储数据量较多的时候
    在这里插入图片描述

创建

/*
 * function:    创建一个节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist create_node()
{
    Linklist node=(Linklist)malloc(sizeof(struct Node));
    if(NULL==node)
        return NULL;
    node->data=0;
    node->next=NULL;
    return node;//0x10
}

入队

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist insert_rear(datatype e,Linklist L)
{
    //创建一个新节点
    Linklist s=create_node();
    s->data=e;
    if(L==NULL)
    {
        L=s;
    }
    else
    {
        //rear指向最后一个节点的地址
        Linklist rear=L;
        while(rear->next!=NULL)
        {
            rear=rear->next;
        }
        rear->next=s;
    }
    return L;
}

出队

/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist delete_head(Linklist L)
{
    //判断链表是否为空
    if(NULL==L)
    {
        return L;
    }
    printf("delete data is:%d\n",L->data);
    if(L->next==NULL)
    {
        free(L);
        L=NULL;
    }
    else
    {
        Linklist q=L->next;
        L->data=q->data;
        L->next=q->next;
        free(q);
        q=NULL;
    }
    return L;


}

遍历

/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int link_output(Linklist L)
{
    //判断是否创建
    //判断是否为空
    if(NULL==L )
    {
        return -1;
    }
    while(L!=NULL)
    {
        printf("%d\t",L->data);
        L=L->next;
    }
    puts("");
}
奕书想睡觉了。
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---栈和队列（结构体实现）
malechi的博客
10-03 5016
目录   栈（LIFO） 顺序栈(sequential stack)及其基本运算的实现 共享栈(share stack) 链栈及其基本运算的实现 队列（Queue，FIFO） 顺序队(sequential queue)及其基本运算的实现 环形队列（或循环队列，circular queue)及其基本运算的实现 用队列中元素个数代替队尾指针的环形队列及其基本运算的实现 链队(lin...
数据结构---栈和队列(栈、队列、循环队列)
qq_47406941的博客
01-06 1118
一、栈 1.概念及结构特点         栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 栈的特点：只能在一端进行数据的插入和删除；遵循“先进后出”原则。 入栈和出栈操作 结构体定义 // 支持动态增长的栈 typedef int STDataType; typedef
线性表和栈
weixin_73560454的博客
01-18 64
数据结构，线性表，顺序表，链表，栈详解
栈的两种遍历方式
qq_19925065的博客
09-11 9416
一、普通遍历 public void test05(){ MyLinkedStack<String> myStack = new MyLinkedStack<String>(); myStack.push("1"); myStack.push("2"); myStack.push("3"); myStack.pus
栈与队列进阶
qq_58052034的博客
04-17 281
然后，我们定义了一个优先队列类PriorityQueue，它包含一个heap数组，用于存储元素，并提供了push和pop方法，实现插入和删除操作。具体来说，在循环队列中，队列头和队列尾都可以指向数组的任意位置，当队列到达数组末尾时，队列尾可以回到数组开头，从而形成一个环状结构。接下来，我们创建了一个最大长度为5的循环队列，并将5个元素依次插入到队列中，之后再试图插入一个元素，但由于队列已满，因此会抛出异常。接下来，我们创建了一个优先队列pq，并向其中插入了3个任务，每个任务都具有不同的优先级。
数据结构【队列】
huajian225的博客
06-15 2887
队列的概念 顺序队列 循环队列 顺序循环队列的ADT定义 1、简单结构体定义 2、初始化 3、队列的清空 4、计算队列的长度 5、判断队列是否为空 6、插入新的元素 7、元素的删除 8、遍历输出队列内的所有元素 链队列的ADT定义 1、链队列简单结构体定义 2、初始化链队列 3、判断链队列是否为空 4、清空链队列 5、销毁链队列 6、获取链队列的长度 7、获取链队列的头元素 8、在链队列尾插入新元素 9、删除链队列的头元素 10、遍历链队列中的元素 顺序队列和链式队列的比较
数据结构-----栈（栈的初始化、建立、入栈、出栈、遍历、清空等操作）
m0_73633088的博客
09-15 5908
大家好呀！今天我们开始学习新的线性表结构----栈，前面我们学习了链表以及链表的相关操作，那么栈跟链表有什么区别呢，操作如何呢？下面就一起来看看吧！栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
数据结构栈和队列（参考代码）
06-18
### 数据结构栈和队列知识点解析 #### 一、栈的基本概念与操作 **栈**是一种特殊的线性表，只允许在一端进行插入和删除操作，这一端被称为栈顶，另一端被称为栈底。栈遵循先进后出（First In Last Out, FILO）的...
数据结构 栈和队列算法讲解.docx
02-11
栈和队列是计算机科学中两种基础但至关重要的数据结构，它们在算法设计和实现中扮演着重要角色。本文将深入讲解栈和队列的算法，以及它们在实际问题中的应用。 栈是一种后进先出（LIFO，Last In First Out）的数据...
Python实现的栈、队列、文件目录遍历操作示例
09-19
总结，Python提供了丰富的数据结构和文件系统操作功能，使得实现栈、队列和目录遍历变得简单。在实际开发中，了解并熟练掌握这些基本操作对于编写高效、优雅的代码至关重要。无论是数据处理还是文件系统的操作，灵活...
数据结构 栈和队列
02-27
栈和队列是两种最基本且重要的数据结构，广泛应用于算法设计和程序实现中。 栈（Stack）被称为“后进先出”（Last In, First Out, LIFO）的数据结构。它的特点是插入和删除操作都集中在一端进行，这一端被称为栈顶...
数据结构---栈和队列之链栈（C语言）
05-05
通过阅读"数据结构---栈和队列之链栈（C语言）"的完整代码，可以深入理解这些概念以及C语言中链表和指针的实际操作。这个压缩包提供的源代码应该包含了上述所有操作的实现，可以作为学习和实践链栈操作的实例。
c语言 数据结构栈的创建
lovemingshu的博客
06-18 4814
栈是一种线性数据结构，采用先进后出的方式管理数据其中一段固定，称之为栈底，另一端随着数据进出而随时改变位置，叫做栈顶，用程序实现栈一定要记录栈顶的位置，往栈放入数据操作称之为入栈(压栈)，从栈中取出数据的操作称之为出栈(弹栈)，可以使用顺序结构来实现栈，这种栈叫顺序栈，也可以使用链式结构来实现栈，这种栈叫链式栈。 下面就是顺序栈的创建步骤和代码实现过程，用的是多文件的形式，我是在Linux系统下编...
【数据结构】顺序栈和链栈的基本操作（定义，初始化， 入栈，出栈，取栈顶元素，遍历，置空）
小吉妙妙屋
04-12 1万+
详细讲解顺序栈和链栈的初始化，入栈，出栈，取栈顶元素，遍历，置空等操作
C语言 队列（循环队列和链队初始化进出队等基本操作）
m0_73070900的博客
04-23 1万+
循环队列、链队的初始化、进队和出队等基本操作-----
顺序栈 C语言 进栈 出栈 遍历
宗谷的博客
04-05 9208
本文摘自《大话数据结构》 帮助大家书写顺序栈代码
栈——栈的定义及基本操作（初始化、判空、进栈、出栈、遍历栈、销毁栈等）
热门推荐
薛定谔的猫的博客
04-19 8万+
文章目录栈的定义栈的存储栈上的基本操作初始化判空操作进栈操作出栈操作读栈顶元素遍历栈销毁栈完整代码及实例共享栈 栈的定义 栈（Stack）是只允许在一端进行插入或删除操作的线性表。 栈的示意图： 栈顶Top：线性表允许插入和删除的那一端。 栈底Bottom：固定的，不允许进行插入和删除的另一端。  假设某个栈S={a1,a2, … ,an}，如上图所示，则a1为栈底元素，an为栈顶元素。由于只能在栈顶进行插入和删除操作，故进栈顺序为a1,a2, … ,an，出栈顺序为an, … ,a2,a1。故栈的操
数据结构遍历顺序栈_数据结构与算法（五）--- 栈
weixin_29279153的博客
02-12 905
栈栈(stack)又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。遵循先进后出原则栈.png顺序存储栈物理结构是顺序存储，先开辟一块内存空间，每...
数据结构：栈
最新发布
2301_79601095的博客
07-23 1286
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
数据结构：链队列的销毁及栈的实现
栈是一种遵循后进先出（LIFO）原则的线性数据结构，而队列则采用先进先出（FIFO）原则。在计算机科学中，栈和队列是基础且重要的数据结构，广泛应用于各种算法和程序设计中。 首先，让我们理解栈的基本概念。栈是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值