Stack and Queue

最新推荐文章于 2025-07-12 15:53:26 发布

原创最新推荐文章于 2025-07-12 15:53:26 发布 · 881 阅读

1 ·

CC 4.0 BY-SA版权

Data Structure 专栏收录该内容

24 篇文章

订阅专栏

本文详细介绍了栈和队列这两种基本的数据结构。包括它们的定义、特点、存储结构及实现方式等。通过本文，读者可以了解到栈的先进后出(FILO)特性，队列的先进先出(FIFO)特性，以及顺序栈、链式栈、顺序队列和链式队列的具体实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、栈的定义
    栈是一种只能在一端进行插入或删除操作的线性表。其中允许进行插入或删除的一端称为栈顶(TOP)，表的另一端称为栈底，栈底是固定不变的。
2、栈的特点
    先进后出(FILO)
3、栈的存储结构
    顺序栈和链式栈；栈本质上是线性表
4、栈的数学性质
    当n个元素以某种顺序进栈，并且可在任意时刻出栈(在满足先进后出的前提下)时，所获得的元素排列的数目N恰好满足函数Catalan()的计算。
5、队列的定义
    队列是一种操作受限的线性表，其限制为仅允许在表的一端进行插入，在表的另一端进行删除。可进行插入的一端称为队尾(Rear),可进行删除的一端称为队头(Front)。
6、队列的特点
    先进先出(FIFO)
7、队列的存储结构

顺序队列和链式队列

8、栈和队列的存储结构

#define maxSize 100 //这里定义一个整型常量maxSize，值为100

//顺序栈定义
typedef struct{
    int data[maxSize];  //存放栈中元素
    int top;    //栈顶指针
}SqStack;   //顺序栈类型定义

//链式栈结点定义
typedef struct{
    int data;   //数据域
    struct LNode *next; //指针域
}LNode;   //链栈结点定义

//顺序队列定义
typedef struct{
    int data[maxSize];
    int front;  //对头指针
    int rear;   //队尾指针
}SqQueue;   //顺序队列类型定义

//链队定义
//队结点类型定义
typedef struct QNode{
    int data;   //数据域
    struct QNode *next; //指针域
}QNode; //队结点类型定义
//链队类型定义
typedef struct{
    QNode *front;   //队头指针
    QNode *rear;    //队尾指针
}LiQueue;   //链队类型定义

9、顺序栈

//初始化栈
void initStack(SqStack &st)
{
    st.top = -1;    //只需将栈顶指针设置为-1
}

//判断栈空
//栈st为空的时候返回1，否则返回0，其对应代码如下：
int isEmpty(SqStack st)
{
    if (st.top == -1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

//进栈
int push(SqStack &st, int x)
{
    if (st.top == maxSize-1)    //栈满不能进栈，防止上溢
    {
        return 0;
    }
    ++(st.top); //先移动指针，再进栈
    st.data[st.top] = x;
    return 1;
}

//出栈
int pop(SqStack &st, int &x)
{
    if (st.top == -1)   //如果栈空，则不能出栈
    {
        return 0;
    }
    x = st.data[st.top];
    --(st.top);
    return 1;
}

//【简略版】
//定义一个栈并且初始化
int stack[maxSize];
int top = -1;

//元素x进栈
stack[++top] = x;

//元素x出栈
x = stack[top--];

10、链栈

//链栈的初始化
void initStack(LNode *&lst)
{
    lst = (LNode*)malloc(sizeof(LNode));    //制造一个头结点
    lst->next = NULL;
}

//判断栈空
//当栈空的时候返回1，否则返回0，其代码如下：
init isEmpty(LNode *lst)
{
    if (lst->next == NULL)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

//进栈
void push(LNode *lst, int x)
{
    LNode *p;
    p = (LNode*)malloc(sizeof(LNode));  //为进栈元素申请结点空间
    p->next = NULL;
    //链表的头插法
    p->data = x;
    p->next = lst->next;
    lst->next = p;
}

//出栈
//在栈不空的情况可以执行，返回1，否则返回0，其实现如下：
int pop(LNode *lst, int &x)
{
    LNode *p;
    if (lst->next == NULL)  //栈空则不能在出栈，返回0
    {
        return 0;
    }
    //单链表的删除操作
    p = lst->next;
    x = p->data;
    lst->next = p->next;
    free(p);
    return 1;
}

11、顺序队

//初始化队列算法
void initQueue(SqQueue &qu)
{
    qu.front = qu.rear = 0; //队首和队尾指针重合，并且指向0
}

//判断队空
int isQueueEmpty(SqQueue qu)
{
    if (qu.front == qu.rear)    //无论队首、队尾指针指向数组中的哪个位置，只要两者重合，即为队空
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

//进队
int enQueue(SqQueue &qu, int x)
{
    if ((qu.rear+1)%maxSize == qu.front)    //队满的判断条件，队满就不能入队
    {
        return 0;
    }
    qu.rear = (qu.rear+1)%maxSize;  //若队未满，则先移动指针,再存入元素
    qu.data[qu.rear] = x;
    return 1;
}

//出队
int deQueue(SqQueue &qu, int &x)
{
    if (qu.front == qu.rear)    //若队空，则不能出队
    {
        return 0;
    }
    qu.front = (qu.front+1)%maxSize;    //若队不空，则先移动指针，再取出元素
    x = qu.data[qu.front];
    return 1;
}

12、链队

//初始化链队
void initQueue(LiQueue *&lqu)
{
    lqu = (LiQueue*)malloc(sizeof(LiQueue));
    lqu->front = lqu->rear = NULL;
}

//判断队空
int isQueueEmpty(LiQueue *lqu)
{
    if (lqu->rear==NULL || lqu->front==NULL)    //队空判断条件
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

//入队
void enQueue(LiQueue *lqu,int x)
{
    QNode *p;
    p = (QNode*)malloc(sizeof(QNode));
    p->data = x;
    p->next = NULL;
    if (lqu->rear == NULL)  //若队列为空，则新结点是队首结点，也是队尾结点
    {
        lqu->front = lqu->rear = p; //特殊情况，只有一个新结点时，应将front和rear同时指向新结点
    }
    else
    {
        lqu->rear->next = p;    //将新结点链接到队尾，rear指向空
        lqu->rear = p;
    }
}

//出队
int deQueue(LiQueue *lqu, int &x)
{
    QNode *p;
    if (lqu->rear == NULL)  //队空不能出队
    {
        return 0;
    }
    else    //若队中不为空，则从队头取出一个结点
    {
        p = lqu->front;
    }
    if (lqu->front == lqu->rear)    //队列中只有一个结点时的出队操作需特殊处理
    {
        lqu->front = lqu->rear = NULL;
    }
    else
    {
        lqu->front = lqu->front->next;
    }
    x = p->data;
    free(p);
    return 1;
}