数据结构中的栈和队列（附实际案例代码）

已于 2024-04-23 12:32:33 修改
阅读量874 收藏 23
点赞数 13
文章标签： 数据结构 算法 c#
于 2024-04-23 12:30:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JAZJD/article/details/138119928
版权

1.栈和队列的定义和特点

        栈（Stack）和队列（Queue）是两种基本的数据结构，它们都属于线性表，即数据元素的存储和访问都是线性的。但它们之间也存在着一些区别。

1.1栈的特点

  • 栈是一种后进先出（LIFO）的数据结构，即最后压入栈的元素将首先被弹出。
  • 栈的操作只能在一端进行，这一端被称为栈顶，而另一端被称为栈底。
  • 栈的基本操作包括入栈（Push）和出栈（Pop），入栈操作将元素放入栈顶，出栈操作将栈顶元素移出。
  • 栈常用于实现函数调用的执行过程、表达式求值、括号匹配等场景。

1.2队列的特点

  • 队列是一种先进先出（FIFO）的数据结构，即最先进入队列的元素将首先被取出。
  • 队列的操作分别在两端进行，队列的一端称为队头，另一端称为队尾。
  • 队列的基本操作包括入队（enqueue）和出队（dequeue），入队操作在队尾添加元素，出队操作从队头移除元素。
  • 队列常用于模拟排队、任务调度、缓冲区管理等场景。

2.实际案例引入

        想象一下，你正在开发一个文本编辑器。用户可以在文本编辑器中输入、删除文本，并进行各种编辑操作。为了增强用户体验，你决定实现撤销（Undo）和重做（Redo）功能，以便用户可以回溯到之前的编辑状态或者重新执行已撤销的操作。

        在这种情况下，你需要管理文本的修改历史，以确保撤销和重做操作的正确性。这时候，栈（Stack）和队列（Queue）就可以派上用场了。

撤销功能的实现

        当用户进行编辑操作时，比如输入文本、删除字符等，你需要将当前的编辑状态保存起来。每当用户执行一个编辑操作时，将该操作对应的编辑状态（比如文本内容、光标位置等）压入栈中。这样，栈顶就是最新的编辑状态，而栈底则是最早的编辑状态。

        当用户点击撤销按钮时，从栈顶弹出最新的编辑状态，并将编辑器恢复到该状态。这样用户就可以一步步地回退到之前的编辑状态，实现了撤销功能。

重做功能的实现

        当用户执行撤销操作后，有时候会改变主意，希望重新执行之前的操作。这时候就需要实现重做功能。你可以使用另一个栈来存储被撤销的操作，当用户点击重做按钮时，从重做栈中弹出操作，并将其应用到编辑器中，实现重做功能。

以下是c语言的代码实现：

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

#define MAX_LENGTH 100

// 编辑历史结构体
typedef struct {
    char text[MAX_LENGTH];
    int cursorPosition;
} EditHistory;

// 栈结构定义
typedef struct {
    EditHistory history[MAX_LENGTH];
    int top;
} UndoStack;

// 初始化栈
void initStack(UndoStack *stack) {
    stack->top = -1;
}

// 判断栈是否为空
int isEmpty(UndoStack *stack) {
    return stack->top == -1;
}

// 判断栈是否已满
int isFull(UndoStack *stack) {
    return stack->top == MAX_LENGTH - 1;
}

// 入栈操作
void push(UndoStack *stack, EditHistory item) {
    if (isFull(stack)) {
        printf("Stack overflow\n");
        return;
    }
    stack->history[++stack->top] = item;
}

// 出栈操作
EditHistory pop(UndoStack *stack) {
    if (isEmpty(stack)) {
        printf("Stack underflow\n");
        exit(1);
    }
    return stack->history[stack->top--];
}

// 模拟用户编辑操作，修改文本内容和光标位置
void editContent(char *text, int *cursorPosition) {
    printf("Enter new text: ");
    scanf("%s", text);
    printf("Enter cursor position: ");
    scanf("%d", cursorPosition);
}

// 撤销操作
void undo(UndoStack *undoStack, char *text, int *cursorPosition) {
    if (isEmpty(undoStack)) {
        printf("No more undo steps\n");
        return;
    }
    EditHistory history = pop(undoStack);
    strcpy(text, history.text);
    *cursorPosition = history.cursorPosition;
}

// 重做操作
void redo(UndoStack *redoStack, char *text, int *cursorPosition) {
    // 在实际情况下，redoStack 应该存储被撤销的操作历史
    // 这里只是简单演示，直接重新执行了撤销操作的逆向操作
    EditHistory history;
    strcpy(history.text, text);
    history.cursorPosition = *cursorPosition;
    push(redoStack, history);
}

int main() {
    char text[MAX_LENGTH];
    int cursorPosition;
    UndoStack undoStack, redoStack;
    EditHistory history;

    // 初始化栈
    initStack(&undoStack);
    initStack(&redoStack);

    // 模拟用户编辑操作
    editContent(text, &cursorPosition);

    // 将当前编辑状态压入栈中
    strcpy(history.text, text);
    history.cursorPosition = cursorPosition;
    push(&undoStack, history);

    // 用户执行撤销操作
    undo(&undoStack, text, &cursorPosition);

    // 用户执行重做操作
    redo(&redoStack, text, &cursorPosition);

    return 0;
}

3. 栈的表示和操作的实现

        栈是一种常见的数据结构，具有后进先出（LIFO）的特性，它的操作包括入栈（Push）和出栈（Pop）。栈可以通过顺序存储和链式存储两种方式来实现。

3.1栈的类型定义

        首先，我们定义栈的基本结构，包括栈的元素类型和栈的大小（对于顺序栈而言）

以下是c语言的代码实现：

#define MAX_SIZE 100

// 栈的元素类型
typedef int ElementType;

// 栈结构定义
typedef struct {
    ElementType data[MAX_SIZE];
    int top; // 栈顶指针
} SeqStack;
对于链栈，我们需要定义栈节点 的结构
// 链栈节点结构
typedef struct StackNode {
    ElementType data; // 数据域
    struct StackNode *next; // 指针域
} StackNode;

// 链栈结构定义
typedef struct {
    StackNode *top; // 栈顶指针
} LinkStack;

3.2顺序栈的表示和实现

        顺序栈使用数组来存储栈元素，同时维护一个栈顶指针指向栈顶元素。下面是顺序栈的入栈和出栈操作的实现。

以下是c语言的代码实现：

// 初始化栈
void initSeqStack(SeqStack *stack) {
    stack->top = -1; // 空栈时栈顶指针为-1
}

// 判断栈是否为空
int isEmptySeqStack(SeqStack *stack) {
    return stack->top == -1;
}

// 判断栈是否已满
int isFullSeqStack(SeqStack *stack) {
    return stack->top == MAX_SIZE - 1;
}

// 入栈操作
void pushSeqStack(SeqStack *stack, ElementType value) {
    if (isFullSeqStack(stack)) {
        printf("Stack overflow\n");
        return;
    }
    stack->data[++stack->top] = value;
}

// 出栈操作
ElementType popSeqStack(SeqStack *stack) {
    if (isEmptySeqStack(stack)) {
        printf("Stack underflow\n");
        exit(1);
    }
    return stack->data[stack->top--];
}

3.3链栈的表示和实现

        链栈使用链表来存储栈元素，每个节点包含数据域和指针域，指向下一个节点。下面是链栈的入栈和出栈操作的实现。

以下是c语言的代码实现：

// 初始化链栈
void initLinkStack(LinkStack *stack) {
    stack->top = NULL; // 空栈时栈顶指针为NULL
}

// 判断链栈是否为空
int isEmptyLinkStack(LinkStack *stack) {
    return stack->top == NULL;
}

// 入栈操作
void pushLinkStack(LinkStack *stack, ElementType value) {
    StackNode *newNode = (StackNode *)malloc(sizeof(StackNode));
    if (newNode == NULL) {
        printf("Memory allocation failed\n");
        exit(1);
    }
    newNode->data = value;
    newNode->next = stack->top;
    stack->top = newNode;
}

// 出栈操作
ElementType popLinkStack(LinkStack *stack) {
    if (isEmptyLinkStack(stack)) {
        printf("Stack underflow\n");
        exit(1);
    }
    StackNode *temp = stack->top;
    ElementType value = temp->data;
    stack->top = stack->top->next;
    free(temp);
    return value;
}

4 栈与递归

        栈在计算机科学中具有重要的应用，尤其是在函数调用和递归方面。在程序执行过程中，每次函数调用都会创建一个栈帧（Stack Frame）来存储函数的局部变量、参数以及返回地址等信息，这些栈帧按照后进先出的顺序存放在栈中，因此栈的特性与函数调用和递归密切相关。

4.1函数调用

        当一个函数被调用时，系统需要保存函数的调用信息，以便在函数执行完毕后能够正确返回到调用处继续执行。这些调用信息包括函数的参数、返回地址等，它们会被压入一个称为“调用栈”的栈中。当函数执行完毕后，这些信息会被从调用栈中弹出，从而返回到正确的位置继续执行。

例如，考虑以下递归函数计算阶乘的例子：

int factorial(int n) {
    if (n == 0 || n == 1)
        return 1;
    else
        return n * factorial(n - 1);
}

4.2递归

        递归也是基于栈的思想实现的。当一个函数调用自身时，它会将当前函数的状态（包括参数、返回地址等）压入栈中，然后开始执行。当递归调用结束时，函数的状态会被弹出栈，并返回到上一个调用处继续执行。例如，计算阶乘的递归函数：

int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

        在函数 factorial 被调用时，n 的值和返回地址会被压入栈中。当函数递归调用自身时，新的 n 值和返回地址也会被压入栈中。当递归结束时，函数的状态会被依次弹出栈，直到返回到初始的调用处。

5队列的表示和操作的实现

        队列是一种常见的数据结构，具有先进先出（FIFO）的特性，通常使用数组或链表来实现。下面我们将分别介绍数组队列和链表队列的表示和操作实现。

5.1数组队列的表现和实现

        使用数组实现队列时，需要记录队头（front）和队尾（rear）的位置。初始时，front 和 rear 都指向数组的首元素。当一个元素被入队时，rear 向前移动一位；当一个元素被出队时，front 向前移动一位。当 rear 等于数组大小时，队列满；当 front 等于 rear 时，队列为空。

#define MAX_SIZE 100

// 队列元素类型
typedef int ElementType;

// 队列结构定义
typedef struct {
    ElementType data[MAX_SIZE];
    int front; // 队头指针
    int rear; // 队尾指针
} ArrayQueue;

接下来是数组队列的入队和出队操作的实现。

// 初始化队列
void initArrayQueue(ArrayQueue *queue) {
    queue->front = queue->rear = -1; // 空队列时队头和队尾指针都为-1
}

// 判断队列是否为空
int isEmptyArrayQueue(ArrayQueue *queue) {
    return queue->front == -1;
}

// 判断队列是否已满
int isFullArrayQueue(ArrayQueue *queue) {
    return (queue->rear + 1) % MAX_SIZE == queue->front;
}

// 入队操作
void enqueueArrayQueue(ArrayQueue *queue, ElementType value) {
    if (isFullArrayQueue(queue)) {
        printf("Queue overflow\n");
        return;
    }
    if (isEmptyArrayQueue(queue))
        queue->front = queue->rear = 0;
    else
        queue->rear = (queue->rear + 1) % MAX_SIZE;
    queue->data[queue->rear] = value;
}

// 出队操作
ElementType dequeueArrayQueue(ArrayQueue *queue) {
    if (isEmptyArrayQueue(queue)) {
        printf("Queue underflow\n");
        exit(1);
    }
    ElementType value = queue->data[queue->front];
    if (queue->front == queue->rear)
        queue->front = queue->rear = -1;
    else
        queue->front = (queue->front + 1) % MAX_SIZE;
    return value;
}

5.2链表队列的表现和实现

        链表队列使用链表来存储队列元素，每个节点包含数据域和指针域，指向下一个节点。

// 队列节点结构
typedef struct QueueNode {
    ElementType data; // 数据域
    struct QueueNode *next; // 指针域
} QueueNode;

// 队列结构定义
typedef struct {
    QueueNode *front; // 队头指针
    QueueNode *rear; // 队尾指针
} LinkedQueue;

接下来是链表队列的入队和出队操作的实现。

// 初始化链表队列
void initLinkedQueue(LinkedQueue *queue) {
    queue->front = queue->rear = NULL; // 空队列时队头和队尾指针都为NULL
}

// 判断链表队列是否为空
int isEmptyLinkedQueue(LinkedQueue *queue) {
    return queue->front == NULL;
}

// 入队操作
void enqueueLinkedQueue(LinkedQueue *queue, ElementType value) {
    QueueNode *newNode = (QueueNode *)malloc(sizeof(QueueNode));
    if (newNode == NULL) {
        printf("Memory allocation failed\n");
        exit(1);
    }
    newNode->data = value;
    newNode->next = NULL;
    if (isEmptyLinkedQueue(queue))
        queue->front = queue->rear = newNode;
    else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
}

// 出队操作
ElementType dequeueLinkedQueue(LinkedQueue *queue) {
    if (isEmptyLinkedQueue(queue)) {
        printf("Queue underflow\n");
        exit(1);
    }
    QueueNode *temp = queue->front;
    ElementType value = temp->data;
    queue->front = queue->front->next;
    free(temp);
    if (queue->front == NULL) // 出队后队列为空，重置队尾指针
        queue->rear = NULL;
    return value;
}

6 综合案例

案例一：浏览器历史记录

        浏览器通常使用栈来管理历史记录。当你访问一个网页时，该网页会被压入历史记录栈中。当你点击后退按钮时，浏览器会从历史记录栈中弹出当前网页，并将上一个网页展示出来。    

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

typedef struct Stack {
    int size;
    int top;
    char **history;
} Stack;

void initStack(Stack *stack, int size) {
    stack->size = size;
    stack->top = -1;
    stack->history = malloc(sizeof(char*) * size);
    if (stack->history == NULL) {
        printf("内存分配失败。\n");
        exit(1);
    }
}

int isEmpty(Stack *stack) {
    return stack->top == -1;
}

int isFull(Stack *stack) {
    return stack->top == stack->size - 1;
}

void push(Stack *stack, char *url) {
    if (isFull(stack)) {
        printf("栈已满，无法压入新元素。\n");
        return;
    }
    stack->top++;
    stack->history[stack->top] = strdup(url);
}

char *pop(Stack *stack) {
    if (isEmpty(stack)) {
        printf("栈为空，无法弹出元素。\n");
        return NULL;
    }
    char *url = stack->history[stack->top];
    stack->top--;
    return url;
}

int main() {
    Stack historyStack;
    initStack(&historyStack, 5);

    push(&historyStack, "www.example.com");
    push(&historyStack, "www.example1.com");
    push(&historyStack, "www.example2.com");

    char *prevUrl = pop(&historyStack);
    printf("后退到上一页：%s\n", prevUrl);

    return 0;
}

    案例二：打印任务队列

        打印任务队列也是队列的一个实际应用。当你向打印机发送多个打印任务时，它们会被添加到打印任务队列中。打印机会从队列中取出任务进行打印，遵循先进先出的原则。

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

typedef struct Node {
    char *filename;
    struct Node *next;
} Node;

typedef struct {
    Node *head;
    Node *tail;
} Queue;

void initQueue(Queue *queue) {
    queue->head = NULL;
    queue->tail = NULL;
}

void enqueue(Queue *queue, char *filename) {
    Node *newNode = malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("内存分配失败。\n");
        return;
    }
    newNode->filename = strdup(filename);
    newNode->next = NULL;

    if (queue->tail == NULL) {
        queue->head = newNode;
        queue->tail = newNode;
    } else {
        queue->tail->next = newNode;
        queue->tail = newNode;
    }
}

char *dequeue(Queue *queue) {
    if (queue->head == NULL) {
        printf("队列为空，无法出队。\n");
        return NULL;
    }
    Node *temp = queue->head;
    char *filename = temp->filename;
    queue->head = temp->next;
    if (queue->head == NULL) {
        queue->tail = NULL;
    }
    free(temp);
    return filename;
}

int main() {
    Queue printQueue;
    initQueue(&printQueue);

    enqueue(&printQueue, "document1.pdf");
    enqueue(&printQueue, "document2.pdf");
    enqueue(&printQueue, "document3.pdf");

    char *filename = dequeue(&printQueue);
    printf("正在打印：%s\n", filename);

    return 0;
}

7 小结

        栈和队列是两种基本的数据结构，在计算机科学中有着广泛的应用。它们都属于线性表，但具有不同的特性。栈遵循后进先出的原则，在函数调用和递归中扮演着重要角色。队列遵循先进先出的原则，在任务管理和数据处理中十分有用。通过理解和掌握栈和队列，我们可以更好地解决各种实际问题，提高程序的效率和性能。

JAZJD
关注
数据结构——栈和队列
奇蠢无比の二琦的博客
11-13 260
一、特殊线性表——栈 1.栈的逻辑结构 ①栈：限定仅在表尾进行插入和删除操作的线性表。 允许插入和删除的一端称为栈顶，另一端称为栈底。 栈的特殊操作：后进先出。 ②栈只是对表插入和删除操作的位置进行了限制，并没有限定插入和删除操作进行的时间。 ③栈的抽象数据类型定义 ADT Stack Data 栈中元素具有相同类型及后进先出特性， 相邻元素具有前驱和后继关系 Operation InitStac...
数据结构 队列和栈实例程序
12-08
数据结构中常用数据结构栈和队列的综合应用。十分经典
栈和队列的典型案例
weixin_52634719的博客
09-22 1304
1.进制转换：N/d得到的余数倒着写 2.括号匹配检验：不能交叉，只能嵌套，在里面的就必须先匹配上，在外面的必须后匹配上 左括号是入栈，右括号就是跟栈顶的进行匹配， 利用栈的性质，先入栈的后匹配，后入栈的括号要先匹配。 3.表达式求值： 运算符和界限符都称作算符。 要用两个栈 4.舞伴问题（先进先出：队列） ...
栈和队列以及其相关的案例
weixin_72728720的博客
01-15 335
栈和队列的定义栈和队列是两种常用的、重要的数据结构；栈和队列是限定插入和删除只能在表的“端点”进行的线性表。线性表 栈1
【数据结构（12）】3.2 栈和队列的案例引入
shangguanxiu的博客
12-30 439
严蔚敏版【数据结构】一、栈的案例 1. 进制转换 2. 括号匹配的检验 3. 表达式求值 二、队列案例 1. 舞伴问题
栈和队列（二）：栈的应用举例
chen825919148的专栏
06-20 1796
一、数制转换 　　十进制数N和其它d进制数的转换是计算机实现计算的基本问题，其解决方法很多，其中一个简单的算法是基于下列原理： 　　　　　　N = (N div d) * d + N mod d。其中：div为整除运算，mod为求余运算。 　　　　例：(1348)10 = (2504)8，其运算过程如下： 　　　　　　    N　　　　N div 8　　　　N mod 8 　　　　　　1
JiSuanQi.rar_jisuanqi_栈和队列_计算器 数据结构
09-20
总的来说，这个项目提供了对数据结构栈和队列的实际应用案例，是学习和理解这些基础数据结构的好教材。通过阅读和分析源代码，可以深入了解如何在实际问题中运用这些抽象数据类型，并提高编程技能。同时，Visual C++...
Java模拟栈和队列数据结构的基本示例讲解共4页.pdf
10-30
本篇文档《Java模拟栈和队列数据结构的基本示例讲解共4页.pdf》将深入浅出地介绍如何在Java中实现栈和队列，以帮助开发者更好地理解和应用这些概念。 首先，让我们来了解栈和队列的基本特性： 1. **栈（Stack）**...
数据结构C++ 顺序栈、链栈、循环队列、链队列的主要操作（Word文档含代码和注释）
11-04
本文档提供了使用C++编程语言实现的数据结构中的栈与队列的操作详解，具体包括顺序栈、链栈、循环队列、链队列四种结构的基本操作，并通过实际案例展示了这些数据结构的应用，例如利用栈进行进制转换，利用队列打印...
栈和队列的基本知识以及使用例子
01-04
该文档介绍了栈和队列的基本知识以及使用例子。跟数据结构基本配套。栈和队列是操作受限制的线性表。它们具有相同的逻辑结构， 即线性结构；操作只能在表的两头进行：栈的插入和删除操作只能在一端进行； 队列的插入和删除操作分别在两端进行。
【数据结构】实验一：栈和队列（Python版）| 数制转换问题 + 求后缀表达式 + 舞会 + 连通块
04-06
4. **灵活运用栈和队列解决综合应用问题**：通过具体案例分析，理解栈和队列各自的特性及应用场景，学会根据实际情况选择合适的数据结构。 #### 三、实验题目详解 ##### 1. 数制转换问题 - **题目描述**：给定一个...
CJ2-05-数据结构-单调栈和单调队列.pdf
02-17
### 数据结构：单调栈与单调队列 ...**总结**：单调栈和单调队列是两种重要的数据结构，能够高效地解决特定类型的问题。通过掌握它们的基本原理和实现细节，可以更灵活地应对编程竞赛和实际工程中的问题。
3、栈和队列、应用举例
谁为拨动染血的时空苍穹
07-31 1776
栈和队列是非常重要的两种数据结构，在软件设计中应用很多。栈和队列也是线性结构，线性表、栈和队列这三种数据结构的数据元素以及数据元素间的逻辑关系完全相同，差别是线性表的操作不受限制，而栈和队列的操作受到限制。栈的操作只能在表的一端进行，队列的插入操作在表的一端进行而其它操作在表的另一端进行，所以，把栈和队列称为操作受限的线性表。 栈(Stack)是操作限定在表的尾端进行的线性表。表尾由于要进行插入、...
数据结构-栈（Stack）和队列（Queue）的实现以及应用（深入浅出）
qq_39225639的博客
08-30 818
数据结构-栈结构和队列结构栈（Stack）栈的特性相关名词栈的实现生活中的栈队列（Queue）队列的特性生活中的队列 栈结构和队列是比较常见的受限的线性结构 栈（Stack） 栈的特性 限定仅仅在表尾进行插入和删除的操作的线性表，这一端称为栈顶。相对的另一端称之为栈底。 原则：后进先出原则 相关名词 进栈(push)：压入 出栈(pop):弹出 栈的实现 栈的常见操作 push 压入元素到栈顶 pop 弹出栈顶元素 peek 返回栈顶的元素 isEmpty 判断栈是否为空 size 返回栈的元
栈和队列的实现（详解+图解！文末附完整代码）
逃离枷锁，冲向天空！
11-25 604
当capacity和top相等时其实是有两种情况的，一种时为空，另一种是栈满，，我们在这里就用一个三目操作符，如果为0，就将capacity初始化为4，否则将capacity的原来的值乘2，然后动态开辟realloc一块新的空间，大小就是newcapacity，这样我们就完成了扩容。在后面的增删查改等操作我们需要断言，为了增加代码的可读性，我们直接写一个函数 ，更加容易理解，如果栈顶元素下标为0，那么这个栈就为空 ，所以直接return top等于 0这个表达式的值，为空则返回 1，不为空则返回0。
数据结构---栈和队列
zzqingyun的博客
02-04 1200
????欢迎来到数据结构的世界 ????博客主页：卿云阁 ????欢迎关注????点赞????收藏⭐️留言???? ????本文由卿云阁原创！ ????本阶段属于锻体阶段，希望各位仙友顺利完成突破 ????首发时间：????2021年1月27日???? ✉️希望可以和大家一起完成进阶之路！ ????作者水平很有限，如果发现错误，请留言轰炸哦！万分感谢！ 目录 0️⃣栈的定义 1️⃣栈的顺序存储结构 2️⃣栈的链式存储结构 3️⃣栈的应用举例 ????数制转换问题 ????括号匹
数据结构-栈和队列(附代码)
Algo_x的博客
06-06 1332
栈和队列 从先在开始计算机的学习要做到“耕战并重”，“耕”就是阅读教科书，“战”就是LC上，王道单科书上刷题。 此外单单就编程来说，其实就是逻辑的代码体现，关键是要现有严密的逻辑，并且知道程序的语言是什么，如此方能编写出合格的算法。之后的知识总结会包括：基本定义+基本语句+算法逻辑。 栈与队列的定义和特点 栈、队列是一种特殊（操作受限）的线性表 区别：仅在于运算规则不同 栈 定义：只能在表的一端（栈顶）进行插入和删除运算的线性表 逻辑结构：与线性表相同，仍为一对一关系 存储结构：用顺序栈或链栈存储均可，但
21_动态规划与数据结构结合
最新发布
刘炫320的博客
09-11 467
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
"栈和队列：数据结构应用案例分析
栈和队列是在计算机科学中常见的数据结构，用于存储和访问数据。栈是一种先进后出（FILO）的数据结构，而队列则是一种先进先出（FIFO）的数据结构。在实际的编程应用中，栈和队列有着广泛的应用，例如实现递归算法。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值