07栈

最新推荐文章于 2023-01-21 09:07:24 发布
最新推荐文章于 2023-01-21 09:07:24 发布
阅读量155 收藏
点赞数
分类专栏： 数据结构与算法 数据结构学习笔记 文章标签： 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/firemaple_li/article/details/85860970
版权

文章目录

1.概念

栈是一种操作受限的线性表，只允许在一端插入和删除数据. 先进后出 and 后进先出
个人感觉，栈可以使用 内部钱内部的场景，某个对象，在内部包含另一个完整的对象，比如 [()], 这对中括号，内部包含了一个完整的小括号对; 又如函数的层层调用，外部函数，包含了内部函数的全部过程。

2.分类

2.1顺序栈

用数组实现的栈叫顺序栈.

2.1.1 固定大小

package com.desmond.codebase.algorithm.stack;

import java.util.Stack;

/**
 * @author presleyli
 * @date 2018/12/24 12:57 PM
 */
public interface StackInterface<E> {
   E push(E e);

   E pop();

   E peek();
}


package com.desmond.codebase.algorithm.stack;

/**
 * 固定大小的顺序栈(数组栈).
 * @author presleyli
 * @date 2018/12/24 12:57 PM
 */
public class FixedSizeArrayStack implements StackInterface<String>{
    private String[] arr;
    private int size;

    public FixedSizeArrayStack(int n) {
        arr = new String[n];
    }

    /**
     * O(1)
     * @param s
     * @return
     */
    @Override
    public String push(String s) {
        if(size >= arr.length) {
            throw new RuntimeException("stack is full");
        }

        arr[size++] = s; // 1

        return s;
    }

    // O(1)
    @Override
    public String pop() {
        if(size == 0) {
            return null;
        }

        return arr[--size]; // 1
    }

    // O(1)
    @Override
    public String peek() {
        if(size == 0) { // 1
            return null;
        }

        int idx = size - 1; // 1
        return arr[idx]; //  1
    }

    @Override
    public String toString() {
        if(size > 0) {
            System.out.println("start___________");
            for(int i=size-1;i>=0;i--) {
                System.out.println(String.valueOf(arr[i]));
            }

            System.out.println("end______\n\n");
        }

        return "\n";
    }

    public static void main(String[] args) {
        FixedSizeArrayStack stack = new FixedSizeArrayStack(2);
        stack.push("a");
        System.out.println(stack);

        stack.push("b");
        System.out.println(stack);

        System.out.println("peek:" + stack.peek());
        System.out.println("peek:" + stack.peek());
        System.out.println(stack);

        System.out.println("pop:" + stack.pop());
        System.out.println(stack);

        System.out.println("pop:" + stack.pop());
        System.out.println(stack);

        System.out.println("pop:" + stack.pop());
        System.out.println(stack);
    }
}

2.1.2 可扩容

​ 利用数组的动态扩容。复杂度

  • 最好：O(1)

  • 最坏： O(n)

  • 均摊：O(1)

    package com.desmond.codebase.algorithm.stack;

/**
 * 可自动扩容的顺序栈(数组栈).
 * @author presleyli
 * @date 2018/12/24 12:57 PM
 */
public class ChangeableSizeArrayStack implements StackInterface<String>{
    private String[] arr;
    private int size;
    private final int SCALE = 2;

    public ChangeableSizeArrayStack(int n) {
        arr = new String[n];
    }

    /**
     * 最好：O(1)
     * 最坏：2n+3 -> O(n)
     * 均摊(摊还)：O(1)
     * @param s
     * @return
     */
    @Override
    public String push(String s) {
        if(size >= arr.length) { // 1
            // 数组已满，扩容
            String[] newarr = new String[arr.length * SCALE]; // 1

            for(int i=0; i<arr.length; i++) { // n
                newarr[i] = arr[i]; // n
            }

            arr = newarr;
        }

        arr[size++] = s; // 1

        return s;
    }

    @Override
    public String pop() {
        if(size == 0) {
            return null;
        }

        return arr[--size];
    }

    @Override
    public String peek() {
        if(size == 0) {
            return null;
        }

        int idx = size - 1;
        return arr[idx];
    }

    @Override
    public String toString() {
        if(size > 0) {
            System.out.println("start___________");
            for(int i=size-1;i>=0;i--) {
                System.out.println(String.valueOf(arr[i]));
            }

            System.out.println("end______\n\n");
        }

        return "\n";
    }

    public static void main(String[] args) {
        ChangeableSizeArrayStack stack = new ChangeableSizeArrayStack(2);
        stack.push("a");
        System.out.println(stack);

        stack.push("b");
        System.out.println(stack);

        stack.push("c");
        System.out.println(stack);

        stack.push("d");
        System.out.println(stack);

        stack.push("e");
        System.out.println(stack);

        stack.push("f");
        System.out.println(stack);

        stack.push("g");
        System.out.println(stack);

        System.out.println("peek:" + stack.peek());
        System.out.println("peek:" + stack.peek());
        System.out.println(stack);

        System.out.println("pop:" + stack.pop());
        System.out.println(stack);

        System.out.println("pop:" + stack.pop());
        System.out.println(stack);

        System.out.println("pop:" + stack.pop());
        System.out.println(stack);
    }
}

2.2链式栈

用链表实现的栈叫顺序栈.

package com.desmond.codebase.algorithm.stack;

import com.desmond.codebase.algorithm.link.Link;

/**
 * 链式栈.
 * @author presleyli
 * @date 2019/1/5 10:53 AM
 */
public class LinkStack implements StackInterface<String>{
    private Link<String> link = new Link<>();
    
    @Override
    public String push(String s) {
        link.add(s);
        
        return s;
    }

    @Override
    public String pop() {
        return link.remove(link.size() - 1);
    }

    @Override
    public String peek() {
        return link.index(link.size() - 1).getE();
    }
}

3.应用

3.1函数调用

3.2表达式中的应用

3.2.1 背景

​ 求四则运算 3+5*8-6 的值：取两个栈，一个放操作数，一个放运算符合。当放入运算符号时，判断如果之前的运算符的优先级大于当前时，先从操作数栈出栈两个操作数，并运用运算符进行运算，结果压入栈中，一直往复至最后一个元素

3.2.1 示意图

在这里插入图片描述

3.2.2 代码

package com.desmond.codebase.algorithm.stack;

import com.desmond.codebase.algorithm.stack.base.FixedSizeArrayStack;

import java.util.stream.Stream;

/**
 * 利用栈实现 四则运算符，
 *  3+5*8-6
 * @author presleyli
 * @date 2019/1/5 11:03 AM
 */
public class Operation {
    public static void main(String[] args) {
        System.out.println(op("3+5*8-6") + "-->" + "37");
        System.out.println(op("3+5") + "-->" + "8");
        System.out.println(op("5*8") + "-->" + "40");
        System.out.println(op("5*8-6") + "-->" + "34");
    }

    /**
     * O(1).
     * @param express
     * @return
     */
    public static Integer op(String express) {
        FixedSizeArrayStack eleStack = new FixedSizeArrayStack(5 );
        FixedSizeArrayStack opStack = new FixedSizeArrayStack(5);

        int result = 0;
        char[] arr = express.toCharArray();

        for(int i = 0; i < arr.length; i++) {
            char c = arr[i]; // 1

            OpEnum opEnum = OpEnum.getOp(c); // 1
            if(opEnum != null) {
                operations(eleStack, opEnum, opStack); // 1

                opStack.push(c + "");
            } else {
                eleStack.push(c + "");
            }

            if(i == arr.length - 1) {
                opEnum = OpEnum.getOp(opStack.pop().charAt(0));

                result = cal(opEnum, eleStack);
            }
        }

        return result;
    }

    /**
     * O(1).
     * @param eleStack
     * @param curr
     * @param opStack
     */
    private static void operations(FixedSizeArrayStack eleStack, OpEnum curr, FixedSizeArrayStack opStack) {
        if(eleStack.size() > 1 && opStack.size() > 0) {
            OpEnum existing = OpEnum.getOp(opStack.peek().charAt(0)); // 1
            if(existing.getPriority() >= curr.getPriority()) { // 1
                existing = OpEnum.getOp(opStack.pop().charAt(0));
                int result = cal(existing, eleStack);

                eleStack.push(result + "");

                operations(eleStack, curr, opStack);
            }
        }
    }

    /**
     * O(1)
     * @param oe
     * @param eleStack
     * @return
     */
    private static Integer cal(OpEnum oe, FixedSizeArrayStack eleStack) {
        int result = 0;

        int top1 = Integer.parseInt(eleStack.pop());
        int top2 = Integer.parseInt(eleStack.pop());

        switch (oe) {
            case ADD:
                result = top2 + top1;
                break;
            case SUBSTRACT:
                result = top2 - top1;
                break;
            case MULTIPLE:
                result = top2 * top1;
                break;
            case DIVIION:
                result = top2 / top1;
                break;
        }

        return result;
    }

    private static enum OpEnum {
        ADD('+', 1),
        SUBSTRACT('-', 1),

        MULTIPLE('*', 2),
        DIVIION('/', 2),
        ;


        private char op;
        private int priority;

        OpEnum(char op, int priority) {
            this.op = op;
            this.priority = priority;
        }

        public static OpEnum getOp(char c) {
            return Stream.of(OpEnum.values())
                    .filter(o -> o.getOp() == c)
                    .findFirst()
                    .orElse(null);
        }

        public char getOp() {
            return op;
        }

        public void setOp(char op) {
            this.op = op;
        }

        public int getPriority() {
            return priority;
        }

        public void setPriority(int priority) {
            this.priority = priority;
        }
    }
}

3.3 括号匹配

​ 判断表达中括号()/[]/{}是否一一匹配.

​ 代码：

package com.desmond.codebase.algorithm.stack;

import com.desmond.codebase.algorithm.stack.base.FixedSizeArrayStack;

/**
 * @author presleyli
 * @date 2019/1/5 11:59 AM
 */
public class BracketMatch {

    public static void main(String[] args) {
        System.out.println(isValid("a(([{}]))"));
        System.out.println(isValid("a(b[c{d}]}"));
        System.out.println(isValid("a(b[(c{d}]]}"));
        System.out.println(isValid("a(b{[c{d}]}"));
    }

    /**
     * O(1).
     * @param express
     * @return
     */
    public static boolean isValid(String express) {
        FixedSizeArrayStack stack = new FixedSizeArrayStack(10);

        for(int i = 0; i < express.length(); i++) {
            char c = express.charAt(i);

            if(c == '(' || c == '[' || c == '{') {
                stack.push(c + "");
            }

            if(c == ')' || c == ']' || c == '}') {
                char b = stack.pop().charAt(0);

                if(c == ')') {
                    if(b != '(') {
                        return false;
                    }
                }

                if(c == ']') {
                    if(b != '[') {
                        return false;
                    }
                }

                if(c == '}') {
                    if(b != '{') {
                        return false;
                    }
                }
            }

        }


        return stack.size() == 0;
    }
}

​

3.4 浏览器前进、后退

流程：
在这里插入图片描述

代码：

package com.desmond.codebase.algorithm.stack;

import com.desmond.codebase.algorithm.stack.base.FixedSizeArrayStack;
import com.desmond.codebase.algorithm.stack.base.StackInterface;

/**
 * 浏览器前进或者后推.
 * @author presleyli
 * @date 2019/1/5 12:38 PM
 */
public class BrowserAheadOrBack {
    static StackInterface<String> ahead = new FixedSizeArrayStack(5),
            back = new FixedSizeArrayStack(5);

    public static void main(String[] args) {
        init();

        ahead();
        ahead();

        back();
        back();
        back();
        back();
    }

    public static void init() {
        ahead.push("a");
        ahead.push("b");

        back.push("c");
    }

    public static void ahead() {
        if(back.size() > 0) {
            ahead.push(back.pop());
        }

        if(back.size() == 0) {
            System.out.println("last page!");
        }

        System.out.println("current: " + ahead.peek());
    }

    public static void back() {
        if(ahead.size() > 0) {
            back.push(ahead.pop());
        }

        if(ahead.size() == 0) {
            System.out.println("first page!");
        }

        System.out.println("current: " + ahead.peek());
    }
}

4. Jvm中的栈

​ 桢栈，包括局部变量表，操作数栈(存放操作数用于操作)，动态链接，方法出口灯信息

desmond_assis
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
07栈的基本操作(顺序栈).cpp
11-21
07栈的基本操作(顺序栈).cpp
栈的顺序存储及代码实现
weixin_36101480的博客
03-15 911
栈是在数据结构中经常能遇到的，在我们平时也能遇到。比如当我们在打断点调试时，经常能遇到堆栈，先调用的后出来。或者网页的后退键也是栈的应用。 一.栈及其初始化 栈是限定仅在表尾进行插入和删除操作的线性表。 我们把允许插入的一端称为栈顶，另一端称为栈底。 栈称为先进后出，简称FOLI 栈也是线性表，也有前驱后继关系。线性表的表尾是栈顶 栈插入操作叫进栈，入栈 栈删除操作叫出栈 栈的结构 栈的顺序...
07-栈Stack
tttxxl的博客
11-20 508
目录1.栈（Stack）2.栈空间3.栈的接口设计4.实现：4.1.直接继承ArrayList，复用其中的一些方法4.2.将ArrayList作为Stack的一个私有属性5.Java官方提供的栈：java.util.Stack 1.栈（Stack） 栈是一种特殊的线性表，只能在一端进行操作。 往栈中添加元素的操作，一般叫做push，入栈。 从栈中移除元素的操作，一般叫做pop，出栈（只能移除栈顶元素，也叫做弹出栈顶元素）。 后进先出的原则：Last In First Out, LIFO 2.栈空间
Js逆向教程-07方法栈
虚幻社区
11-14 1465
最后的最后由本人水平所限，难免有错误以及不足之处， 屏幕前的靓仔靓女们 如有发现，恳请指出！你轻轻地点了个赞，那将在我的心里世界增添一颗明亮而耀眼的星！
JVM之栈
从基础到源码解析的学习记录
12-30 860
文章目录1、虚拟机栈的主要特点1.1、内存中的栈与堆1.2、Java虚拟机栈是什么？1.3、栈的优点2、虚拟机栈常见异常与如何设置栈大小2.1、栈中可以出现的异常2.2、设置栈内存大小3、虚拟机栈的运行原理3.1、运行原理3.2、代码示例4、栈帧的内部结构4.1、局部变量表4.1.1、结构认识4.1.2、Slot的理解4.1.3、静态变量与局部变量的对比4.1.4、补充4.2、操作数栈4.2.1、操作数栈的特点4.2.2、操作数栈的作用4.2.3、操作数栈的字节码指令执行分析4.2.2、关于调用方法，返回值
浅析栈溢出原理
热门推荐
najdhdfh的博客
10-20 1万+
函数的调用 准备工具: linux系统 调试工具gdb gdb插件:pwndbg 关于pwndbg插件可以在github搜索并下载安装,需要python环境 工具准备好之后,来看一段简单的代码,我们将通过调试分析这段简单的代码来理解函数在被调用前后都做了哪些操作. #include<stdio.h> int add(int a, int b){ return a + b; } int main(){ int num = add(1,2); printf("resu
07 |「栈和队列」简析
小Y的博客
01-21 1309
简析栈和队列。
栈与递归——2018/01/07思考
qq_40491305的博客
01-07 310
栈与递归 继昨天写完栈的简单应用——四则运算之后，我对栈的兴趣又变浓了，尤其是昨天在看到栈与递归这个问题时，心中更是一咯噔，我们都知道递归对内存的耗费是比较大的，而计算机在函数调用过程中与栈相似，因此递归是可以通过栈来实现的，从而提高效率（当然循环有时候也是可以实现的，可是我就想用栈，你管我~），所以在我下午吃了一下午鸡（跳了一下午伞）之后，“良心备受谴责”，特意晚上重回图书馆。回到图书馆后本来
07_本地方法栈
qq_46265096的博客
01-04 45
07_本地方法栈本地方法栈（Native Method Stack） 本地方法栈（Native Method Stack） Java虚拟机栈用于管理Java方法的调用，而本地方法栈用于管理本地方法的调用。 本地方法栈，也是线程私有的。 允许被实现成固定或者是可动态扩展的内存大小。（在内存溢出方面是相同的） ① 如果线程请求分配的栈容量超过本地方法栈允许的最大容量，Java虚拟机将会抛出一个 StackOverflowError 异常。 ② 如果本地方法栈可以动态扩展，并且在尝试扩展的时候无法申
2020-07-12栈
qq_44884455的博客
08-06 150
什么是栈（后进先出） (使用指针的简单数据结构来表示动态集合。基本的结构就有：栈、队列、链表、有根树) 栈的几种操作： STACK-EMPTY(S) //测试一个栈是否为空 if S.top == 0 return TRUE else return FALSE PUSH(S,x) //压入，栈上的insert操作 S.top = S.top + 1 S[S.top] = x POP(S) if STACK-EMPTY..
JVM07 JVM本地方法栈
wegofun的博客
07-05 157
07 本地方法栈 本地方法接口为本地方法栈服务，本地方法栈执行时通过调用本地方法接口来实现； 1. 本地方法栈 Java虚拟机栈用于管理Java方法的调用，而本地方法栈用于管理本地方法； 本地方法栈是线程私有的； 允许被实现成固定或者是可动态扩展的内存大小，会出现StackOverflowError异常和OutOfMemoryError异常； 本地方法是使用C语言实现的； 它的具体做法是Native Method Stack中登记native方法，在Execution Engine执行时加载本地方法库
07.链式堆栈以及栈的应用.ppt
03-02
07.链式堆栈以及栈的应用.ppt
64位Linux下的栈溢出
10-05
0x01 x86和x86_64的区别 0x02 漏洞代码片段 0x03 触发溢出 0x04 控制RIP 0x05 跳入用户控制的缓冲区 0x06 执行shellcode 0x07 GDB vs 现实 0x08 结语
bhushanyadav07
02-12
:laptop: 我爱的东西编码 前端开发 :writing_hand: 研究和发展 :face_with_monocle: 数据科学 :grimacing_face: :hammer_and_wrench: 科技栈 与我联系显示一些 :red_heart: 通过对某些存储库加注星标！
LWIP协议栈（2_1_0版本，至2018.7.19最新）
07-19
至2018.07.19最新的LWIP官方协议栈，在apps文件中包含目前物联网最流行的网络协议MQTT，在学习作为轻量级的网络协议栈同时还能作为MQTT的项目进行开发
node-v18.11.0-headers.tar.xz
最新发布
05-20
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
JavaScript_跨平台3D场景编辑器基于threejs golang和mongodb桌面和web.zip
05-20
JavaScript
JavaScript_如何编写跨平台Nodejs代码.zip
05-20
JavaScript
北邮大三物流工程物流信息系统课程设计
05-20
北邮大三物流工程物流信息系统课程设计
基于Qt使用CANopennode协议栈进行CAN接口通信代码
06-06
msg.data[6] = 0x07; msg.data[7] = 0x08; co_send(&node, 0x123, &msg.data[0], msg.len); // 接收CANopen消息 while (true) { QByteArray data = serialPort.readAll(); if (!data.isEmpty()) { for (int...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值