栈的初认识

已于 2024-02-27 15:58:52 修改
阅读量1k 收藏 19
点赞数 29
文章标签： java 开发语言 c++ 数据结构
于 2024-02-27 11:13:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sara_shengxin/article/details/136315937
版权

什么是栈

        栈（stack）是一种数据结构，它是一种具有特定方法的线性表，又称之为访问受限的线性表，它是许多表达式，符号等运算的基础，也是递归的底层实现。。栈的特点是先进后出（FILO，First In Last Out），即最后进入的元素最先出来，而最先进入的元素最后出来。栈通常有两种基本操作：压栈（push），在栈顶插入元素；出栈（pop），删除栈顶元素。

        栈在计算机科学中有广泛的应用，比如函数调用的时候会使用栈来保存函数的调用顺序和局部变量；浏览器的访问历史可以使用栈来实现页面的后退和前进；编译器和解释器中使用栈来存储临时数据和函数调用栈；操作系统中也会使用栈来存储程序执行的上下文等。 栈的实现方式有多种，比如可以使用数组或链表来实现。栈的重要性不言而喻，它为解决许多实际问题提供了便利的途径。

栈的结构如下：

393a909794184c0c8bf89223fa4ceadf.png

栈的操作

        push():增加一个元素

        pop()：弹出一个元素

        peek():显示栈顶元素，但是不出栈

        empty():判断栈是否为空

栈的实现

栈的实现可以用数组，也可以用链表，或者使用Java的LinkedList三种方式

用数组实现

#include <iostream>
#include <stack>

int main() {
    std::stack<int> myStack;

    // 压入元素
    myStack.push(1);
    myStack.push(2);
    myStack.push(3);

    // 访问栈顶元素并出栈
    std::cout << "栈顶元素：" << myStack.top() << std::endl;
    myStack.pop();

    // 输出栈中元素数量
    std::cout << "栈中元素数量：" << myStack.size() << std::endl;

    // 判断栈是否为空
    if(myStack.empty()) {
        std::cout << "栈为空" << std::endl;
    } else {
        std::cout << "栈不为空" << std::endl;
    }

    return 0;
}
import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> myStack = new Stack<>();

        // 压入元素
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);

        // 访问栈顶元素并出栈
        System.out.println("栈顶元素：" + myStack.peek());
        myStack.pop();

        // 输出栈中元素数量
        System.out.println("栈中元素数量：" + myStack.size());

        // 判断栈是否为空
        if(myStack.isEmpty()) {
            System.out.println("栈为空");
        } else {
            System.out.println("栈不为空");
        }
    }
}

 用链表实现

        用链表实现栈时，将插入与删除都在表头操作 

#include <iostream>

// 定义链表节点结构体
struct Node {
    int data;
    Node* next;
};

class Stack {
private:
    Node* top;

public:
    // 构造函数，初始化栈顶指针为nullptr
    Stack() : top(nullptr) {}

    // 判断栈是否为空
    bool isEmpty() {
        return top == nullptr;
    }

    // 压栈
    void push(int value) {
        Node* newNode = new Node;
        newNode->data = value;
        newNode->next = top;
        top = newNode;
    }

    // 出栈
    void pop() {
        if (isEmpty()) {
            std::cout << "栈为空，无法出栈" << std::endl;
            return;
        }
        Node* temp = top;
        top = top->next;
        delete temp;
    }

    // 获取栈顶元素
    int topValue() {
        if (isEmpty()) {
            std::cout << "栈为空，栈顶元素不存在" << std::endl;
            return -1;
        }
        return top->data;
    }

    // 析构函数，释放所有节点内存
    ~Stack() {
        while (top != nullptr) {
            Node* temp = top;
            top = top->next;
            delete temp;
        }
    }
};

int main() {
    Stack myStack;

    myStack.push(1);
    myStack.push(2);
    myStack.push(3);

    std::cout << "栈顶元素：" << myStack.topValue() << std::endl;
    myStack.pop();

    std::cout << "栈顶元素：" << myStack.topValue() << std::endl;
    myStack.pop();

    std::cout << "栈顶元素：" << myStack.topValue() << std::endl;
    myStack.pop();

    return 0;
}
import java.util.EmptyStackException;

class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

class Stack {
    private Node top;

    public Stack() {
        top = null;
    }

    public boolean isEmpty() {
        return top == null;
    }

    public void push(int data) {
        Node newNode = new Node(data);
        newNode.next = top;
        top = newNode;
    }

    public int pop() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        int data = top.data;
        top = top.next;
        return data;
    }

    public int peek() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return top.data;
    }
}

public class Main {
    public static void main (String[] args) {
        Stack myStack = new Stack();

        myStack.push(1);
        myStack.push(2);
        myStack.push(3);

        System.out.println("栈顶元素：" + myStack.peek());
        myStack.pop();

        System.out.println("栈顶元素：" + myStack.peek());
        myStack.pop();

        System.out.println("栈顶元素：" + myStack.peek());
        myStack.pop();
    }
}

栈的经典算法

括号匹配问题

        当遇到左括号时，将其入栈；当遇到右括号时，检查栈顶元素是否与其匹配的左括号，如果匹配则将栈顶元素出栈，继续遍历；如果不匹配或者栈为空，则说明括号不匹配，返回 false。最终，若字符遍历结束时，栈为空，则说明括号完全匹配，返回 true。 

#include <iostream>
#include <stack>
#include <string>

bool isMatching(const std::string& str) {
    std::stack<char> st;
    
    for (char c : str) {
        if (c == '(' || c == '[' || c == '{') {
            st.push(c);
        } else if (c == ')' || c == ']' || c == '}') {
            if (st.empty()) {
                return false;
            } else if ((c == ')' && st.top() == '(') || (c == ']' && st.top() == '[') || (c == '}' && st.top() == '{')) {
                st.pop();
            } else {
                return false;
            }
        }
    }
    
    return st.empty();
}

int main() {
    std::string str = "{[()]}";
    if (isMatching(str)) {
        std::cout << "Parentheses are matching." << std::endl;
    } else {
        std::cout << "Parentheses are not matching." << std::endl;
    }

    return 0;
}

最小栈

        最小栈问题是一个常见的面试问题，通常要求设计一个特殊的栈数据结构，除了支持常规的栈操作（入栈、出栈、获取栈顶元素）之外，还要支持获取栈中的最小元素操作。即，设计一个栈，在常数时间复杂度内可以获取当前栈中的最小元素值。

#include <stack>
#include <iostream>

class MinStack {
private:
    std::stack<int> dataStack;
    std::stack<int> minStack;

public:
    void push(int x) {
        dataStack.push(x);
        if (minStack.empty() || x <= minStack.top()) {
            minStack.push(x);
        }
    }

    void pop() {
        if (dataStack.top() == minStack.top()) {
            minStack.pop();
        }
        dataStack.pop();
    }

    int top() {
        return dataStack.top();
    }

    int getMin() {
        return minStack.top();
    }
};

int main() {
    MinStack minStack;
    minStack.push(-2);
    minStack.push(0);
    minStack.push(-3);

    std::cout << "Current min element in stack: " << minStack.getMin() << std::endl;  // Output: -3

    minStack.pop();
    std::cout << "Top element in stack: " << minStack.top() << std::endl;  // Output: 0

    std::cout << "Current min element in stack: " << minStack.getMin() << std::endl;  // Output: -2

    return 0;
}

         在最小栈的实现中，dataStack 和 minStack 通常被用于存储不同类型的数据，并且它们之间具有一定的关系：

 `dataStack`：数据栈用于存储传入的用户数据，即用户对栈进行 push 和 pop 操作时真正操作的栈。数据栈中的元素顺序代表用户数据的入栈和出栈顺序。 

`minStack`：最小值栈（辅助栈）用于存储当前数据栈中的最小元素。当用户向数据栈压入元素时，如果该元素比当前最小元素小或等于当前最小元素，则要将该元素同时压入最小值栈。最小值栈中的栈顶元素始终代表当前数据栈中的最小元素。

        这种设计的关键在于，在常数时间内获取当前栈中的最小元素。通过在每次 push 操作中维护最小值栈的栈顶元素，最小值栈可以保持与数据栈相同的压入和弹出顺序，并在 O(1) 的时间内返回当前栈中的最小元素值。 因此，dataStack 和 minStack 是两个栈，互相独立，但在实现中具有密切的关系，最小值栈的设计是为了支持在常数时间内获取最小元素的特殊需求。

最大栈

与最小栈相似

#include <stack>
#include <iostream>

class MaxStack {
private:
    std::stack<int> dataStack;
    std::stack<int> maxStack;

public:
    void push(int x) {
        dataStack.push(x);
        if (maxStack.empty() || x >= maxStack.top()) {
            maxStack.push(x);
        }
    }

    void pop() {
        if (dataStack.top() == maxStack.top()) {
            maxStack.pop();
        }
        dataStack.pop();
    }

    int top() {
        return dataStack.top();
    }

    int getMax() {
        return maxStack.top();
    }
};

int main() {
    MaxStack maxStack;
    maxStack.push(2);
    maxStack.push(5);
    maxStack.push(1);

    std::cout << "Current max element in stack: " << maxStack.getMax() << std::endl;  // Output: 5

    maxStack.pop();
    std::cout << "Top element in stack: " << maxStack.top() << std::endl;  // Output: 5

    std::cout << "Current max element in stack: " << maxStack.getMax() << std::endl;  // Output: 2

    return 0;
}

计算器问题

        计算器问题通常是指实现一个简单的计算器程序，该程序可以对包含加减乘除以及括号的数学表达式进行求值。该问题的解决涉及到处理运算符优先级、括号的计算顺序以及实现逆波兰表达式等方法。解决计算器问题的最好方法就是栈。

#include <iostream>
#include <stack>
#include <string>

int calculate(std::string s) {
    std::stack<int> nums;
    std::stack<char> ops;

    int num = 0;
    char sign = '+';

    for (int i = 0; i < s.length(); i++) {
        char c = s[i];
        if (isdigit(c)) {
            num = num * 10 + (c - '0');
        }
        if ((!isdigit(c) && c != ' ') || i == s.length() - 1) {
            if (sign == '+') {
                nums.push(num);
            } else if (sign == '-') {
                nums.push(-num);
            } else if (sign == '*') {
                int prev = nums.top();
                nums.pop();
                nums.push(prev * num);
            } else if (sign == '/') {
                int prev = nums.top();
                nums.pop();
                nums.push(prev / num);
            }
            num = 0;
            sign = c;
        }
    }

    int result = 0;
    while (!nums.empty()) {
        result += nums.top();
        nums.pop();
    }
    return result;
}

int main() {
    // Example usage
    std::string s = "3+2*2";
    int result = calculate(s);
    std::cout << "Result: " << result << std::endl;  // Output: 7

    return 0;
}

 

 

sara_shengxin
关注
  • 29
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
profinet协议栈源码
05-16
基于p-net的移植，适用于stm32平台。 github地址：https://github.com/andre-lost-a-pig/p-net-stm32
5_栈_
09-30
利用栈和队列的特性设计一个算法，用于判断一个字符串是否为回文。
关于栈，队列和数组的初步认识
05-06
该文章主要是用于初学c++/c对于栈，队列和数组的认识，有一定的算法基础会更好的理解此篇文章。
C语言实现栈操作
11-28
假设给定的整数栈 初始状态为空，栈的最大容量为100.从标准输入中输入一组栈操作，按操作顺序输出出栈元素序列。栈操作：1表示入栈操作，后跟一个整数（不为1/0和-1）为入栈元素，0表示出栈操作，-1表示操作结束。从...
铁路栈问题
03-12
铁路栈问题 输入参数 进站的火车最大编号 使用字符串表示火车出站序列 返回值： 根据输入的进站序列判断，如果输入的出战序列是可能的，返回1，否则返回0；
android高斯模糊填充imageview背景
cf8833的博客
05-21 517
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
Spring Bean Map之舞
m0_51176516的博客
05-23 450
在Spring框架中，Bean的生命周期管理是其核心功能之一。当Spring容器启动时，它会根据配置信息（如XML配置文件、注解等）来创建和管理Bean实例。这些Bean实例默认会被放置在一个Map数据结构中，以便容器能够快速地根据Bean的名称（或ID）来查找和访问它们。 在Spring的源码中，Bean实例的存储和管理主要依赖于DefaultSingletonBeanRegistry类。这个类内部使用了一个名为singletonObjects的Map来存储单例Bea...
java学习和项目总结
2301_79390585的博客
05-24 364
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 549
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
SpringBoot Validation自定义注解之校验指定最小整数
thinkers
05-21 202
1，引入核心关键依赖。
JVM学习-执行引擎
丢爸
05-21 1017
当然是否需要启动JIT编译器将字节码直接编译为对应平台的本地机器指令，则需要根据代码被调用。大部分的程序代码转换为物理机的目标代码或虚拟机能执行的指令集之前，都需要经过下图各个步骤。，将其直接编译为对应平台的本地机器指令，以此提升Java程序的执行性能。”，JIT编译器在运行时会针对那些频繁被调用的热点代码做出。Java代码编译是由Java源码编译器来完成，流程图如下。而定，关于那些需要被编译为本地代码的字节码，称为“Java字节码的执行是由JVM执行引擎来完成。
深入理解Java的垃圾回收机制（GC）实现原理
微笑听雨
05-25 773
GC是Java虚拟机的重要组成部分，通过自动内存管理，GC提高了Java程序的稳定性和安全性。理解GC的工作原理和不同收集器的特点，有助于选择合适的GC策略，优化应用性能。通过合理配置JVM参数，可以提高GC效率，减少应用停顿时间，提升系统的整体性能。
【进程信号】可重入函数&&volatile关键字
稻草人敲代码的博客
05-22 517
虽然执行了myhandler,也成功修改了flag的值，但是由于编译器优化，早就将flag的值拷贝到寄存器中了，CPU只会在寄存器中读取flag的值。标准情况下，键入 CTRL-C ,2号信号被捕捉，执行自定义动作，修改 flag＝1 ， while。意思就是说，可重入函数里面的数据都是临时变量，随着函数栈帧的销毁而销毁，编译器在优化代码的时候，会大概推断出哪些变量在特定的范围内不会改变。保持内存的可见性，告知编译器，被该关键字修饰的变量，，对该变量的任何操作，都必须在真实的内存中进行操作。
微信小程序uniapp+django洗脚按摩足浴城消费系统springboot
QQ1304979694的博客
05-24 482
Python语言官方规范访问数据库的统一接口规范(Python DB-API)，防止在使用不同数据库时，由于底层数据库技术不同造成接口程序紊乱的问题。（3）项目初期开发，美工设计，前端实现，开发信息系统的用户功能的实现，完善界面排版，实现信息提取发送等一系列功能。项目系统最后阶段的修改及最终测试运行。当然，在研究过程中也可以直接调查，对调查搜集到的资料进行综合分析、比较，调查法是科学研究中普遍的研究方法。（5）系统测试：对设计好的程序进行最终调试，通过调试发现存在的问题并解决，从而达到完善系统的目的。
Solon 的 InjectGather 在 AppContext 里起到了什么作用？
Itmastergo的博客
05-20 802
Solon是一款轻量级的Java开发框架，其设计理念简单且易于使用，主要应用于微服务和现代化的Java应用开发。Solon框架的核心目标是提供一个高效且简洁的开发环境，使开发者能够快速构建和部署应用程序。在Solon框架中，AppContext是核心上下文，它管理着整个应用程序的生命周期，包括bean的注册、依赖注入、事件管理等。AppContext是一个应用程序的核心容器，类似于Spring中的。Bean管理：负责注册和管理应用程序中的所有bean。依赖注入：提供自动化的依赖注入机制。事件管理。
初识Spring Cloud
u011627218的专栏
05-20 805
一、介绍。
小小字符串竟然如此嚣张 —— 聊聊 Java 的 String
最新发布
Gary_Tam的博客
05-25 220
大家好，我是徒手敲代码。今天来分享几个 String 在面试当中，比较常见的问题。这个东西用得最多，而且底层的原理，面试也经常问。
MyBatis从浅入深
Cobrander2_0的博客
05-21 653
Mybatis用于简化Java当中对于JDBC的操作，它将连接数据库，执行SQL命令自动化实现。
一个用Java编写的屏幕测距工具，包括游戏地图测量功能
学习学习学习
05-22 372
该程序提供了一个简单便捷的方式，在屏幕上测量距离，包括游戏地图分析在内。它允许用户准确确定屏幕上两点之间的距离，帮助游戏过程中的战略规划、资源管理和决策制定。注意：确保应用程序窗口覆盖屏幕上感兴趣的区域，以进行准确的测量。对于游戏地图，请调整缩放级别或分辨率，以匹配游戏内的设置，从而进行精确测量。
谈谈自己对数据结构中栈和队列的认识
06-06
好的，关于栈和队列，它们都是数据结构中比较基础的数据类型。 首先，栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构。它的特点是只允许在栈顶进行插入和删除操作，也就是说，最后一个进入栈的元素，是第...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值