数据结构——栈（详细分析）

已于 2024-06-05 11:39:30 修改
阅读量1.2k 收藏 14
点赞数 28
分类专栏： 算法与数据结构 文章标签： 数据结构 栈 c# 考研
于 2024-05-21 23:18:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76516899/article/details/139103808
版权

目录

 

🍉引言

🍉栈的本质和特点

🍈栈的基本操作

🍈栈的特点

🍍后进先出

🍍操作受限

🍍动态调整

🍈栈的优缺点

🍍优点

🍍缺点

🍉栈的应用

栈的代码实现

代码说明

图解栈的出入过程

压栈过程

出栈过程

栈的实际应用实例

括号匹配

浏览器前进后退功能

代码说明

🍉栈的实现细节和优化

🍈数组实现栈的优化

 

3a51751fe24944eaaad2285a23a7f6b6.gif

🍉引言

栈（Stack）是一种常见的数据结构，在计算机科学中具有重要的应用价值。栈的操作受限于后进先出（LIFO, Last In First Out）的原则，这种特点使得栈在处理特定类型的问题时非常高效。本文将详细解析栈的本质和特点，并通过生活中的例子和代码实现来深入理解栈的应用。

🍉栈的本质和特点

  • 栈是一种线性数据结构，只允许在一端进行插入和删除操作，这一端称为栈顶（Top）。与栈顶相对的另一端称为栈底（Bottom），栈底是固定的，不进行操作

🍈栈的基本操作

栈有几种基本操作：

  1. 压栈（Push）：将一个元素添加到栈顶。
  2. 出栈（Pop）：移除并返回栈顶元素。
  3. 取栈顶元素（Peek or Top）：返回栈顶元素但不移除它。
  4. 检查栈是否为空（isEmpty）：返回布尔值，指示栈是否为空。
  5. 检查栈是否已满（isFull）：返回布尔值，指示栈是否已满（主要用于固定大小的栈）。

🍈栈的特点

🍍后进先出

  • 栈的最主要特点是后进先出，即最新加入的元素最先被移除。这种特性使得栈特别适用于某些特定的应用场景。

🍍操作受限

  • 与其他数据结构相比，栈的操作比较受限。只能在栈顶进行压栈和出栈操作，不能直接访问栈中的任意元素。

🍍动态调整

  • 栈可以是固定大小的，也可以是动态调整大小的。动态栈会根据需要自动调整其容量。

🍈栈的优缺点

🍍优点

  1. 简单高效： 栈的操作简单，只需考虑栈顶元素，因此执行速度较快。

  2. 内存管理： 栈内存的分配和释放是自动进行的，不需要手动管理内存，避免了内存泄漏和垃圾回收的问题。

  3. 递归调用： 栈结构天然适合处理递归调用，函数的调用和返回都可以利用栈的特性。

🍍缺点

  1. 大小限制： 栈的大小通常是固定的，当数据量超过栈的容量时会导致栈溢出。

  2. 数据不灵活： 栈是一种后进先出（LIFO）的数据结构，只能在栈顶进行操作，不适合需要随机访问数据的场景。

  3. 局部性： 栈中的数据只能按照特定的顺序访问，缺乏灵活性，不能满足所有的数据操作需求。

🍉栈的应用

栈在现实生活和计算机科学中都有广泛的应用：

  1. 函数调用：计算机系统使用栈来管理函数调用。每次函数调用时，当前函数的状态（如局部变量、返回地址等）会被压入栈中。当函数返回时，状态从栈中弹出并恢复。
  2. 表达式求值和语法解析：栈用于将中缀表达式转换为后缀表达式或前缀表达式，并且在表达式求值过程中，栈也扮演重要角色。
  3. 浏览器的前进后退功能：浏览器使用两个栈来管理用户的浏览历史，一个栈存储前进的页面，另一个栈存储后退的页面。
  4. 撤销操作：许多软件（如文本编辑器、图像编辑器等）使用栈来实现撤销和恢复功能。

栈的代码实现

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

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

// 初始化栈
Stack* createStack(int capacity) {
    Stack *stack = (Stack *)malloc(sizeof(Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->items = (int *)malloc(capacity * sizeof(int));
    return stack;
}

// 检查栈是否为空
bool is_empty(Stack *stack) {
    return stack->top == -1;
}

// 压入元素到栈
void push(Stack *stack, int item) {
    if (stack->top == stack->capacity - 1) {
        printf("栈已满，无法压入元素\n");
        return;
    }
    stack->items[++stack->top] = item;
}

// 弹出栈顶元素
int pop(Stack *stack) {
    if (is_empty(stack)) {
        printf("栈为空，无法弹出元素\n");
        exit(EXIT_FAILURE);
    }
    return stack->items[stack->top--];
}

// 获取栈顶元素
int peek(Stack *stack) {
    if (is_empty(stack)) {
        printf("栈为空，无法获取栈顶元素\n");
        exit(EXIT_FAILURE);
    }
    return stack->items[stack->top];
}

// 获取栈的大小
int size(Stack *stack) {
    return stack->top + 1;
}

int main() {
    Stack *stack = createStack(100); // 创建一个容量为100的栈

    push(stack, 1);
    push(stack, 2);
    push(stack, 3);

    printf("栈顶元素：%d\n", peek(stack));  // 输出 3
    printf("出栈元素：%d\n", pop(stack));   // 输出 3
    printf("栈顶元素：%d\n", peek(stack));  // 输出 2
    printf("栈大小：%d\n", size(stack));    // 输出 2

    // 释放分配的内存
    free(stack->items);
    free(stack);

    return 0;
}

代码说明

  1. Stack 结构体包含一个整数数组 items，一个表示栈顶索引的 top，和一个表示栈容量的 capacity。
  2. createStack 函数用于初始化栈并分配内存。
  3. is_empty 函数用于检查栈是否为空。
  4. push 函数用于将元素压入栈，并在栈满时打印错误信息。
  5. pop 函数用于弹出栈顶元素，并在栈为空时打印错误信息并退出程序。
  6. peek 函数用于获取栈顶元素，并在栈为空时打印错误信息并退出程序。
  7. size 函数用于获取栈的大小（当前存储的元素数量）。
  8. main 函数演示了栈的使用，类似于您提供的 Python 代码示例。

图解栈的出入过程

  • 为了更直观地理解栈的操作过程，我们可以使用图解的方式来展示栈的压栈和出栈操作。

压栈过程

  • 初始状态：栈为空
栈: []
  •  压栈 1：
压栈 1
栈: [1]
  • 压栈 2：
压栈 2
栈: [1, 2]
  • 压栈 3：
压栈 3
栈: [1, 2, 3]

出栈过程

  • 初始状态：栈顶元素为 3
栈: [1, 2, 3]
  • 出栈 3：
出栈 3
栈: [1, 2]
  • 出栈 2：
出栈 2
栈: [1]
  • 出栈 1：
出栈 1
栈: []

栈的实际应用实例

括号匹配

  • 括号匹配问题是栈的经典应用之一，常用于编译器和解释器的语法解析。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 栈结构定义
typedef struct Stack {
    int top;
    unsigned capacity;
    char* array;
} Stack;

// 创建栈
Stack* createStack(unsigned capacity) {
    Stack* stack = (Stack*) malloc(sizeof(Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->array = (char*) malloc(stack->capacity * sizeof(char));
    return stack;
}

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

// 入栈
void push(Stack* stack, char item) {
    stack->array[++stack->top] = item;
}

// 出栈
char pop(Stack* stack) {
    if (isEmpty(stack))
        return '\0';
    return stack->array[stack->top--];
}

// 获取栈顶元素
char peek(Stack* stack) {
    if (isEmpty(stack))
        return '\0';
    return stack->array[stack->top];
}

// 判断括号是否平衡
int isBalanced(const char* expression) {
    Stack* stack = createStack(strlen(expression));
    char pairs[256] = { 0 };
    pairs[')'] = '(';
    pairs[']'] = '[';
    pairs['}'] = '{';

    for (int i = 0; i < strlen(expression); i++) {
        char char = expression[i];
        if (char == '(' || char == '{' || char == '[') {
            push(stack, char);
        } else if (char == ')' || char == '}' || char == ']') {
            if (isEmpty(stack) || pop(stack) != pairs[char]) {
                free(stack->array);
                free(stack);
                return 0; // false
            }
        }
    }

    int balanced = isEmpty(stack);
    free(stack->array);
    free(stack);
    return balanced;
}

// 测试函数
int main() {
    const char* expression1 = "{[()()]}";
    printf("%s\n", isBalanced(expression1) ? "True" : "False");

    const char* expression2 = "{[(])}";
    printf("%s\n", isBalanced(expression2) ? "True" : "False");

    return 0;
}

浏览器前进后退功能

浏览器的前进和后退功能可以通过两个栈来实现，一个栈用于存储前进页面，另一个栈用于存储后退页面：

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

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

typedef struct Stack {
    Node* top;
} Stack;

// 初始化栈
void init_stack(Stack* stack) {
    stack->top = NULL;
}

// 检查栈是否为空
int is_empty(Stack* stack) {
    return stack->top == NULL;
}

// 推入元素到栈
void push(Stack* stack, const char* data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = (char*)malloc(strlen(data) + 1);
    strcpy(new_node->data, data);
    new_node->next = stack->top;
    stack->top = new_node;
}

// 弹出栈顶元素
char* pop(Stack* stack) {
    if (is_empty(stack)) {
        return NULL;
    }
    Node* temp = stack->top;
    char* data = temp->data;
    stack->top = stack->top->next;
    free(temp);
    return data;
}

// 浏览器历史记录结构体
typedef struct BrowserHistory {
    Stack forward_stack;
    Stack backward_stack;
    char* current_page;
} BrowserHistory;

// 初始化浏览器历史记录
void init_browser_history(BrowserHistory* history) {
    init_stack(&history->forward_stack);
    init_stack(&history->backward_stack);
    history->current_page = NULL;
}

// 访问新页面
void visit(BrowserHistory* history, const char* page) {
    if (history->current_page != NULL) {
        push(&history->backward_stack, history->current_page);
    }
    history->current_page = (char*)malloc(strlen(page) + 1);
    strcpy(history->current_page, page);

    // 清空前进栈
    while (!is_empty(&history->forward_stack)) {
        free(pop(&history->forward_stack));
    }
}

// 后退
char* back(BrowserHistory* history) {
    if (!is_empty(&history->backward_stack)) {
        push(&history->forward_stack, history->current_page);
        history->current_page = pop(&history->backward_stack);
        return history->current_page;
    } else {
        return NULL;  // 无法后退
    }
}

// 前进
char* forward(BrowserHistory* history) {
    if (!is_empty(&history->forward_stack)) {
        push(&history->backward_stack, history->current_page);
        history->current_page = pop(&history->forward_stack);
        return history->current_page;
    } else {
        return NULL;  // 无法前进
    }
}

int main() {
    BrowserHistory history;
    init_browser_history(&history);

    visit(&history, "Page1");
    visit(&history, "Page2");
    visit(&history, "Page3");

    printf("%s\n", back(&history));  // 输出 Page2
    printf("%s\n", back(&history));  // 输出 Page1
    printf("%s\n", forward(&history));  // 输出 Page2

    return 0;
}

代码说明

  1. 栈的实现：我们用 Node 结构体来表示栈中的节点，用 Stack 结构体来管理栈顶节点。提供了初始化、检查空栈、推入和弹出元素的函数。
  2. 浏览器历史记录：用 BrowserHistory 结构体来管理当前页面和两个栈。提供了初始化、访问新页面、后退和前进的函数。
  3. 内存管理：使用 malloc 和 free 来动态分配和释放内存，以避免内存泄漏。

🍉栈的实现细节和优化

  • 在实际应用中，栈的实现可以有多种方式，包括使用数组（列表）或链表。每种方式都有其优缺点：
  1. 数组实现栈：简单高效，但需要预先确定栈的最大容量，可能会导致空间浪费或溢出。
  2. 链表实现栈：灵活，无需预先确定栈的容量，但每个节点需要额外的指针存储空间，操作相对复杂。

🍈数组实现栈的优化

  • 为了解决数组实现栈的容量限制问题，可以使用动态数组，它会在需要时自动扩展容量：
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct {
    int *items;
    int capacity;
    int size;
} DynamicArrayStack;

// Initialize the stack
DynamicArrayStack* createStack() {
    DynamicArrayStack* stack = (DynamicArrayStack*)malloc(sizeof(DynamicArrayStack));
    stack->capacity = 1;
    stack->size = 0;
    stack->items = (int*)malloc(stack->capacity * sizeof(int));
    return stack;
}

// Check if the stack is empty
bool isEmpty(DynamicArrayStack* stack) {
    return stack->size == 0;
}

// Push an item onto the stack
void push(DynamicArrayStack* stack, int item) {
    if (stack->size == stack->capacity) {
        stack->capacity *= 2;
        stack->items = (int*)realloc(stack->items, stack->capacity * sizeof(int));
    }
    stack->items[stack->size++] = item;
}

// Pop an item from the stack
int pop(DynamicArrayStack* stack) {
    if (isEmpty(stack)) {
        fprintf(stderr, "pop from empty stack\n");
        exit(EXIT_FAILURE);
    }
    return stack->items[--stack->size];
}

// Peek at the top item of the stack
int peek(DynamicArrayStack* stack) {
    if (isEmpty(stack)) {
        fprintf(stderr, "peek from empty stack\n");
        exit(EXIT_FAILURE);
    }
    return stack->items[stack->size - 1];
}

// Get the size of the stack
int stackSize(DynamicArrayStack* stack) {
    return stack->size;
}

// Free the stack
void freeStack(DynamicArrayStack* stack) {
    free(stack->items);
    free(stack);
}

int main() {
    // Create and use the dynamic array stack
    DynamicArrayStack* dynamicStack = createStack();
    push(dynamicStack, 1);
    push(dynamicStack, 2);
    push(dynamicStack, 3);

    printf("栈顶元素：%d\n", peek(dynamicStack)); // 输出 3
    printf("出栈元素：%d\n", pop(dynamicStack));  // 输出 3
    printf("栈顶元素：%d\n", peek(dynamicStack)); // 输出 2
    printf("栈大小：%d\n", stackSize(dynamicStack)); // 输出 2

    freeStack(dynamicStack);
    return 0;
}

希望这些能对刚学习数据结构的同学们提供些帮助哦！！！

710b90fe3a854ebba1fc0690af904387.png

 

Papicatch
关注
  • 28
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构——栈和队列
qq_51497720的博客
04-23 1975
数据结构——栈和队列 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 数据结构简介 顺序结构 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 链式结构 全新的界面设计 ，将会带来全新的写作体验；## 标题 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高
C++数据结构——栈.pdf
07-11
C++数据结构——栈 C++数据结构 数据结构——栈 栈 最近计划再复习⼀遍数据结构，看到⼀篇博客：。 1、栈(Stack)是⼀种线性存储结构，它具有如下特点： （1）栈中的数据元素遵守"先进后出"(First In Last Out)的原则...
C++数据结构——栈
GeekZW的博客
06-25 16万+
C++数据结构——栈 最近计划再复习一遍数据结构，看到一篇博客：https://www.cnblogs.com/QG-whz/p/5170418.html#_label0。 1、栈(Stack)是一种线性存储结构，它具有如下特点： ...
数据结构——栈详解
m0_54615144的博客
07-27 2766
栈(Stack)是一种线性存储结构，它具有如下特点： （1）栈中的数据元素遵守“先进后出"(First In Last Out)的原则，简称FILO结构。（后进先出的叫法，也是可以的） （2）限定只能在栈顶进行插入和删除操作。 2、栈的相关概念： （1）栈顶与栈底：允许元素插入与删除的一端称为栈顶，另一端称为栈底。 （2）压栈：栈的插入操作，叫做进栈，也称压栈、入栈。 （3）弹栈：栈的删除操作，也叫做出栈。...
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 40万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
基础数据结构——栈（stack）
weixin_60778429的博客
05-11 1328
目录 1.栈的介绍 2.栈的模拟实现 3.栈的基本用法 4.部分栈有关oj解析 1.栈的介绍 栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。 可以参照下图去理解 2.栈的模拟实现 其实栈是一个比较简单且容易实现的数据结构，我们主要需要实现的功能有： 1.pop 返回并弹出栈顶元素 2.peek 返回栈顶元素 3.p.
Java数据结构01——栈
qq_64037280的博客
02-04 3952
java java数据结构 栈
数据结构——栈和队列详细解释
m0_61886762的博客
09-24 2368
你们在使用电脑中也会经历过机器有时会处于疑似死机的状态，鼠标点什么地方都没有任何反应，双击任何快捷键都不动弹。就当你失去内心时，机器突然对你刚的所有操作都执行了一遍。这是因为操作系统在当时可能CPU没有忙过来。操作系统中应用了一种数据结构来实现上述所说的问题也就是先进先出的功能，这就是队列。队列是一种先进先出的线性表简称FIFO。允许插入的操作为队尾，允许删除的操作为队头。就类似于最近几年的做核酸排队的操作，你在入队时是从队尾排队做核酸，做完之后是从队伍的头部做完后退出队伍。
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 1万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构——线性表——栈
m0_50708613的博客
01-28 2601
一、栈 1.栈的定义 栈是只能从一端存取数据和读取数据且遵循 "先进后出" 或“后进后出”原则的线性存储结构。 2.栈的分类 与线性表存储结构类似，栈也有两种存储结构：顺序存储结构和链式存储结构。 二、栈的顺序存储结构 1.顺序栈的定义 顺序栈：即用顺序存储结构方式设计栈的存储数据，从而实现栈存储结构。 顺序栈通常有一个一维数组data和一个记录栈顶元素位置的变量top组成，底部称为栈底，头部称为栈顶。如图所示： 3.顺序栈是四要素 设顺序栈为st. (1)栈空：st.to...
c++ 实现计算器（数据结构——栈）
weixin_45956544的博客
11-27 7961
数据结构课程设计——计算器 目录（可跳转） 文章目录1 项目介绍1.1 背景分析1.2 功能分析2 类结构设计3 功能实现3.1 输入功能3.2 合法性检测3.3 中缀转后缀+计算4 亮点和小结4.1 代码亮点简述4.2 项目小结/心得 1 项目介绍 1.1 背景分析   计算器，广泛应用于商业交易中，是必备的办公用品之一，也被称作“第一代电子计算机”。与计算机相同，它的内部也由逻辑电路组成，其功能实现也离不开对各条语句的分析，从而解析复杂的表达式，按照计算规则得到正确的结果。   我们平时最常接触的
算法和数据结构——栈.pdf
08-07
#资源达人分享计划#
数据结构说课稿——栈.pdf
08-07
#资源达人分享计划#
院校数据结构课程——“栈”微课教学设计.pdf
08-07
#资源达人分享计划#
数据结构的案例教学——栈在“迷宫问题”中的应用.pdf
08-07
#资源达人分享计划#
插入排序和希尔排序详解
friendhan2005的博客
06-08 569
希尔排序详解，大家快来看！！！
二叉树顺序结构——堆的结构与实现
最新发布
qq3304968099的博客
06-10 862
二叉树顺序结构——堆的结构与源代码实现
数据结构和算法一轮
李青水的博客
06-08 896
数据结构第一轮复习
数据结构--栈和队列
code袁的博客
06-08 893
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896栈是一种线性数据结构，具有后进先出（LIFO）的特点。栈可以简单地理解为一摞盘子，我们只能在盘子的顶部放入或取出盘子，不能在中间插入或者从底部取出盘子。队列是一种线性数据结构，具有先进先出（FIFO）的特点。队列可以简单地理解为排队，先到先得，后到后得。手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
数据结构试验——栈的基本操作
10-07
栈是一种具有特定操作顺序的线性数据结构，遵循"后进先出"（Last In First Out，LIFO）的原则。栈的基本操作包括初始化、入栈、出栈、输出、销毁、置栈空、求栈长、判顺序栈是否为空、栈满以及取栈顶元素。 初始化...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值