栈和队列（内含两者间的相互转化）

最新推荐文章于 2024-07-13 17:12:41 发布
最新推荐文章于 2024-07-13 17:12:41 发布
阅读量1k 收藏 9
点赞数 30
文章标签： 数据结构 链表 c语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74234168/article/details/129785979
版权

前言：

当今信息化时代，数据结构作为计算机科学的基础学科之一，无疑具有重要的地位和作用。在日常开发和算法设计中，我们经常需要运用各种数据结构来解决问题。而其中最常用的两种数据结构就是栈和队列。本篇博客将介绍如何用栈实现队列以及用队列实现栈，希望能够帮助读者深入理解栈和队列的概念，掌握它们之间的相互转换方法，从而更加灵活地运用它们来解决实际问题。

一，栈：

定义

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

图示：

根据栈后入先出（LIFO）的特点，我们可以将它看作一个桶，我们只能再最顶层添加元素，也只能移走最顶层的元素

“栈溢出”：需要注意的是栈是计算机暂时存储数据的地方，空间是有限的，当栈满时再有元素入栈就会发生上溢。当栈空时再出栈就会导致下溢。

实现：

我们可以用链表或数组来实现栈的结构，两者的优劣如下：

数组能做到随机的快速（通过下标）的访问元素，查询速度快，但当涉及到元素的增删时需要在数组空间中移动大量的数据而导致效率低下。

链表只支持顺序访问，由于需要遍历，导致查找元素效率低，但是增删元素快速。

由于我们模拟栈主要涉及元素的插入和删除，下文我将使用链表来实现栈。

头文件的引用：
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
节点的定义：
typedef int StackDataType;

typedef struct Stack
{
    int* a;
    int top;
    int capacity;
}Stack;
各接口的声明：
void StackInit(Stack* ps);//栈的初始化
void StackDestroy(Stack* ps);//栈的销毁
void StackPush(Stack* ps, StackDataType x);//入栈
void StackPop(Stack* ps);//出栈
int StackTop(Stack* ps);//返回栈顶元素
bool StackEmpty(Stack* ps);//判断栈是否为空
void StackPrint(Stack* ps);//栈元素的打印
  1. 栈的初始化
void StackInit(Stack* ps)
{
    assert(ps);//assert的作用是判断ps是否不为空，下文作用相同

    ps->a = (StackDataType*)malloc(sizeof(StackDataType) * 4);
    if (ps->a == NULL)//当ps->a == NULL时即为扩容失败
    {
        perror("malloc fail");
        return;
    }

    ps->capacity = 4;//初始化容量为4
    ps->top = 0;
}
  1. 栈的销毁
void StackDestroy(Stack* ps)
{
    assert(ps);

    free(ps->a);//释放ps->a的空间
    ps->a = NULL;//指针置空
    ps->top = 0;
    ps->capacity = 0;
}
3.入栈

入栈分两种情况，一种是栈没满，这时只需要加入栈顶元素然后ps->top++即可；另一种是栈满了，此时需要先扩容。

void StackPush(Stack* ps, StackDataType x)
{
    assert(ps);

    if (ps->top == ps->capacity)//扩容过程
    {
        StackDataType* tmp = (StackDataType*)realloc(ps->a, sizeof(StackDataType) * ps->capacity * 2);

        if (tmp == NULL)
        {
            perror("realloc fail");
            return;
        }

        ps->a = tmp;
        ps->capacity *= 2;
    }

    ps->a[ps->top] = x;//top是从0开始的
    ps->top++;
}

4.出栈

出栈的过程可以通过缩小栈的大小来完成，因为size减小时无法访问原栈顶元素，类似于将栈顶元素移出栈。

void StackPop(Stack* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));//这里需要判断栈是否已空防止栈溢出

    ps->top--;
}
5.返回栈顶元素
int StackTop(Stack* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    return ps->a[ps->top - 1];//之所以是ps->top-1前面在入栈时已经说明，下文相同
}
6.判断栈是否为空
bool StackEmpty(Stack* ps)
{
    assert(ps);

    return ps->top == 0;
}
7.栈元素的打印
void StackPrint(Stack* ps)
{
    assert(ps);
    int i = ps->top-1;
    while (i>=0)
    {
        printf("%d\n", ps->a[i]);
        i--;
    }
}
效果演示：

二，队列：

定义：

队列（Queue）是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

图示：

根据队列先入先出（FIFO）的特点，我们可以将它看作高速公路上的收费站，各元素需要排好队，先入队列的先出队列。

实现：

我们同样可以使用数组或链表来实现队列，究竟选哪种，先让我们来看看两者的优缺点。

数组实现队列的优点：

  • 数组实现队列的代码相对简单易懂，不需要涉及指针等概念。

  • 数组的存储方式是连续的，因此访问效率较高。

数组实现队列的缺点：

  • 数组需要预先定义好大小，且不能动态调整大小，如果队列需要存储的元素数量超过了数组大小，就会发生溢出错误。

  • 在删除队列元素时，需要移动整个数组中的元素，效率较低。

链表实现队列的优点：

  • 链表可以动态分配内存，可以适应不同大小的队列。

  • 在删除队列元素时，只需要改变链表指针的指向，不需要移动整个链表，效率较高。

链表实现队列的缺点：

  • 链表的存储方式是不连续的，访问效率较低。

  • 链表实现队列的代码相对较复杂，需要涉及指针等概念，容易出现指针问题导致程序出错。

综上所述，如果队列元素数量不大且固定，且需要访问效率高，可以选择使用数组实现队列；如果队列元素数量不确定，且需要删除操作频繁，可以选择使用链表实现队列。当然，在实际情况中，也可以根据具体场景进行综合考虑和权衡，选择最合适的实现方式。

由于我们的重点仍然是增删操作，下文我仍然使用链表来实现队列。

头文件的引用：
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
节点的定义：
typedef int QueueDataType;
// 定义队列结点
typedef struct Node 
{
    QueueDataType data;
    struct Node *next;
} Node;

// 定义队列结构体
typedef struct Queue 
{
    Node *front; // 队头指针
    Node *rear; // 队尾指针
} Queue;
各接口的声明：
Queue* QueueCreate();//队列的初始化
void QueueDestroy(Queue *q);//队列的销毁
void QueuePush(Queue *q, QueueDataType data) ;//入对
QueueDataType QueuePop(Queue *q);//出对
bool QueueIsEmpty(Queue *q);//判断队列是否为空
void QueuePrint(Queue *q);//队列元素的打印
  1. 队列的初始化
Queue* QueueCreate() 
{
    Queue *q = (Queue*)malloc(sizeof(Queue));
    if (q == NULL) 
    {
        printf("Memory allocation failed.\n");
        return NULL;
    }
    q->front = q->rear = NULL;
    return q;
}
2.队列的销毁
void QueueDestroy(Queue *q) 
{
    assert(q);
    Node *temp;
    while (q->front != NULL) 
    {
        temp = q->front;
        q->front = q->front->next;
        free(temp);
        temp=NULL;
    }
    free(q);
    q=NULL;
}
3.入队
void QueuePush(Queue *q, QueueDataType data) 
{
    Node *node = (Node*)malloc(sizeof(Node));
    if (node == NULL) 
    {
        printf("Memory allocation failed");
        return;
    }
    node->data = data;
    node->next = NULL;
    if (q->front == NULL) 
    {
        q->front = node;
        q->rear = node;
    } 
    else 
    {
        q->rear->next = node;
        q->rear = node;
    }
}
4.出队

出队时需要判断对头是否为空，以及出队后队列是否为空（若出对后为空队列则队尾要置空）

int QueuePop(Queue *q) 
{
    assert(q);

    if (q->front == NULL) 
    {
        printf("Queue is empty.\n");
        return -1;
    }
    int data = q->front->data;
    Node *temp = q->front;
    q->front = q->front->next;
    free(temp);
    temp = NULL;
    if (q->front == NULL) 
    {
        q->rear = NULL;
    }
    return data;
}
5.判断队列是否为空
bool QueueIsEmpty(Queue *q)
{
    assert(q);

    return q->front == NULL;
}
6.队列元素的打印
void QueuePrint(Queue *q) 
{
    assert(q);

    if (QueueIsEmpty(q)) 
    {
        printf("Queue is empty.\n");
        return;
    }
    Node *node = q->front;
    while (node != NULL) 
    {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}
效果演示：

三，用栈实现队列：

题目参考：力扣232. 用栈实现队列

由于栈只能从顶部入栈和出栈，想用栈模拟队列就需要两个栈，一个用来模拟队列尾部入队列，一个用来模拟队列头部出队列。如下图所示，入队顺序为1-2-3，出队顺序也为1-2-3。

代码：

为了避免代码太多造成阅读困难，下面我将代码分为4个文件，需要使用时可通过头文件"myQueue.h"调用,代码如下：

  1. myQueue.h
#pragma once
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
#include<stdio.h>
#include"Stack.h"

typedef struct {
    Stack pushst;
    Stack popst;
} MyQueue;

MyQueue* myQueueCreate();//队列的创建（由入入栈和出出栈两个栈组成）
void myQueuePush(MyQueue* obj, int x);//将元素X推到队列的末尾
int myQueuePop(MyQueue* obj);//从队列的开头移除并返回元素
int myQueuePeek(MyQueue* obj);//返回队列开头的元素
bool myQueueEmpty(MyQueue* obj);//判断队列是否为空
void myQueueFree(MyQueue* obj);//释放队列
2. Stack.h
#pragma once
#include"myQueue.h"
typedef int StackDataType;

typedef struct Stack
{
    int* a;
    int top;
    int capacity;
}Stack;

void StackInit(Stack* ps);
void StackDestroy(Stack* ps);
void StackPush(Stack* ps, StackDataType x);
void StackPop(Stack* ps);
int StackTop(Stack* ps);
bool StackEmpty(Stack* ps);
3. Stack.c

该文件下各函数都时上文再栈的模拟实现中已经完成了的，我们可以直接用，下面的代码仅仅是将各函数总结到一起而已

#include "myQueue.h"

void StackInit(Stack* ps)
{
    assert(ps);

    ps->a = (StackDataType*)malloc(sizeof(StackDataType) * 4);
    if (ps->a == NULL)
    {
        perror("malloc fail");
        return;
    }

    ps->capacity = 4;
    ps->top = 0;
}

void StackDestroy(Stack* ps)
{
    assert(ps);

    free(ps->a);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}

void StackPush(Stack* ps, StackDataType x)
{
    assert(ps);

    if (ps->top == ps->capacity)
    {
        StackDataType* tmp = (StackDataType*)realloc(ps->a, sizeof(StackDataType) * ps->capacity * 2);

        if (tmp == NULL)
        {
            perror("realloc fail");
            return;
        }

        ps->a = tmp;
        ps->capacity *= 2;
    }

    ps->a[ps->top] = x;
    ps->top++;
}

bool StackEmpty(Stack* ps)
{
    assert(ps);

    return ps->top == 0;
}

void StackPop(Stack* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    ps->top--;
}

int StackTop(Stack* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    return ps->a[ps->top - 1];
}
4. myQueue.c
#include"myQueue.h"

MyQueue* myQueueCreate()
{
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    if (obj == NULL)
    {
        perror("malloc fail");
        return NULL;
    }

    StackInit(&obj->pushst);//入入栈初始化
    StackInit(&obj->popst);//出出栈初始化
    return obj;
}

void myQueuePush(MyQueue* obj, int x)
{
    StackPush(&obj->pushst, x);
}

int myQueuePeek(MyQueue* obj)
{
    if (StackEmpty(&obj->popst))
    {
        //倒数据
        while (!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst, StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }

    return StackTop(&obj->popst);
}

bool myQueueEmpty(MyQueue* obj)
{
    return StackEmpty(&obj->pushst) && StackEmpty(&obj->popst);
}

int myQueuePop(MyQueue* obj)
{
    int front = myQueuePeek(obj);
    StackPop(&obj->popst);

    return front;
}

void myQueueFree(MyQueue* obj)
{
    StackDestroy(&obj->pushst);
    StackDestroy(&obj->popst);

    free(obj);
}
效果演示：

四，用队列实现栈：

题目参考：力扣225. 用队列实现栈

用队列实现栈，关键是如何实现栈”后入先出“的特点，这里我们额外借助一个空队列用于移出先入的元素，那么在原队列中剩下的一个元素即为栈顶元素，移除栈顶元素后我们又得到了一个空队列，重复上面的操作就可以不断的移出栈顶元素，这样就可以实现用队列实现栈

代码：
  1. myStack.h
#include<stdio.h>
#include<stdbool.h>
typedef int QDatatype;

typedef struct QueueNode {
    struct QueueNodef* next;
    QDatatype data;
}QNode;

typedef struct Quenue {
    QNode* head;
    QNode* tail;
    int size;
}Queue;

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

MyStack* myStackCreate();//栈的创建
void myStackPush(MyStack* obj, int x);//将元素X压入栈顶
int myStackPop(MyStack* obj);//移除并返回栈顶元素
int myStackTop(MyStack* obj);//返回栈顶元素
bool myStackEmpty(MyStack* obj);//判断栈是否为空，空返回true
void myStackFree(MyStack* obj);//释放栈
  1. Queue.h
#include<stdio.h>
#include<assert.h>
#include"myStack.h"

void QueueInit(Queue* pq);//队列的初始化
bool QueueEmpty(Queue* pq);//判断队列是否为空
void QueuePush(Queue* pq, QDatatype x);//进入队列
void QueuePop(Queue* pq);//删除
QDatatype QueueFront(Queue* pq);//先入元素出队列（仅复制）（队列头先出）
QDatatype QueueBack(Queue* pq);//后入元素出队列
void QueueDestroy(Queue* pq);//销毁队列
  1. Queue.c
nclude "Queue.h"
#include "myStack.h"

void QueueInit(Queue* pq)
{
    assert(pq);

    pq->head = pq->tail = NULL;
    pq->size = 0;
}

bool QueueEmpty(Queue* pq)
{
    assert(pq);

    return pq->size == 0;
}

void QueuePush(Queue* pq, QDatatype x)
{
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        return;
    }
    newnode->data = x;
    newnode->next = NULL;

    if (pq->head == NULL)
    {
        assert(pq->tail == NULL);

        pq->head = pq->tail = newnode;
    }
    else
    {
        pq->tail->next = newnode;
        pq->tail = newnode;
    }

    pq->size++;
}

void QueuePop(Queue* pq)
{
    assert(pq);
    assert(pq->head != NULL);

    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* next = pq->head->next;
        free(pq->head);
        pq->head = next;
    }

    pq->size--;
}

QDatatype QueueFront(Queue* pq)
{
    assert(pq);
    assert(pq->head != NULL);

    return pq->head->data;
}

QDatatype QueueBack(Queue* pq)
{
    assert(pq);
    assert(pq->tail != NULL);

    return pq->tail->data;

}

QDatatype QueueSize(Queue* pq)
{
    assert(pq);

    return pq->size;
}

void QueueDestroy(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }

    pq->head = pq->tail = NULL;
    pq->size = 0;
}
  1. myStack.c
#include"myStack.h"
#include"Queue.h"

MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    if (pst == NULL)
    {
        perror("malloc fail");
        return NULL;
    }

    QueueInit(&pst->q1);
    QueueInit(&pst->q2);

    return pst;
}

void myStackPush(MyStack* obj, int x) {
    if (!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* emptyQ = &obj->q1;
    Queue* nonemptyQ = &obj->q2;
    if (!QueueEmpty(&obj->q1))
    {
        emptyQ = &obj->q2;
        nonemptyQ = &obj->q1;
    }

    while (QueueSize(nonemptyQ) > 1)
    {
        QueuePush(emptyQ, QueueFront(nonemptyQ));//非空队列前（n-1）元素先入先出进入空队列。相当于拷贝，实际元素没出队列
        QueuePop(nonemptyQ);
    }

    int top = QueueFront(nonemptyQ);
    QueuePop(nonemptyQ);

    return top;
}

int myStackTop(MyStack* obj) {
    if (!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}
效果演示：

小结：

本篇博客介绍了如何用栈实现队列以及用队列实现栈。首先，我们简单介绍了栈和队列的概念，特点和如何实现他们。然后，我们阐述了两种数据结构之间的转换方法。

在用栈实现队列的部分，我们通过两个栈的互相倒腾来实现队列的“先进先出”特点。在队列中，元素总是从队列的前端出队，而在栈中，元素总是从栈顶出栈。因此，我们可以用一个栈来作为入队列的栈，用另一个栈作为出队列的栈，通过将入队列的元素逐个压入入队列的栈中，然后再将入队列的栈中的所有元素逐个弹出并压入出队列的栈中，最后再从出队列的栈中弹出元素实现队列的“先进先出”。

在用队列实现栈的部分，我们使用两个队列的互相倒腾来实现栈的“后进先出”特点。在栈中，最后压入栈的元素最先出栈，而在队列中，最先进入队列的元素最先出队列。因此，我们可以用一个空队列来作为先入元素的中转站，通过移出原队列先入的元素，即可实现栈顶元素先出栈，然后原队列又变为了空队列，支持我们重复操作，实现了栈的”后入先出“。

总的来说，这两种数据结构的相互转换离不开对原结构的理解。通过对两种结构的相互转换，我们不仅可以更深入地理解栈和队列的概念，而且也可以更加灵活地运用它们来解决实际问题。

鱼籽油
关注
  • 30
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
【Python数据结构系列】❤️《栈（顺序栈与链栈）》——❤️知识点讲解+代码实现
码农-Vax天道的时间宝藏
08-06 3939
灵魂拷问：为什么要学数据结构？ 数据结构，直白地理解，就是研究数据的存储方式。数据存储只有一个目的，即为了方便后期对数据的再利用。因此，数据在计算机存储空间的存放，决不是胡乱的，这就要求我们选择一种好的方式来存储数据，而这也是数据结构的核心内容。 可以说，数据结构是一切编程的基本。学习数据结构是学习一种思想：如何把现实问题转化为计算机语言的表示。 对于学计算机的朋友来说，学习数据结构是基本功。而对于非计算机专业，但是未来想往数据分析、大数据方向发展、或者在Python的使用上能有一个大的跨越的朋友来说，学.
用栈来是实现队列
m0_66944273的博客
05-13 302
要用栈模拟队列，首先要清楚栈和队列有什么不同的特点 相同点:栈和队列都是保存一组元素的容器 队列(Queue)：线性表结构,遵循先进先出,后进出的（FIFO:First in last out）的基本原则;它只允许在队首进行出队(删除)的操作,在队尾进行入队(插入)的操作; 栈(Stack): 栈采用的是后进先出(LIFO:Last in fist out)的基本原则，与队列的操作相反，栈只允许在栈顶进行插入和删出操作； 对栈和队列之间的特点有了大概了解，就能开始我们的的正式实现了首先.
栈和队列(Stack & Queue)
最新发布
qq_57146327的博客
07-13 791
T data;
栈与队列（详解）
c_study__c的博客
09-28 2017
栈与队列（详解）
栈(stack)和队列（queue）
weixin_45608986的博客
04-09 424
一、栈 1.概念 栈（Stack）是存放数据对象的一种特殊容器，是一种程线性排列的数据结构，在这种结构中我们只能访问最新添加的数据。栈就像一个又细又长的圆筒，圆筒一端封闭，一端开口，往圆筒里放入圆球，先放入的在圆筒底部，后放入的靠近圆筒出口。 ...
栈与队列（超详细）
qq_45792749的博客
03-29 1万+
目录一、栈（Stack）什么是栈？栈的常见方法一级目录一级目录 一、栈（Stack） 什么是栈？ 栈其实就是一种数据结构 - 先进后出（先入栈的数据后出来，最先入栈的数据会被压入栈底） 什么是java虚拟机栈？ java虚拟机栈只是JVM当中的一块内存，该内存一般用来存放 例如：局部变量 当调用函数时，我们会为函数开辟一块内存，叫做 栈帧，在 java虚拟机栈中开辟，具体如下。 常见考点：不可能的出栈顺序 这道题该怎么分析呢？ 首先我们知道，出栈时拿到的第一个元素为4，那么4必须入栈，因为入栈的顺序是
栈和队列从小白到入门的学习路径
04-03
栈和队列是计算机科学中最基础的数据结构，它们在编程中有着广泛的应用。本文将带你从零开始，逐步深入理解栈和队列的概念、性质及其在实际问题中的应用，帮助你构建扎实的理论基础和实践能力。 **1. 数据结构的...
02-栈和队列.zip
01-31
栈和队列是数据结构中的基础概念，它们在计算机科学和编程中扮演着重要的角色。在深入探讨这两个概念之前，让我们先理解它们的基本定义。 栈（Stack）是一种后进先出（Last In First Out，简称LIFO）的数据结构。这...
zhanheduilie.rar_栈和队列
09-24
栈和队列是计算机科学中基础且重要的数据结构，它们在程序设计中有着广泛的应用。在本资料"zhanheduilie.ppt"中，详细讲述了这两种数据结构的原理、特性以及实际应用。 栈（Stack）是一种后进先出（LIFO, Last In ...
栈与队列的相互转化.rar
08-12
队列是先进先出，有队头和队尾，因此用第一个栈的栈顶表示队头，第二个表示队尾。 2. 队列插入的时候是从尾巴插入，因此代表尾部的栈可以定义成一个插入栈也是队尾栈。 3. 队列输出遵守先进先出原则，输出的元素是队...
【数据结构】栈和队列详细分析（全）
码农研究僧的博客
05-05 1万+
前言 栈和队列是两种重要的线性结构。从数据结构角度看，栈和队列也是线性表， 其特殊性在于栈和队列的基本操作是线性表操作的子集，它们是操作受限的线性表，因此，可称为限定性的数据结构。 栈的定义与特点 栈是限定仅在表尾进行插入或删除操作的线性表。 表尾称为栈顶,表头端称为栈底 。不含元素的空表称为空栈。栈的修改是按后进先出的原则进行的。 栈的操作 队列的定义与特点 和栈相反，队列是一种先进先出的线性表。它只允许在表的一端进行插入，而在另一端删除元素，允许插入的一端称为队尾，允许删除的一端则称为队头。 ...
面试高频算法详解 | 栈与队列篇
业余码农Amazing10的博客
02-26 460
面试高频算法详解 | 栈与队列篇 在互联网招聘的面试环节中，手撕算法环节往往会与数据结构的考察相结合。各种经典的算法都离不开常用数据结构的支持。在之前的分享中，我们对链表结构进行了分析，由浅入深的掌握了链表的基本操作和变形算法。 今天，我们同样将从最基础的数据结构栈与队列出发，挖掘常见线性结构的处理思想。 1 结构定义 栈 栈也叫堆栈，是一种在操作系统以及CPU指令设计中经常使用的数据结构。由于栈...
数据结构——栈和队列详细解释
m0_61886762的博客
09-24 2482
你们在使用电脑中也会经历过机器有时会处于疑似死机的状态，鼠标点什么地方都没有任何反应，双击任何快捷键都不动弹。就当你失去内心时，机器突然对你刚的所有操作都执行了一遍。这是因为操作系统在当时可能CPU没有忙过来。操作系统中应用了一种数据结构来实现上述所说的问题也就是先进先出的功能，这就是队列。队列是一种先进先出的线性表简称FIFO。允许插入的操作为队尾，允许删除的操作为队头。就类似于最近几年的做核酸排队的操作，你在入队时是从队尾排队做核酸，做完之后是从队伍的头部做完后退出队伍。
栈和队列 的差别、转化与本质
2302_77114273的博客
05-20 147
本文将回答：栈和队列是什么，有什么联系和差别，能否相互转化，底层本质是否统一
数据结构——栈与队列
m0_57484470的博客
10-17 6400
数据结构栈与队列相关基础知识详解！！！
栈和队列的详解
gongjunbox的博客
12-31 3872
栈和队列在数据结构中，运用极其广泛，可以解决很多复杂的问题，无论是先进先出，还是先进后出，都是在生活中容易碰到的情况，所以这些特性可以解决生活中很多常见的事情
栈和队列（详细版，一看就懂。包含栈和队列的定义、意义、区别，实现）
热门推荐
weixin_47252176的博客
03-10 2万+
栈和队列 一、栈和队列的定义、区别，存在的意义 1.栈的定义 （1）栈：栈实际上是一种线性表，它只允许在固定的一段进行插入或者删除元素，在进行数据插入或者删除的一段称之为栈顶，剩下的一端称之为栈顶。其遵循的原则是后进先出。 （2）栈的核心操作：三大核心操作，入栈，出栈，取栈顶元素 （3）对于栈的形象理解：子弹的弹夹我们一定见过，子弹在被压入的时候就相当于是一个个元素，而弹夹就相当于是栈。先被压入的子弹是最后被打出的，先压入的元素是最后出来的，也就是后进先出。 2.队列的定义 （1）队列：首先队列也是一种特殊
栈和队列详解
qq_68006585的博客
11-06 752
栈和队列详解
栈和队列的数据结构实现
"这篇资源主要介绍了数据库中的栈和队列操作实现示例，以及相关数据结构的概念和基本操作。" 栈和队列是计算机科学中基础且重要的数据结构，它们都属于线性表的范畴，但操作规则有所不同。 1. **栈**： - **栈的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值