栈的数组和链表实现及应用

最新推荐文章于 2022-06-11 23:33:57 发布
最新推荐文章于 2022-06-11 23:33:57 发布
阅读量149 收藏
点赞数 1
分类专栏： 老韩数据结构与算法笔记 文章标签： 栈 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc1954607060/article/details/115966170
版权

栈

https://blog.csdn.net/oneby1314/article/details/107843972

1、栈的基本介绍

1.1、栈的实际需求

请计算表达式：[722-5+1-5+3-3] 的值
请问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算，因为我们看这个算式 7 * 2 * 2 - 5，但是计算机怎么理解这个算式的
对计算机而言， 它接收到的就是一个字符串， 我们讨论的是这个问题：栈

img

1.2、栈的基本性质

  • 栈的英文为(stack)
  • 栈是一个先入后出(FILO-First In Last Out)的有序列表
  • 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。 允许插入和删除的一端， 为变化的一端， 称为栈顶(Top)， 另一端为固定的一端， 称为栈底(Bottom)。
  • 根据栈的定义可知， 最先放入栈中元素在栈底， 最后放入的元素在栈顶， 而删除元素刚好相反， 最后放入的元素最先删除， 最先放入的元素最后删除
  • 图解方式说明出栈(pop)和入栈(push)的概念

img

1.3、栈的应用场景

  • 子程序的调用： 在跳往子程序前， 会先将下个指令的地址存到堆栈中， 直到子程序执行完后再将地址取出， 以回到原来的程序中。
  • 处理递归调用： 和子程序的调用类似， 只是除了储存下一个指令的地址外， 也将参数、 区域变量等数据存入栈中。
  • 表达式的转换：[中缀表达式转后缀表达式]与求值(实际解决)。
  • 二叉树的遍历。
  • 图形的深度优先(depth 一 first)搜索法。

2、数组模拟栈

2.1、代码思路及步骤

  • maxSize ：栈的大小（数组的大小）
  • arr ：用来模拟栈的数组
  • top ：指向当前栈顶元素，初始值为 -1 ，表示栈空
  • 判断栈满：top == maxSize ，即已经到达数组最后一个位置
  • 判断栈空：top == -1
  • 入栈：arr[++top] = arr;
  • 出栈：return arr[top–] ;

img

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("pop,表示出栈");
            System.out.println("push,表示入栈");
            System.out.println("exit,表示退出程序");
            System.out.println("请输入你的选择：");

            key=scanner.next();
            switch (key){
                case "show":
                    arrayStack.show();

                    break;

                case "pop":

                    try {
                        int value=arrayStack.pop();
                        System.out.println("出栈的值为 "+value);

                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }

                    break;


                case "push":
                    System.out.println("输入值");
                    int value=scanner.nextInt();
                    arrayStack.push(value);

                    break;

                case "exit":
                    loop=false;
                    System.out.println("退出程序");
            }
        }



    }
}

class ArrayStack {
    private int maxSize;
    private int top=-1;
    private int[] stack;

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


    public int getMaxSize() {
        return maxSize;
    }

    public void setMaxSize(int maxSize) {
        this.maxSize = maxSize;
    }

    public int getTop() {
        return top;
    }

    public void setTop(int top) {
        this.top = top;
    }

    public int[] getStack() {
        return stack;
    }

    public void setStack(int[] stack) {
        this.stack = stack;
    }


    public boolean isFull(){

        return top == maxSize - 1;
    }

    public boolean isEmpty(){

        return  top == -1;
    }

    public void push(int value){
        if (isFull()){
            System.out.println("栈已满，无法添加");
            return;
        }

        stack[++top]=value;

    }

    public int pop(){

        if (isEmpty()) {
            throw new RuntimeException("栈为空，没有数据");
        }

        int value=stack[top--];

        return value;
    }
    
    public void show(){
        if (isEmpty()) {
            System.out.println("栈空，没有数据~~");
            return;
        }
        // 需要从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }

    }
}

3、单链表模拟栈（头插法）

3.1、创建链表节点

  • 一个数据域
  • 一个指向下一节点
class Link{
    private int val;
    private Link next;


    public Link(int val) {
        this.val = val;
    
    }
    
    public int getval() {
        return val;
    }
    
    public void setval(int val) {
        this.val = val;
    }
    
    public Link getNext() {
        return next;
    }
    
    public void setNext(Link next) {
        this.next = next;
    }
    
    @Override
    public String toString() {
        return "Link{" +
                "val=" + val +
                '}';
    }

}

3.2、创建链表管理类

  • 获得栈的实际长度的，注意不要将头节点算入
  • 判断是否满、是否为空
  • 入栈：采用头插法，注意将头节点和插入的值接上，否则链表直接断掉。还没所有操作都不能进行
  • 出栈
  • 遍历，同样注意不要将头节点算入
class LinkStack{
    private int maxsize;
    private Link top = new Link(-1);

    public Link getTop(){
        return top;
    }


    public LinkStack(int maxsize) {
        this.maxsize = maxsize;
    }

    //获得链表有效长度
    public int getSize(Link top) {
        int size = 0;

        Link temp = top;

        while (true) {
            if (temp.getNext() == null) {
                break;

            }
            temp = temp.getNext();
            size++;

        }
        return size;
    }


    public boolean isEmpty(){

        return getSize(top)==0;
    }
    public boolean isFull(){

        return getSize(top)==maxsize;

    }

        //头插法
    public void push(Link num){
        if (isFull()) {
            System.out.println("栈已满，无法入栈");
            return;
        }

        num.setNext(top.getNext());

        top.setNext(num);//接上头节点

    }


    public int pop() {

        if (isEmpty()){
            throw new RuntimeException("栈为空");
        }

        Link temp = top.getNext();
        top.setNext(temp.getNext());
        return temp.getval();
    }


//不显示头节点

    public void show(){

        if (isEmpty()) {
            System.out.println("栈为空");
            return;
        }
        Link temp = top.getNext();

        while (temp!=null){
            //输出节点的信息
            System.out.println(temp);
            //将temp后移， 一定小心
            temp = temp.getNext();

        }

    }

}

3.3、测试类

public class LinkStackDemo {
    public static void main(String[] args) {
        LinkStack linkStack=new LinkStack(5);
        String key="";
        boolean loop=true;
        while (loop) {
            System.out.println("show,表示显示栈");
            System.out.println("pop,表示出栈");
            System.out.println("push,表示入栈");
            System.out.println("exit,表示退出程序");
            System.out.println("请输入你的选择：");
            Scanner scanner=new Scanner(System.in);
            key=scanner.next();
            switch (key){
                case "show":

                    linkStack.show();

                    break;

                case "pop":

                    try {
                        int value=linkStack.pop();
                        System.out.println("出栈的值为 "+value);

                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }

                    break;


                case "push":
                    System.out.println("输入值");
                    int key1=0;
                    key1=scanner.nextInt();
                    Link value=new Link(key1);
                    linkStack.push(value);
                    break;
                    
                case "exit":
                    loop=false;
                    System.out.println("退出程序");
                    break;
            }
        }
    }
}

总结

链表中头节点不能随意变动，在计算长度和遍历时不能将其算入内

同时要注意链表不能断。

4、中缀转后缀表达式

对我们来说更加熟悉中缀表达式，不过对于计算机来说，后缀表达式无需考虑优先级等问题，只需判断是数值还是运算符，进行相应操作，更加方便。

4.1、思路及步骤

  1. 初始化两个栈**：运算符栈s1和储存中间结果的数组s2**，为了方便可将s2换成数组，因为s2只需要进行入栈，最后全部入栈后逆序出栈，不方便，而将其改为数组更加便利

  2. 从左至右扫描中缀表达式；

  3. 若遇到数，直接添加的数组s2中；

  4. 遇到运算符时，比较其与s1栈顶运算符的优先级：

    1. 若运算符栈顶为空，（说明还没有运算符进来，或者说之前高优先级的运算符已经处理完成）则直接入栈；
    2. 如果当前运算符优先级比栈顶运算符的高，也将运算符添加至s2（当前运算符优先级高，先执行运算）
    3. 当前运算符优先级 <= 栈顶运算符优先级，将s1栈顶的运算符弹出并添加到s2中（operStack 栈顶运算符优先级高，先执行运算），再次转到(4.1)与s1中新的栈顶运算符相比较

  5. 遇到括号时：

    1. 如果是左括号“(”，则直接压入s1，等待与其配对的右括号，因为括号中的表达式需要优先运算
    2. 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃

  6. 重复2-5知道到中缀表达式最右边

  7. 若此时s1中还有剩余的运算符将其依次弹出，并添加到s2；

  8. 将s2数组遍历即可得到后缀表达式。

4.2、代码实现

/**
*@author Jason
*@Description 为了方便遍历，将string的表达式转换成arraylist
*@Date 20:27 2021/4/12
*@Param No such property: code for class: Script1
*@Return java.util.List<java.lang.String>
**/

    public static List<String> toInfixExpressionList(String s) {
        // 定义一个List,存放中缀表达式 对应的内容
        List<String> ls = new ArrayList<String>();
        int i = 0; // 这时是一个指针，用于遍历 中缀表达式字符串
        String str; // 对多位数的拼接
        char c; // 每遍历到一个字符，就放入到c
        do {
            // 如果c是一个非数字，我需要加入到ls
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                ls.add("" + c);
                i++; // i需要后移
            } else { // 如果是一个数，需要考虑多位数
                str = ""; // 先将str 置成"" '0'[48]->'9'[57]
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    str += c;// 拼接
                    i++;
                }
                ls.add(str);
            }
        } while (i < s.length());
        return ls;// 返回
    }
/**
*@author Jason
*@Description  中缀转后缀表达式
*@Date 17:24 2021/4/12

*@Return java.util.List<java.lang.String>
**/
    public static List<String> parseSuffixExpresionList(List<String> ls) {
        Stack<String> s1 = new Stack<String>();
        List<String> s2 = new ArrayList<String>();

        for (String item : ls) {

            if (item.matches("\\d+")) {
                s2.add(item);

            } else if (item.equals("(")) {
                s1.push(item);
            } else if (item.equals(")")) {

                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();
            }

            else {
                while(s1.size()!=0&&Operation.getValue(s1.peek())>=Operation.getValue(item)){
                    s2.add(s1.pop());
                }

                s1.push(item);

            }
        }
        while (s1.size()!=0){
            s2.add(s1.pop());
        }
        return s2;
    }


    public static List<String> getListString(String suffixExpression) {

        String[] split = suffixExpression.split(" ");

        List<String> list = new ArrayList<String>();
        for(String ele: split) {
            list.add(ele);
        }
        return list;
        
        
/** 
*@author Jason
*@Description 定义并返回运算符优先级，方便比较
*@Date 17:15 2021/4/21
*@Param 
*@Return 
**/

class Operation {
    private static int LEFT_BRACKET  = 0;
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    public static int getValue(String operation) {
        int result = 0;
        switch (operation) {
            case "(":
                result = LEFT_BRACKET;
                break;
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在该运算符" + operation);
                break;
        }
        return result;
    }
}

5、后缀（逆波兰）表达式的计算

5.1、思路及步骤

  • 计算后缀表达式无需考虑运算符优先级问题，所以只需要一个数栈即可
  • 分为两种情况：
    • 遇到数：压入数栈
    • 遇到运算符：从数栈中弹出两个数，进行计算，计算结果压入数栈

5.2、代码实现

    /**
    *@author Jason
    *@Description
     * 完成对逆波兰表达式（后缀表达式）的运算
     *
     *      - **遇到数：压入数栈**
     * - **遇到运算符：从数栈中弹出两个数，进行计算，计算结果压入数栈**
     *
    *@Date 16:16 2021/4/12
    *@Param
    *@Return int
    **/
    public static int calculate(List<String> ls) {
        // 创建给栈, 只需要一个栈即可
        Stack<String> stack = new Stack<String>();
        // 遍历 ls
        for (String item : ls) {
            // 这里使用正则表达式来取出数
            if (item.matches("\\d+")) { // 匹配的是多位数
                // 入栈
                stack.push(item);
            } else {
                // pop出两个数，并运算， 再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (item.equals("+")) {
                    res = num1 + num2;
                } else if (item.equals("-")) {
                    res = num1 - num2;
                } else if (item.equals("*")) {
                    res = num1 * num2;
                } else if (item.equals("/")) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                //把res 入栈
                stack.push("" + res);
            }
        }
        //最后留在stack中的数据是运算结果
        return Integer.parseInt(stack.pop());
    }
}
停留的时钟
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
重温四大基础数据结构：数组、链表、队列和栈
彤哥读源码
08-05 1726
前言 本文收录于专辑：http://dwz.win/HjK，点击解锁更多数据结构与算法的知识。 你好，我是彤哥，一个每天爬二十六层楼还不忘读源码的硬核男人。 数组、链表、队列、栈，是数据结构中最基础的四大结构，数组和链表更是基础中的基础，后续所有复杂的数据结构都是在它们的基础上演变而来的。 本节，我们就来重温这四大结构。 数组 关于数组，大家都比较熟悉了。 它是一种线性数据结构，使用一组连续的内存空间存储一组具有相同类型的数据。 这个概念中有三个关键词：线性、连续、相同类型。 线性，表示没有分叉，任.
栈的数组实现
04-12
NULL 博文链接：https://128kj.iteye.com/blog/1704098
数组和链表的区别以及应用场景
weixin_45151960的博客
10-26 5138
数组和链表的区别以及应用场景 首先我们要先理解什么是数组和链表 在计算机中要对给定的数据集进行若干处理，首要任务是把数据集的一部分（当数据量非常大时，可能只能一部分一部分地读取数据到内存中来处理）或全部存储到内存中，然后再对内存中的数据进行各种处理。 例如，对于数据集 S{1，2，3，4，5，6}，要求 S 中元素的和，首先要把数据存储到内存中，然后再将内存中的数据相加。 当内存空间中有足够大的...
栈的应用 数组模拟 （指针）
ACM_e的博客
08-08 831
什么是栈？
数据结构：数组、链表、栈、队列的理解
weixin_30512785的博客
04-10 782
解释定义 数据结构： 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。再简单描述一下：数据结构就是描述对象间逻辑关系的学科。 如果还是不太清楚下面会举例说明的。 数据存储结构： 简单的讲就是数据在计算机中的存储方式。 常用的数据存储方式有两种：顺序存储，非顺序存储。顺序存储就是把数据存储在一块联系的存储介质（硬盘或内存等）中。反之就是非顺序存储咯。Java中的数组就是典型的...
python利用数组和链表实现栈和队列 数组和链表.pdf
04-18
Python 实现栈和队列 栈和队列是两种常用的数据结构，在编程设计中广泛应用。...本文介绍了如何使用 Python 实现栈和队列，包括使用数组和链表两种方法。栈和队列是两种常用的数据结构，在编程设计中广泛应用。
用数组和链表实现栈.zip
03-04
本教程将深入探讨如何使用两种常见数据结构——数组和链表来实现栈。 一、数组实现栈 数组是最基础的数据结构，它提供了一种在内存中连续存储相同类型元素的方式。在数组中实现栈，我们可以将数组的最后一个元素视...
python算法-数组和链表 数组和链表.pdf
04-18
Python算法-数组和链表 Python算法中，数组和链表是两种常用的数据结构。它们都是用于存储和管理数据的，但是它们在实现和...数组和链表都是非常有用的数据结构，只有通过了解它们的特点和缺点，才能更好地应用它们。
数组和链表和集合的区别和应用场景以及堆和栈的区别 数组和链表.pdf
04-18
数组、链表和集合的区别和应用场景以及堆和栈的区别 数组和集合的区别： 1. 数组的长度是固定的，而集合的长度是动态不固定的。 2. 数组的存储类型是单一的，同一个数组只能存储同一数据类型的数据，而集合可以...
栈关于数组与链表的实现
06-06
栈的两种常见实现方式是数组和链表，各有优缺点。 数组实现的栈： 1. **优点**：数组实现的栈空间连续，访问效率高，因为内存的随机访问特性使得在栈顶进行插入和删除操作的时间复杂度为O(1)。 2. **缺点**：固定...
堆栈类设计
06-22
6、 堆栈类设计* 定义Stack类，参照实现： a) 用数组实现先进后出的数据结构 b) 栈顶指针的设置 c) 进栈操作 d) 出栈操作 e) 空栈与栈满溢出判定 f) 完成相应应用程序设计
链表-栈的应用
XZB119211的博客
06-11 131
链表-栈的应用
计算机中堆栈的应用举例,链表与栈的典型应用——简单计算机的实现
weixin_39841825的博客
06-20 269
先来看一个粗糙的简单计算器的实现。他只支持加减乘除，并且一次只能对两个小于10的正整数做一次运算点击(此处)折叠或打开#includeint char2number(char c){switch(c){case '0':return 0;case '1':return 1;case '2':return 2;case '3':return 3;case '4':return 4;case '5':...
用数组实现堆栈（含模板类）
weixin_43399489的博客
07-14 372
堆栈(Stack)是一种相同数据类型数据的集合，并且拥有后进先出的特性(last in first out，有时候简写为LIFO),所有的操作都在堆栈顶端进行。 堆栈具有5种基本操作： 创建一个空堆栈 Stack() 把数据压入堆栈 Push() 从栈顶弹出堆栈 Pop() 判断是否为空堆栈 isEmpty() 判断堆栈是否已满 isFull() 注意：int的0相当于bool的false ...
数据结构——栈(顺序表与链表)
weixin_57023347的博客
06-10 586
文章目录1.栈的定义2.栈的主要操作3.栈的代码实现1.栈的初始化：2.入栈与判断栈满3.出栈与判断栈空 1.栈的定义 栈可以看作是一个受约束的线性表，插入和删除操作都在栈顶进行。 怎么理解呢？我梦可以将栈理解成一个箱子，每次只能将一本书从箱子放入或拿出，并且每次只能在箱子顶上将书放入或拿出，如图： 简单介绍： 由上图这种特性可知，栈具有数据后入先出，先入后出的特点，通常将数据插入称为压入栈(push)，将数据取出叫做弹出栈(pop)，栈也被称为后入先出表。 栈顶指针，通常是指向栈顶的元素。用数组实现
C++使用链表实现栈
weixin_55037029的博客
07-16 1194
栈的特点： 1.压入栈时压在最上面 2.弹出栈时弹出最上面 源码： #include<iostream> using namespace std; struct Node { int data; Node* next; }; class stack { public: Node* head; int len; //结点数 public: //先实例化头节点 stack() { head = new Node; head->next = NULL; len
C++[类设计]使用数组实现顺序栈
marlboro_1999的专栏
04-21 918
//in Sequence_stack.h #pragma once #include #define DEFAULT_MAX_SIZE 150 template class Sequence_stack { private: unsigned int nMaxSize;//stack's total size,DEFAULT_MAX_SIZE is the default value un
栈的创建------用数组实现栈
Z.H.L的博客
10-23 912
设计： 1、该数组存储对象类型在实例化是才确定-----泛型 2、数组的索引0是栈底 3、创建一个正整数变量top ----是栈顶元素否后的索引号 4、创建一个栈的接口----定义如下函数： 代码实现： 接口类：StackADT  public interface StackADT &lt;T&gt; { /** * 压栈 * @param t */ pub...
栈和队列的基本实现（数组实现和链表实现）
贝西晨的博客
11-28 1432
基本知识： 队列：先进先出。场景：排队购票 栈：先进后出。 场景：邮箱对栈和队列的基本操作，通过数组和链表进行实现 import java.util.LinkedList;/** * * @author */ class Node<T> { Node next; T data; public Node() { } public Node(T data
栈结构解析：线性表与数组、链表实现
总结来说，这个教育资源深入讲解了栈结构的概念，包括其基本操作、数组和链表两种常见的实现方式，以及它们在程序设计中的应用。这对于学习计算机科学和软件工程的学生来说是非常有价值的资料。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值