4.栈

4.栈
强烈推介IDEA2020.2破解激活,IntelliJ IDEA 注册码,2020.2 IDEA 激活码

目录

1.栈的一个实际需求
2.栈的介绍
3.栈的实现
4.栈实现综合计算器
5.栈的其他应用场景

1.栈的一个实际需求

在这里插入图片描述
请问计算机底层是如何运算得到结果的?计算机怎么理解这个算式的(对计算机而言,它接收到的就是一个字符串)。

2.栈的介绍

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

3.栈的实现

1.用数组模拟栈的使用,由于栈是一种有序列表,所以可以使用数组的结构来储存栈的数据内容:

package stack;

public class ArrayStack {
   
    private int maxSize;//栈的容量
    private int[] stack;//存放数据的数组
    private int top = -1;//栈顶,初始化为-1

    /** * 构造器 * @param maxSize */
    public ArrayStack(int maxSize) {
   
        this.maxSize = maxSize;
        this.stack = new int[maxSize];
    }

    /** * 入栈 * @param value */
    public void push(int value){
   
        if (isFull()){
   
            throw new RuntimeException("栈满");
        }
        top++;
        stack[top] = value;
    }

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

    /** * 从栈顶开始遍历数据 */
    public void show(){
   
        if (isEmpty()){
   
            throw new RuntimeException("栈空");
        }
        int cur = top;
        while (cur!=-1){
   
            System.out.println(stack[cur--]);
        }
    }

    public boolean isFull(){
   
        return this.top == this.maxSize - 1;
    }

    public boolean isEmpty(){
   
        return this.top == -1;
    }

    public static void main(String[] args) {
   
        ArrayStack stack = new ArrayStack(5);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.show();
        System.out.println("出栈:"+stack.pop());
        stack.show();
    }

}

2.如何使用链表来模拟栈呢?

熟悉链表操作的话应该容易想到:每次入栈,即向单向链表中添加节点时,直接添加到链表最前面,达到最后入栈的在链表中最先访问的目的。有关链表相关操作,可参考我的另一篇记录:4.链表

4.栈实现综合计算器

在实现之前,首先理解一下前缀表达式、中缀表达式、后缀表达式的概念:

1.前缀表达式又称波兰式,前缀表达式的运算符位于操作数之前。比如:- × + 3 4 5 6;
2.中缀表达式就是常见的运算表达式,如:(3+4)×5-6;
3.后缀表达式又称逆波兰表达式,与前缀表达式相似,只是运算符位于操作数之后,比如:3 4 + 5 × 6 - 。

人类最熟悉的一种表达式1+2,(1+2) ×3,3+4+5等都是中缀表示法。对于人们来说,也是最直观的一种求值方式,先算括号里的,然后算乘除,最后算加减。但是,计算机处理中缀表达式却并不方便。而逆波兰表达式在编译技术中有着普遍的应用,因此在开发中,我们一般需要将中缀表达式转成后缀表达式

中缀表达式转后缀表达式主要用到了栈进行运算符处理和排序输出:

  1. 初始化两个栈:运算符栈 s1 和储存中间结果的栈 s2;
  2. 从左至右扫描中缀表达式;
  3. 遇到操作数时,直接将其压入 s2;
  4. 遇到运算符时,比较其与 s1 栈顶运算符的优先级:
    ① 如果 s1 栈空,或栈顶运算符为左括号(,则直接将此运算符入栈;
    ② 若优先级比栈顶运算符的高,也将运算符压入 s1;
    ③ 否则,将 s1 栈顶的运算符弹出并压入到 s2 中,并再与 s1 中新的栈顶运算符相比较,直到当前运算符优先级大于栈顶元素优先级后,当前操作符再入栈s1(即满足②);
  5. 操作符是 ( 则无条件入栈s1;
  6. 操作符为 ),则将s1依次出栈后入栈到s2,直到匹配到第一个(为止,此操作符直接舍弃,(直接出栈舍弃;
  7. 将 s1 中剩余的运算符依次弹出并压入 s2;
  8. 依次弹出 s2 栈中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式。

对于上述算法过程,示例演示将中缀表达式1+((2+3)*4)-5转换为后缀表达式的过程如下:
在这里插入图片描述
因此中缀表达式:1+((2+3)*4)-5转为后缀表达式结果为 :1 2 3 + 4 × + 5 –

将中缀表达式转为后缀表达式后,我们再通过处理后缀表达式就很容易得出表达式结果了,可以以上述为例走一遍,会发现就是实际的中缀表达式的运算顺序:

1.从左至右扫描表达式;
2.遇到数字时,将数字压入堆栈;
3.遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 和 栈顶元素),并将结果入栈;
4.重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果。

代码实现(java):

package stack;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;
import java.util.regex.Pattern;

/** * 支持 + - * / ( ) * 支持多位数,支持小数, * 兼容处理, 过滤任何空白字符,包括空格、制表符、换页符 */
public class Calculator {
   

	/** * 匹配 + - * / ( ) 运算符 */
	static final String SYMBOL = "\\+|-|\\*|/|\\(|\\)";

	static final String LEFT = "(";
	static final String RIGHT = ")";
	static final String ADD = "+";
	static final String MINUS= "-";
	static final String TIMES = "*";
	static final String DIVISION = "/";

	/** * 加減 + - */
	static final int LEVEL_01 = 1;
	/** * 乘除 * / */
	static final int LEVEL_02 = 2;

	/** * 括号 */
	static final int LEVEL_HIGH = Integer.MAX_VALUE;


	static Stack<String> stack = new Stack<>();
	static List<String> data = Collections.synchronizedList(new ArrayList<String>());

	/** * 去除所有空白符 * @param s * @return */
	public static String replaceAllBlank(String s ){
   
		// \\s+ 匹配任何空白字符,包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]
		return s.replaceAll("\\s+","");
	}

	/** * 判断是不是数字 int double long float * @param s * @return */
	public static boolean isNumber(String s){
   
		Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
		return pattern.matcher(s).matches();
	}

	/** * 判断是不是运算符 * @param s * @return */
	public static boolean isSymbol(String s){
   
		return s.matches(SYMBOL);
	}

	/** * 匹配运算等级 * @param s * @return */
	public static int calcLevel(String s){
   
		if("+".equals(s) || "-".equals(s)){
   
			return LEVEL_01;
		} else if("*".equals(s) || "/".equals(s)){
   
			return LEVEL_02;
		}
		return LEVEL_HIGH;
	}

	/** * 匹配 * @param s * @throws Exception */
	public static List<String> doMatch (String s) throws Exception{
   
		if(s == null || "".equals(s.trim())) throw new RuntimeException("data is empty");
		if(!isNumber(s.charAt(0)+"")) throw new RuntimeException("data illeagle,start not with a number");

		s = replaceAllBlank(s);

		String each;
		int start = 0;

		for (int i = 0; i < s.length(); i++) {
   
			if(isSymbol(s.charAt(i)+"")){
   
				each = s.charAt(i)+"";
				//栈为空,(操作符,或者 操作符优先级大于栈顶优先级 && 操作符优先级不是( )的优先级 及是 ) 不能直接入栈
				if(stack.isEmpty() || LEFT.equals(each)
						|| ((calcLevel(each) > calcLevel(stack.peek())) && calcLevel(each) < LEVEL_HIGH)){
   
					stack.push(each);
				}else if( !stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())){
   
					//栈非空,操作符优先级小于等于栈顶优先级时出栈入列,直到栈为空,或者遇到了(,最后操作符入栈
					while (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek()) ){
   
						if(calcLevel(stack.peek()) == LEVEL_HIGH){
   
							break;
						}
						data.add(stack.pop());
					}
					stack.push(each);
				}else if(RIGHT.equals(each)){
   
					// ) 操作符,依次出栈入列直到空栈或者遇到了第一个)操作符,此时)出栈
					while (!stack.isEmpty() && LEVEL_HIGH >= calcLevel(stack.peek())){
   
						if(LEVEL_HIGH == calcLevel(stack.peek())){
   
							stack.pop();
							break;
						}
						data.add(stack.pop());
					}
				}
				start = i ;    //前一个运算符的位置
			}else if( i == s.length()-1 || isSymbol(s.charAt(i+1)+"") ){
   
				each = start == 0 ? s.substring(start,i+1) : s.substring(start+1,i+1);
				if(isNumber(each)) {
   
					data.add(each);
					continue;
				}
				throw new RuntimeException("data not match number");
			}
		}
		//如果栈里还有元素,此时元素需要依次出栈入列,可以想象栈里剩下栈顶为/,栈底为+,应该依次出栈入列,可以直接翻转整个stack 添加到队列
		Collections.reverse(stack);
		data.addAll(new ArrayList<>(stack));

		System.out.println(data);
		return data;
	}

	/** * 算出结果 * @param list * @return */
	public static Double doCalc(List<String> list){
   
		Double d = 0d;
		if(list == null || list.isEmpty()){
   
			return null;
		}
		if (list.size() == 1){
   
			System.out.println(list);
			d = Double.valueOf(list.get(0));
			return d;
		}
		ArrayList<String> list1 = new ArrayList<>();
		for (int i = 0; i < list.size(); i++) {
   
			list1.add(list.get(i));
			if(isSymbol(list.get(i))){
   
				Double d1 = doTheMath(list.get(i - 2), list.get(i - 1), list.get(i));
				list1.remove(i);
				list1.remove(i-1);
				list1.set(i-2,d1+"");
				list1.addAll(list.subList(i+1,list.size()));
				break;
			}
		}
		doCalc(list1);
		return d;
	}

	/** * 运算 * @param s1 * @param s2 * @param symbol * @return */
	public static Double doTheMath(String s1,String s2,String symbol){
   
		Double result ;
		switch (symbol){
   
			case ADD : result = Double.valueOf(s1) + Double.valueOf(s2); break;
			case MINUS : result = Double.valueOf(s1) - Double.valueOf(s2); break;
			case TIMES : result = Double.valueOf(s1) * Double.valueOf(s2); break;
			case DIVISION : result = Double.valueOf(s1) / Double.valueOf(s2); break;
			default : result = null;
		}
		return result;

	}

	public static void main(String[] args) {
   
		//String math = "9+(3-1)*3+10/2";
		String math = "12.8 + (2 - 3.55)*4+10/5.0";
		try {
   
			doCalc(doMatch(math));
		} catch (Exception e) {
   
			e.printStackTrace();
		}
	}

}

5.栈的其他应用场景:

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

本文来源MrKorbin,由架构君转载发布,观点不代表Java架构师必看的立场,转载请标明来源出处:https://javajgs.com/archives/25282

发表评论