数据结构与算法（栈）

最新推荐文章于 2024-07-12 18:56:03 发布
最新推荐文章于 2024-07-12 18:56:03 发布
阅读量18 收藏
点赞数
文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eeeeye_/article/details/134385642
版权

概念及应用

在这里插入图片描述
在这里插入图片描述

基本操作（数组模拟栈）

package com.Eeeeye;

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        ArrayStack arrayStack = new ArrayStack(4);
        String key = "";
        boolean loop = true;//控制是否退出菜单
        Scanner scanner = new Scanner(System.in);
        while (loop) {
            System.out.println("show:显示栈");
            System.out.println("exit: 退出程序");
            System.out.println("push");
            System.out.println("pop");
            System.out.println("请输入");
            key = scanner.next();
            switch (key) {
                case "show":
                    arrayStack.list();
                    break;
                case "push":
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    arrayStack.push(value);
                    break;
                case "pop":
                    try {
                        int res = arrayStack.pop();
                        System.out.println("出栈的数据是" + res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    loop = false;
                    scanner.close();
                default:
                    break;
            }
        }
        System.out.println("程序退出了");

    }
}

class ArrayStack {
    private int maxSize;
    private int[] stack;
    private int top = -1;//数组从1开始

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    //判断栈满
    public boolean isFull() {
        return top == maxSize - 1;

    }

    //判断栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //入栈
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;

    }

    //出栈
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException();
        }
        int value = stack[top];
        top--;
        return value;
    }

    //遍历栈,从栈顶开始,自上而下显示数据（栈底不变）
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空无法遍历");
            return;
        }
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d] = %d\n", i, stack[i]);

        }
    }


}

链表模拟栈

class LinkedListStack {
    private int maxSize;
    private int size;
    private Node top;

    public LinkedListStack(int maxSize) {
        this.maxSize = maxSize;
        //根据输入创建一个特定的链表

    }

    public LinkedListStack() {
    }


    public boolean isFull() {
        return size == maxSize;
    }

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

    public void push(int no) {
        Node node = new Node(no);

        if (isFull()) {
            System.out.println("栈已满");
        }
        if (isEmpty()) {
            top = node;
        } else {
            node.next = top;
            top = node;

        }
        size++;
    }
    public int pop() {
        if (isEmpty()){
            System.out.println("栈为空");
        }
        int no = top.no;
        top = top.next;
        size--;
        return no;
    }
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空无法遍历");
            return;
        }
        Node temp = top;
        while (true){
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }



    /**
     * 获取
     *
     * @return maxSize
     */
    public int getMaxSize() {
        return maxSize;
    }

    /**
     * 设置
     *
     * @param maxSize
     */
    public void setMaxSize(int maxSize) {
        this.maxSize = maxSize;
    }

    /**
     * 获取
     *
     * @return size
     */
    public int getSize() {
        return size;
    }

    /**
     * 设置
     *
     * @param size
     */
    public void setSize(int size) {
        this.size = size;
    }


    public String toString() {
        return "LinkedListStack{maxSize = " + maxSize + ", size = " + size + "}";
    }
}

class Node {
    public int no;

    public Node next;


    public Node() {
    }

    public Node(int no) {
        this.no = no;
    }


    public String toString() {
        return "Node{no = " + no + "}";
    }
}

用栈完成一个简易的计算器，计算简单的表达式

package com.Eeeeye.stack;

public class Calculator {
    public static void main(String[] args) {
        String expression = "70+2*6-2";
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        //定义需要的相关变量
        int index = 0;//用于扫描
        int num1 = 0;
        int num2 = 0;
        int oper = 0;//也可以写为char
        int res = 0;
        char ch = ' ';//将每次扫描到的char保存到ch
        String keepNum = "";
        //死循环扫描expression
        while (true) {
            //将字符以字符串的形式取出后再转为字符
            ch = expression.substring(index, index + 1).charAt(0);
            //判断ch是什么，然后做相应的处理
            if (operStack.isOper(ch)) {//如果是运算符
                if (!operStack.isEmpty()) {
                    //比较优先级，如果当前操作优先级小于栈中的运算符
                    //就需要从数栈中pop出两个数，从符号栈中Pop出一个符号
                    //进行运算得到结果，此结果入数栈，然后将当前运算符入符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        //把运算的结果入数栈
                        numStack.push(res);
                        //把当前的运算符入符号栈
                        operStack.push(ch);

                    } else {//如果优先级高直接入栈
                        operStack.push(ch);

                    }


                } else {//如果是空直接入栈
                    operStack.push(ch);
                }


            } else {//如果是数，则直接入数栈

                //1.当处理多位数时，不能发现是一个数就立即入栈，因为可能是多位数
                //2.往expression后多看一位，当是运算符时，才进行入栈操作
                //3.因此需要定义一个字符串变量用于拼接

                //处理多位数
                keepNum += ch;//在循环中储存上一个ch的值并与当前循环的ch值相加

                //如果ch已经是expression的最后一位，直接入栈，否则index+2会出现下标越界异常
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                    break;
                } else {


                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        //如果后一位是运算符，则入栈
                        numStack.push(Integer.parseInt(keepNum));
                        keepNum = "";
                    }


                }
            }
            index++;
            //index从0开始
            if (index >= expression.length()) {//也可以是等于
                break;
            }
        }
        //扫描完毕，按顺序，从数栈和符号栈中pop出相应的数和符号，并运算
        while (true) {
            //如果符号栈为空，则计算到最后，数栈中存放最后的结果
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            numStack.push(res);//入栈
        }
        System.out.println("表达式为" + expression + "  " + numStack.pop());
    }
}

class ArrayStack2 {
    private int maxSize;
    private int[] stack;
    private int top = -1;//数组从1开始

    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    //增加一个方法，可以返回当前栈顶的值，但不是真正的pop
    public int peek() {
        return stack[top];
    }

    //判断栈满
    public boolean isFull() {
        return top == maxSize - 1;

    }

    //判断栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //入栈
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;

    }

    //出栈
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException();
        }
        int value = stack[top];
        top--;
        return value;
    }

    //遍历栈,从栈顶开始,自上而下显示数据（栈底不变）
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空无法遍历");
            return;
        }
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d] = %d\n", i, stack[i]);

        }
    }

    //返回运算符的优先级，优先级是程序员来确定的，优先级使用数字表示
    //数字越大，优先级越高
    public int priority(int oper) {
        //Java中int和char可以混用
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;//假定目前只有加减乘除
        }
    }

    //判断是否为运算符
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';

    }

    public int cal(int num1, int num2, int oper) {
        int res = 0;//用于存放计算的结果
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;//注意顺序
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }

}
Eeeeye_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构与算法】：栈
Baridhu的博客
02-15 1947
本文主要争对对栈的运用、基础理解和代码实现，其中对逆波兰表达式等进行了分析、讲解。
恋上数据结构与算法课件.rar
11-23
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。本课程的资源"恋上数据结构与算法课件.rar"涵盖了多个核心概念，旨在帮助学习者深入理解这些关键领域。 首先，我们来探讨“复杂度”。在计算...
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构与算法丨栈
兔子王
10-03 1601
数据结构与算法之栈。
头歌数据结构与算法——栈
weixin_62440328的博客
10-28 5632
【代码】头歌数据结构与算法——栈。
数据结构与算法-Part4——栈与队列
leikang111的博客
04-09 2121
C#栈与队列全收录!
数据结构与算法-栈
勤于笔记，成于点滴。
11-24 1386
栈又称为堆栈，是一种运算受限定表。说是限定表是由于对于元素的入栈和出栈都在表末尾进行，换言之就是先进后出，其本质就是对表尾部元素进行操作。
Java数据结构与算法——栈
★★光亭★★
03-13 9105
Java数据结构与算法——栈
数据结构与算法--栈
前端劝退工程师
04-14 1050
**栈是一种遵从后进先出（LIFO）原则的有序集合。新添加的或待删除的元素都保存在栈的 末尾，称作栈顶，另一端就叫栈底。在栈里，新元素都靠近栈顶，旧元素都接近栈底。 –《学习javaScript数据结构与算法》 ** /*栈 * push 添加新元素到栈顶 * pop 移除栈顶元素，同时返回被移除的元素 * peek 返回栈顶元素 * isEmpty 是否为空栈 ...
数据结构与算法（总结）
weixin_45397053的博客
04-23 5万+
总结： 一、数据结构（Data Structure） 是数据的组织结构，用来组织、存储数据。算法（Algorithm） 就是解决问题的方法或者过程。 二、数据结构分为逻辑结构和物理结构。逻辑结构分为集合结构、线性结构、树形结构、图形结构；物理结构分为顺序存储结构、链式存储结构。 三、算法是一系列运算步骤。算法有5个基本特性，输入、输出、有穷性、确定性、可行性；算法最求5个目标，正确性、可读性、健壮性、运行时间少、内存空间小。 四、「数组」 是实现线性表的顺序结构存储的基础；「链表」 是实现线性表的链式存储结
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
数据结构与算法.docx
12-15
数据结构与算法是计算机科学的核心组成部分，它们是解决问题和优化程序性能的基础。本文将深入探讨数据结构和算法的基础知识，以及它们在实际编程中的应用。 首先，数据结构是组织、管理和存储数据的方式，目的是...
36. Adam 算法详解
qq_41238579的博客
07-10 955
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
函数模板与类模板
程序员_小兵
07-12 1542
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 674
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
【排序 - 堆排序】
2302_80393814的博客
07-10 539
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
最新发布
hanmo22357的博客
07-12 779
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
头歌数据结构与算法栈
09-13
栈是一种常见的数据结构，它遵循先进后出（Last-In-First-Out，简称LIFO）的原则。在栈中，元素只能从栈顶进行插入和删除操作。 栈的主要操作包括： - Push：将元素压入栈顶。 - Pop：将栈顶元素弹出，并返回该元素。 - Top：获取栈顶元素，但不对其进行删除操作。 - IsEmpty：判断栈是否为空。 - Size：返回栈中元素的个数。 栈可以用于解决很多实际问题，比如函数调用、括号匹配、表达式求值等。在算法实现中，栈经常用于辅助数据结构，比如深度优先搜索（DFS）、回溯算法等。 关于算法，算法是一组解决问题的步骤或方法。数据结构与算法是紧密相关的，数据结构提供了存储和组织数据的方式，而算法则定义了对这些数据进行操作的步骤。在学习和应用算法时，数据结构的选择和使用是非常重要的。栈作为一种基础数据结构，在算法设计中有着广泛的应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值