Java数据结构（五）——栈

栈(Stack)

实际需求

计算722-5+1-5+3-3

对于计算机而言，其接收到的就是一个字符串

计算机底层如何计算获得结果？

栈的介绍

• 栈是一个先入后出的有序列表

• 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶，另一端为固定的一端，称为栈底。

• 最先放入的元素在栈底，最后放入的元素在栈顶

• 删除元素从栈顶开始删除

栈的应用场景

1. 子程序调用：在跳往子程序前，会将下个指令的地址存在堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。return

2. 处理递归调用：和子程序调用类似，只是除了存储下个指令地址外，也将参数、区域变量等数据存入堆栈中

3. 表达式的转换与求值（中缀表达式转后缀表达式）

4. 二叉树遍历

5. 图的深度优先（depth-first）搜索法

用数组模拟栈，并实现其功能

思路分析

1. 使用数组模拟栈

2. 定义top变量，表示栈顶，初始化：top = -1

3. 入栈：当有数据加入到栈时top++；stack[top] = data;

4. 出栈：value = stack[top];top--;return value

5. 遍历栈：从栈顶开始显示

代码实现

/**
 * 表示栈
 */
class StackModel{
    private int maxSize;//栈的最大容量
    private int top = -1;//栈顶
    private int[] stack;//数组模拟栈
?
    public StackModel(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[maxSize];
    }
?
    /**
     * 栈满
     * @return
     */
    public boolean isFull(){
        return top == maxSize-1;
    }
?
    /**
     * 栈空
     * @return
     */
    public boolean isEmpty(){
        return top == -1;
    }
?
    /**
     * 入栈
     * @param data
     */
    public void push(int data){
       if (isFull()){
           System.out.println("栈满");
           return;
       }
       top++;
       stack[top] = data;
    }
?
    /**
     * 出栈
     * @return
     */
    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 StackModel() {
    }
?
    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;
    }
?
    @Override
    public String toString() {
        return "StackModel{" +
                "maxSize=" + maxSize +
                ", top=" + top +
                ", stack=" + Arrays.toString(stack) +
                ‘}‘;
    }
}

用链表实现栈

class LinkStack{
    private StackNode first;
    private int top = -1;
    private int maxSize;
?
    public LinkStack(int maxSize) {
        this.maxSize = maxSize;
        first = new StackNode();
    }
?
    /**
     * 判满
     * @return
     */
   public boolean isFull(){
       return top == maxSize - 1;
   }
?
    /**
     * 判空
     * @return
     */
   public boolean isEmpty() {
       return top == -1;
   }
?
    /**
     * 压栈
     * @param data
     */
   public void push(int data){
       if (isFull()){
           System.out.println("栈满");
           return;
       }
       top++;
       StackNode temp = first;
       temp.setData(data);
       temp = temp.getNext();
   }
?
   public int pop(){
       if (isEmpty()){
           throw new RuntimeException("栈空");
       }
       StackNode temp = first;
       while (temp.getNext() != null){
           temp = temp.getNext();
       }
       int value = temp.getData();
       temp = temp.getPre();
       top--;
       return value;
   }
    /**
     * 显示栈
     */
   public void list(){
       if (isEmpty()){
           System.out.println("栈空");
           return;
       }
       StackNode temp = first;
       while (temp.getNext() != null){
           temp = temp.getNext();
       }
       for (int i = top; i >=0 ; i--) {
           System.out.println(i+"-"+temp.getData());
           temp = temp.getPre();
       }
   }
}
?
class StackNode{
    private int data;
    private StackNode next;
    private StackNode pre;
?
    public StackNode(int data) {
        this.data = data;
    }
?
    public StackNode() {
    }
?
    public int getData() {
        return data;
    }
?
    public void setData(int data) {
        this.data = data;
    }
?
    public StackNode getNext() {
        return next;
    }
?
    public void setNext(StackNode next) {
        this.next = next;
    }
?
    public StackNode getPre() {
        return pre;
    }
?
    public void setPre(StackNode pre) {
        this.pre = pre;
    }
?
    @Override
    public String toString() {
        return "StackNode{" +
                "data=" + data +
                ‘}‘;
    }
}

栈实现综合计算器

思路

1. 设计两个栈，数栈（numStack，存放数据）和符号栈（operStack，存放运算符）

2. 通过index索引，遍历计算的表达式

3. 若index得到一个数字，直接放入数栈，若得到符符号，分如下两种情况：

   • 3.1 若当前符号栈为空，直接入栈

   • 3.2 若符号栈不为空，就进行比较。

     • 3.2.1 如果当前的操作符的优先级小于或等于栈中的操作符，就需要从数栈中pop出两个数，再从符号栈中pop出一个符号，进行运算，将得到的结果入数栈，把当前的操作符入符号栈

     • 如果当前操作符优先级大于栈中的操作符，直接入符号栈

4. 扫描完毕后，就顺序的从数栈和符号栈pop出相应的书和符号并运算

5. 最后在数栈中只有一个数据，即为表达式结果

前缀、中缀和后缀表达式

前缀表达式（波兰表达式）

• 运算符位于操作数之前

• 如：（3+4）* 5 - 6对应的前缀表达式 - * + 3 4 5 6

• 求值流程：

  1. 从右向左扫描表达式

  2. 遇到数字，将数字压到堆栈，遇到运算符，弹出栈顶两个数，进行运算

  3. 结果入栈

  4. 重复上述操作，直到扫描完毕

中缀表达式

即为常见的表达式，3+4-5

后缀表达式（逆波兰表达式）

• 运算符位于操作数之和

• 如：（3+4）* 5 - 6，对应的表达式 3 4 + 5 * 6 -

• 求值流程

  1. 从左至右扫描

  2. 遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个元素进行计算

  3. 结果入栈

  4. 重复上述过程，直至表达式结束

中缀表达式转后缀表达式

• 初始化两个栈：运算符栈s1和存储中间结果的栈s2

• 从左至右扫描中缀表达式

• 遇到操作时时，压入s2

• 遇到运算符时，比较与s1栈顶运算符的优先级

  1. 若s1为空，或栈顶运算符为左括号“（”，则直接将此运算符入栈

  2. 若优先级比栈顶运算符高，也将其压入s1

  3. 否则s1栈顶运算符出栈，并压入s2中，再次与新的栈顶运算符做比较

Java数据结构（五）——栈

原文：https://www.cnblogs.com/whystudyjava/p/14043288.html