系统栈、数据结构栈、栈的基本操作、队列、队列的基本操作

已于 2024-03-22 09:39:31 修改
阅读量618 收藏 9
点赞数 19
文章标签： 数据结构 栈 vim linux 队列 栈与队列
于 2024-03-21 20:20:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71850179/article/details/136895667
版权

我要成为嵌入式高手之3月21日数据结构第四天！！
———————————————————————————— 

栈

先进后出、后进先出

一、系统栈

大小：8MB

1、局部变量

2、未经初始化为随机值

3、代码执行到变量定义时为变量开辟空间

4、当变量的作用域结束时回收空间

5、函数的形参和返回值

6、函数的调用关系、保护现场和恢复现场

7、栈的增长方向，自高向低增长

二、栈：FILO

怎样具备先进后出、后进先出？

类似羽毛球桶

FILO（栈）

只允许从一端进行数据的插入和删除的线性存储结构（线性表）（一对一的线性存储结构，与顺序表、链式表类似）

插入：入栈、压栈 — 栈顶（允许操作）

删除：出栈、弹栈 — 栈底（不允许操作）

顺序表——顺序栈

满增栈        满减栈        空增栈        空减栈

入栈时操作方法不同

满、空栈

栈顶所在位置是否存有元素

增、减栈

取决于栈增长的方向

增：栈顶由低地址向高地址

减：栈顶由高地址向低地址

链式表——链式栈

栈顶、栈底

栈的基本操作：

注：只针对于链式栈

1、创建栈

/* 创建栈 */
STACK_LIST *CreateStackList()
{
    STACK_LIST *plist = malloc(sizeof(STACK_LIST));
    if (NULL == plist)
    {
        perror("fail to malloc list");
        return NULL;
    }

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

    return plist;
}

2、入栈

/* 入栈 */
int JoinStrackNode(STACK_LIST *plist, DATA_TYPE data)
{
    STACK_NODE *pnode = malloc(sizeof(STACK_NODE));
    if (NULL == pnode)
    {
        perror("fail to malloc pnode");
        return -1;
    }
    pnode->data = data;
    pnode->pnext = NULL;

    pnode->pnext = plist->ptop;
    plist->ptop = pnode;
    plist->clen++;
    
    return 0;
}

3、出栈

/* 出栈 */
int LeaveStackNode(STACK_LIST *plist_in, STACK_LIST *plist_out)
{
    STACK_NODE *pfree = NULL;

    if (NULL == plist_in->ptop)
    {
        return -1;
    }
    else
    {
        pfree = plist_in->ptop;
        plist_in->ptop = plist_in->ptop->pnext;
        pfree->pnext = NULL;
        plist_in->clen--;
    }
    f (NULL == plist_out->ptop)
    {
        plist_out->ptop = pfree;
    }
    else
    {
        pfree->pnext = plist_out->ptop;
        plist_out->ptop = pfree;
        plist_out->clen++;
    }

    return 0;
}

4、获取栈顶元素

/* 获取栈顶元素 */
STACK_NODE *GetStackTop(STACK_LIST *plist)
{
    if (NULL == plist->ptop)
    {
        return NULL;
    }
    else
    {
        return plist->ptop;
    }
}

5、清空栈

/* 清空栈 */
int DeleteStackAll(STACK_LIST *plist)
{
    STACK_NODE *ptmp = plist->ptop;
    STACK_NODE *pfree = NULL;

    if (NULL == plist->ptop)
    {
        return -1;
    }
    while (ptmp != NULL)
    {
        pfree = ptmp;
        ptmp = ptmp->pnext;
        plist->ptop = ptmp;
        free(pfree);
    }

    return 1;
}

6、销毁栈

/* 销毁栈 */
int DestroyStack(STACK_LIST *plist)
{
    int ret = 0;

    if (NULL == plist->ptop)
    {
        free(plist);
    }
    else
    {
        ret = DeleteStackAll(plist);
        if (1 == ret)
        {
            free(plist);
        }
    }

    return 0;
}

7、测试：遍历

/* 测试:遍历 */
int SearchAllStack(STACK_LIST *plist)
{
    STACK_NODE *ptmp = plist->ptop;

    if (NULL == plist->ptop)
    {
        printf("NO DATA!\n");
        return -1;
    }
    else
    {
        while (ptmp != NULL)
        {
            printf("%d\n", ptmp->data);
            ptmp = ptmp->pnext;
        }
    }

    return 0;
}

总程序：

头文件

#ifndef _HEAD_H
#define _HEAD_H

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

typedef int DATA_TYPE;

typedef struct node
{
    DATA_TYPE data;
    struct node *pnext;
}STACK_NODE;

typedef struct list
{
    STACK_NODE *ptop;
    int clen;
}STACK_LIST;


extern STACK_LIST *CreateStackList();
extern int JoinStrackNode(STACK_LIST *plist, DATA_TYPE data);
extern int LeaveStackNode(STACK_LIST *plist_in, STACK_LIST *plist_out);
extern int SearchAllStack(STACK_LIST *plist);
extern STACK_NODE *GetStackTop(STACK_LIST *plist);
extern int DeleteStackAll(STACK_LIST *plist);
extern int DestroyStack(STACK_LIST *plist);

#endif

 main.c

#include "head.h"

int main(void)
{
    int ret = 0;

    /* 创建入栈列表 */
    STACK_LIST *plist_in = CreateStackList();
    if (NULL == plist_in)
    {
        perror("fail to create plist_in");
        return -1;
    }
    
    /* 创建出栈列表 */
    STACK_LIST *plist_out = CreateStackList();
    if (NULL == plist_out)
    {
        perror("fail to create plist_out");
        return -1;
    }

    /* 入栈 */
    JoinStrackNode(plist_in, 1);
    JoinStrackNode(plist_in, 2);
    JoinStrackNode(plist_in, 3);
    JoinStrackNode(plist_in, 4);
    JoinStrackNode(plist_in, 5);
    SearchAllStack(plist_in);
    printf("========================\n");

    /* 出栈 */
    LeaveStackNode(plist_in, plist_out);
    LeaveStackNode(plist_in, plist_out);
    LeaveStackNode(plist_in, plist_out);
    printf("plist_in:\n");
    SearchAllStack(plist_in);
    printf("========================\n");
    printf("plist_out:\n");
    SearchAllStack(plist_out);

    /* 获取栈顶元素 */
    STACK_NODE *top = GetStackTop(plist_in);
    if (NULL == top)
    {
        perror("fail to GetStackTop");
    }
    printf("top data:%d\naddr:%p\n", top->data, top);
    printf("========================\n");

    /* 清空栈 */
    DeleteStackAll(plist_in);
    SearchAllStack(plist_in);

    /* 销毁栈 */
    DestroyStack(plist_in);
    DestroyStack(plist_out);


    return 0;
}

功能函数

#include "head.h"

/* 创建栈 */
STACK_LIST *CreateStackList()
{
    STACK_LIST *plist = malloc(sizeof(STACK_LIST));
    if (NULL == plist)
    {
        perror("fail to malloc list");
        return NULL;
    }

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

    return plist;
}

/* 入栈 */
int JoinStrackNode(STACK_LIST *plist, DATA_TYPE data)
{
    STACK_NODE *pnode = malloc(sizeof(STACK_NODE));
    if (NULL == pnode)
    {
        perror("fail to malloc pnode");
        return -1;
    }
    pnode->data = data;
    pnode->pnext = NULL;

    pnode->pnext = plist->ptop;
    plist->ptop = pnode;
    plist->clen++;
    
    return 0;
}

/* 出栈 */
int LeaveStackNode(STACK_LIST *plist_in, STACK_LIST *plist_out)
{
    STACK_NODE *pfree = NULL;

    if (NULL == plist_in->ptop)
    {
        return -1;
    }
    else
    {
        pfree = plist_in->ptop;
        plist_in->ptop = plist_in->ptop->pnext;
        pfree->pnext = NULL;
        plist_in->clen--;
    }
    f (NULL == plist_out->ptop)
    {
        plist_out->ptop = pfree;
    }
    else
    {
        pfree->pnext = plist_out->ptop;
        plist_out->ptop = pfree;
        plist_out->clen++;
    }

    return 0;
}

/* 获取栈顶元素 */
STACK_NODE *GetStackTop(STACK_LIST *plist)
{
    if (NULL == plist->ptop)
    {
        return NULL;
    }
    else
    {
        return plist->ptop;
    }
}

/* 清空栈 */
int DeleteStackAll(STACK_LIST *plist)
{
    STACK_NODE *ptmp = plist->ptop;
    STACK_NODE *pfree = NULL;

    if (NULL == plist->ptop)
    {
        return -1;
    }
    while (ptmp != NULL)
    {
        pfree = ptmp;
        ptmp = ptmp->pnext;
        plist->ptop = ptmp;
        free(pfree);
    }

    return 1;
}

/* 销毁栈 */
int DestroyStack(STACK_LIST *plist)
{
    int ret = 0;

    if (NULL == plist->ptop)
    {
        free(plist);
    }
    else
    {
        ret = DeleteStackAll(plist);
        if (1 == ret)
        {
            free(plist);
        }
    }

    return 0;
}


/* 测试:遍历 */
int SearchAllStack(STACK_LIST *plist)
{
    STACK_NODE *ptmp = plist->ptop;

    if (NULL == plist->ptop)
    {
        printf("NO DATA!\n");
        return -1;
    }
    else
    {
        while (ptmp != NULL)
        {
            printf("%d\n", ptmp->data);
            ptmp = ptmp->pnext;
        }
    }

    return 0;
}

三、队列：FIFO

概念

允许从一端进行数据插入，而另一端进行数据删除的线性表

特性

先进先出、后进后出

应用场景：缓冲区（数据缓存）

为了解决高速设备和低速设备交互时速度不匹配问题，进行缓存（缓冲）

队列的基本操作：

1、创建队列

/* 创建队列 */
QUEUE_LIST *CreateQueueList()
{
    QUEUE_LIST *plist = malloc(sizeof(QUEUE_LIST));
    if (NULL == plist)
    {
        perror("fail to malloc list");
        return NULL;
    }

    plist->pbegin = NULL;
    plist->pend = NULL;
    plist->clen = 0;

    return plist;
}

2、创建队列元素 

QUEUE_NODE *CreateQueueNode(DATA_TYPE data)
{
    QUEUE_NODE *pnode = malloc(sizeof(QUEUE_NODE));
    if (NULL == pnode)
    {
        perror("fail to malloc node");
        return NULL;
    }
    pnode->data = data;
    pnode->pnext = NULL;

    return pnode;
}

3、入队操作

/* 入队 */
int JoinQueueNode(QUEUE_LIST *plist, QUEUE_NODE *pnode)
{
    QUEUE_NODE *ptmp = NULL;
    
    if (NULL == plist->pbegin)
    {
        plist->pbegin = pnode;
        plist->pend = pnode;
        plist->clen++;
    }
    else
    {
        ptmp = plist->pend;
        ptmp->pnext = pnode;
        plist->pend = pnode;
        plist->clen++;
    }

    return 0;
}

4、出队操作

/* 出队 */
int LeaveQueueNode(QUEUE_LIST *plist)
{
    QUEUE_NODE *ptmp = NULL;
    if (plist->pbegin == NULL)
    {
        printf("NO NODE TO LEAVE\n");
        return -1;
    }
    else if (plist->pbegin == plist->pend && plist->pbegin != NULL)
    {
        free(plist->pbegin);
        plist->clen--;
        plist->pbegin = NULL;
        plist->pend = NULL;
    }
    else
    {
        ptmp = plist->pbegin;
        while (ptmp->pnext->pnext != NULL)
        {
            ptmp = ptmp->pnext;
        }
        free(ptmp->pnext);
        ptmp->pnext = NULL;
        plist->pend = ptmp;
        plist->clen--;
    }
    return 0;
}

5、清空队列

/* 清空队列 */
int DeleteQueueAll(QUEUE_LIST *plist)
{
    QUEUE_NODE *ptmp = plist->pbegin;
    QUEUE_NODE *pfree = NULL;
    
    if (NULL == plist->pbegin && plist->pend == NULL)
    {
        return -1;
    }
    while (ptmp != NULL)
    {
        pfree = ptmp;
        ptmp = ptmp->pnext;
        plist->pbegin = ptmp;
        free(pfree);
        plist->clen--;
    }
    plist->pend = NULL;

    return 0;
}

6、获取队列队头的数据

/* 获取队头数据 */
QUEUE_NODE *GetQueueBegin(QUEUE_LIST *plist)
{
    if (NULL == plist->pbegin && NULL == plist->pend)
    {
        return NULL;
    }
    else
    {
        return plist->pbegin;
    }
}

7、销毁队列

/* 销毁队列 */
int DestroyQueue(QUEUE_LIST *plist)
{
    int ret = 0;

    if (NULL == plist->pbegin && plist->pend == NULL)
    {
        free(plist);
    }
    else
    {
        ret = DeleteQueueAll(plist);
        if (0 == ret)
        {
            free(plist);
        }
    }

    return 0;
}

8、测试：遍历

/* 测试:遍历 */
int SearchAllQueue(QUEUE_LIST *plist)
{
    QUEUE_NODE *ptmp = plist->pbegin;

    if (NULL == plist->pbegin && NULL == plist->pend)
    {
        printf("NO DATA!\n");
        return -1;
    }
    else
    {
        while (ptmp != NULL)
        {
            printf("%d\n", ptmp->data);
            ptmp = ptmp->pnext;
        }
    }
    printf("len = %d\n", plist->clen);

    return 0;
}

总程序

头文件：

#ifndef _HEAD_H
#define _HEAD_H

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

typedef int DATA_TYPE;

typedef struct node
{
    DATA_TYPE data;
    struct node *pnext;
}QUEUE_NODE;

typedef struct list
{
    QUEUE_NODE *pbegin;
    QUEUE_NODE *pend;
    int clen;
}QUEUE_LIST;


extern QUEUE_LIST *CreateQueueList();
extern QUEUE_NODE *CreateQueueNode(DATA_TYPE data);
extern QUEUE_NODE *GetQueueBegin(QUEUE_LIST *plist);
extern int JoinQueueNode(QUEUE_LIST *plist, QUEUE_NODE *pnode);
extern int LeaveQueueNode(QUEUE_LIST *plist);
extern int SearchAllQueue(QUEUE_LIST *plist);
extern int DeleteQueueAll(QUEUE_LIST *plist);
extern int DestroyQueue(QUEUE_LIST *plist);

#endif

功能函数：

#include "head.h"

/* 创建队列 */
QUEUE_LIST *CreateQueueList()
{
    QUEUE_LIST *plist = malloc(sizeof(QUEUE_LIST));
    if (NULL == plist)
    {
        perror("fail to malloc list");
        return NULL;
    }

    plist->pbegin = NULL;
    plist->pend = NULL;
    plist->clen = 0;

    return plist;
}

QUEUE_NODE *CreateQueueNode(DATA_TYPE data)
{
    QUEUE_NODE *pnode = malloc(sizeof(QUEUE_NODE));
    if (NULL == pnode)
    {
        perror("fail to malloc node");
        return NULL;
    }
    pnode->data = data;
    pnode->pnext = NULL;

    return pnode;
}

/* 入队 */
int JoinQueueNode(QUEUE_LIST *plist, QUEUE_NODE *pnode)
{
    QUEUE_NODE *ptmp = NULL;
    
    if (NULL == plist->pbegin)
    {
        plist->pbegin = pnode;
        plist->pend = pnode;
        plist->clen++;
    }
    else
    {
        ptmp = plist->pend;
        ptmp->pnext = pnode;
        plist->pend = pnode;
        plist->clen++;
    }

    return 0;
}

/* 出队 */
int LeaveQueueNode(QUEUE_LIST *plist)
{
    QUEUE_NODE *ptmp = NULL;
    if (plist->pbegin == NULL)
    {
        printf("NO NODE TO LEAVE\n");
        return -1;
    }
    else if (plist->pbegin == plist->pend && plist->pbegin != NULL)
    {
        free(plist->pbegin);
        plist->clen--;
        plist->pbegin = NULL;
        plist->pend = NULL;
    }
    else
    {
        ptmp = plist->pbegin;
        while (ptmp->pnext->pnext != NULL)
        {
            ptmp = ptmp->pnext;
        }
        free(ptmp->pnext);
        ptmp->pnext = NULL;
        plist->pend = ptmp;
        plist->clen--;
    }
    return 0;
}

/* 清空队列 */
int DeleteQueueAll(QUEUE_LIST *plist)
{
    QUEUE_NODE *ptmp = plist->pbegin;
    QUEUE_NODE *pfree = NULL;
    
    if (NULL == plist->pbegin && plist->pend == NULL)
    {
        return -1;
    }
    while (ptmp != NULL)
    {
        pfree = ptmp;
        ptmp = ptmp->pnext;
        plist->pbegin = ptmp;
        free(pfree);
        plist->clen--;
    }
    plist->pend = NULL;

    return 0;
}

/* 获取队头数据 */
QUEUE_NODE *GetQueueBegin(QUEUE_LIST *plist)
{
    if (NULL == plist->pbegin && NULL == plist->pend)
    {
        return NULL;
    }
    else
    {
        return plist->pbegin;
    }
}

/* 销毁队列 */
int DestroyQueue(QUEUE_LIST *plist)
{
    int ret = 0;

    if (NULL == plist->pbegin && plist->pend == NULL)
    {
        free(plist);
    }
    else
    {
        ret = DeleteQueueAll(plist);
        if (0 == ret)
        {
            free(plist);
        }
    }

    return 0;
}

/* 测试:遍历 */
int SearchAllQueue(QUEUE_LIST *plist)
{
    QUEUE_NODE *ptmp = plist->pbegin;

    if (NULL == plist->pbegin && NULL == plist->pend)
    {
        printf("NO DATA!\n");
        return -1;
    }
    else
    {
        while (ptmp != NULL)
        {
            printf("%d\n", ptmp->data);
            ptmp = ptmp->pnext;
        }
    }
    printf("len = %d\n", plist->clen);

    return 0;
}

主函数：

#include "head.h"

int main(void)
{
    /* 创建队列标签 */
    QUEUE_LIST *plist = CreateQueueList();
    if (NULL == plist)
    {
        perror("fail to create list");
        return -1;
    }

    /* 入队 */
    /* 创建队列结点 */
    QUEUE_NODE *pnode = CreateQueueNode(1);
    if (NULL == pnode)
    {
        perror("fail to create node");
        return -1;
    }
    JoinQueueNode(plist, pnode);

    pnode = CreateQueueNode(2);
    if (NULL == pnode)
    {
        perror("fail to create node");
        return -1;
    }
    JoinQueueNode(plist, pnode);
    pnode = CreateQueueNode(3);
    if (NULL == pnode)
    {
        perror("fail to create node");
        return -1;
    }
    JoinQueueNode(plist, pnode);
    pnode = CreateQueueNode(4);
    if (NULL == pnode)
    {
        perror("fail to create node");
        return -1;
    }
    JoinQueueNode(plist, pnode);
    pnode = CreateQueueNode(5);
    if (NULL == pnode)
    {
        perror("fail to create node");
        return -1;
    }
    JoinQueueNode(plist, pnode);
    SearchAllQueue(plist);
    printf("=========================\n");

    /* 获取队头数据 */
    pnode = GetQueueBegin(plist);
    if (NULL == pnode)
    {
        perror("this queue no begin\n");
    }
    else
    {
        printf("head data:%d\nhead addr:%p\n", pnode->data, pnode);
        printf("=========================\n");
    }
#if 0
    /* 出队一次一个结点 */
    LeaveQueueNode(plist);
    LeaveQueueNode(plist);
    SearchAllQueue(plist);
    printf("=========================\n");
#endif
#if 1
    /* 清空队列 */
    DeleteQueueAll(plist);
    SearchAllQueue(plist);
    printf("=========================\n");
#endif
    /* 销毁队列 */
    DestroyQueue(plist);

    return 0;
}

7.25！
关注
  • 19
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻，对每一组输入数据进行操作后的输出数据为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车离去；则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。栈以顺序结构实现，队列以链表实现。 需另设一个栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车，也用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中每个元素表示一辆汽车，包含两个数据项：汽车的牌照号码和进入停车场的时刻。
数据结构实验报告2-栈与队列-队列基本操作算法-实验内容及要求.docx
07-06
编写程序，建立容量为n(建议n=8)的循环队列，完成以下程序功能。输入字符#，执行一次出队操作，屏幕上显示出队字符；输入字符@，队列中所有字符依次出队并按出队次序在屏幕上显示各字符；输入其它字符，则输入的字符入队。 要求采用队头/队尾间隔至少一个空闲元素的方法来实现循环队列；空队执行出队操作及队满执行入队操作需显示提示信息。
数据结构C++ 顺序栈、链栈、循环队列、链队列的主要操作（Word文档含代码和注释）
11-04
注：分为四个内容：顺序栈、链栈、循环队列、链队列。代码由C++程序设计语言编写，包含栈和队列的基本操作（栈：出、入、取、判空等|队列：出、入、取、打印队列、判空等），并展示了三个具体的使用例子，包括用栈求进制转换和用队列打印杨辉三角形，以及用栈计算后缀表达式。代码均已通过VS（附有运行结果截图）。为了防止误修改，文档已限制编辑，密码是：1234。本资源适合数据结构初学者和期末复习等，代码仅供参考。
Java模拟栈和队列数据结构的基本示例讲解
09-02
主要介绍了Java模拟栈和队列数据结构的基本示例,栈的后进先出和队列的先进先出是数据结构中最基础的知识,本文则又对Java实现栈和队列结构的方法进行了细分,需要的朋友可以参考下
Python 实现数据结构中的的栈队列
09-19
主要介绍了Python 实现数据结构中的的栈，队列,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构实验三——栈和队列的基本操作
weiyuexin的博客
10-11 5645
** 一、实验内容 ** 1. 实验目的 编程实现顺序栈和链栈的基本操作：建栈，取栈顶元素，入栈，出栈； 编程实现循环队列和链队列的基本操作：建队列，取队头元素，入队，出队。 2. 基本要求 掌握栈的顺序存储结构、链式存储结构及其基本操作； 掌握队列的顺序存储结构、链式存储结构及其基本操作。 4. 支撑的课程目标 本实验项目可以支撑“目标1. 理解数据结构的基本概念、计算机内部数据对象的表示和特性。掌握线性表、树、图等数据逻辑结构、存储结构及其差异以及各种操作的实现。”、和“目标2能够针对实际问题选
数据结构实验六 栈和队列的基本操作及应用
qq_64314976的博客
08-07 2169
它只允许在表的一端进行插入，而在另一端删除元素。队列也有两种存储表示，顺序表示（循环队列）和链式表示（链队）。队列的主要操作是进队和出队，对于顺序的循环队列的进队和出队操作要注意判断队满或队空。1.栈是限定仅在表尾进行插入或删除的线性表，又称为先进后出的线性表。栈有两种存储表示，顺序表示（顺序栈）和链式表示（链栈）。栈的主要操作是进栈和出栈，对于顺序栈的进栈和出栈操作要注意判断栈满或栈空。2. 掌握队列的链式表示和实现。1. 掌握栈的顺序表示和实现；2.实现队列的链式表示和实现。1.链栈实现数制的转换。..
数据结构 实验四 栈和队列的基本操作的实现
m0_51308557的博客
12-19 4071
（1）用栈实现括号匹配的检验（2）用栈实现形如a+b@b+a#的中心对称的字符序列的检验。（3）用队列实现形如a+b@b+a#的中心对称的字符序列的检验
数据结构实验--栈和队列操作
跳跳糖°的博客
04-17 3296
数据结构实验–顺序栈的操作 文章目录数据结构实验--顺序栈的操作一、实验要求二、实验核心算法二、实验代码示例 一、实验要求 编程实现栈的以下基本操作：建栈，取栈顶元素，入栈，出栈，显示顺序栈元素 二、实验核心算法 （1）定义顺序栈的存储结构，用base表示栈底指针，top表示栈顶指针，stacksize表示栈的容量 typedef struct { SElemType *base; //栈底指针 SElemType *top; //栈顶指针 int s
数据结构栈和队列的基本操作
lizhi20210729的博客
11-21 1412
前言 这一篇我就不附书上代码了，太慢。 线性表的应用 线性表的合并 int ListLength(LNode L) { int i=0; LinkList p; p=L.next; while(p) { i++; p=p->next; } return i; } void MergeList(LinkList LA,LNode LB) { int m,n,i,e; m=ListLength(*LA);n=ListLength(
C 数据结构队列和栈基本操作
牧野的博客
11-05 1630
队列 队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。队列是一种操作受限制的线性表。 与现实中的排队类似，进行插入操作只能在队尾，进行删除操作只能在队头。队列是一种先进先出的线性表。 C实现队列，需要定义一个结点结构，一个含指向首结点和尾结点指针的结构（比链表多一个指向首尾的结构）。 队列的首指针指向第一个元素，队列的尾指针指向最后...
栈和队列基本操作
mz474920631的博客
11-30 3529
栈和队列一、栈栈是什么栈的实现栈的基本操作栈类型的定义初始化栈检查栈是否为满入栈出栈获取栈顶元素检测栈是否为空测试函数完整代码Stack.hStack.cmain.c二、队列队列是什么队列的实现队列类型的定义申请一个节点初始化队列队尾入队列队头出队列获取队列头部元素获取队列队尾元素获取队列中有效元素个数检测队列是否为空销毁队列测试函数完整代码三、环形队列假溢出问题 一、栈 栈是什么   栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈
数据结构实验报告：栈和队列的基本操作及应用
2码8改
01-30 1万+
                                          Rails（***） 一、实验目的 1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。 2、掌握栈和队列的特点，即后进先出和先进先出的原则。 3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序存储结构和链式存储结构上的实现。 二、实验题目（已选题目四） 本次实验提供4个...
数据结构——栈的详解
晴空๓
04-20 7万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
第十三讲：指针（5）
2301_79761834的博客
05-18 954
第十三讲：指针（5）
【数据结构】栈和队列
GGDxianv的博客
05-13 1225
这篇文章来讲数据结构中的栈和队列，栈和队列都是用顺序表来实现的是两种特殊的顺序表。
数据结构------二叉树经典习题2
最新发布
jj666mhhh的博客
05-18 467
-二叉树经典习题
数据结构栈和队列（队列的详解）
的博客
05-17 882
假设开始队列为空，phead和ptail都指向NULL要改变一级指针的指向(值)要使用二级指针，解引用改变一级指针。
 数据结构栈和队列基本操作
06-07
栈(Stack)和队列(Queue)是两种基本的数据结构。它们都是线性结构，但它们的操作方式有所不同。 栈的基本操作有： 1. push(item)：将元素压入栈顶。 2. pop()：将栈顶元素弹出。 3. top()：返回栈顶元素，但不弹...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值