3.栈

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等都是中缀表示法。对于人们来说，也是最直观的一种求值方式，先算括号里的，然后算乘除，最后算加减。但是，计算机处理中缀表达式却并不方便。而逆波兰表达式在编译技术中有着普遍的应用，因此在开发中，我们一般需要将中缀表达式转成后缀表达式。

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

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

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

遇到操作数时，直接将其压入 s2；

遇到运算符时，比较其与 s1 栈顶运算符的优先级：
① 如果 s1 栈空，则直接将此运算符入栈；
② 若优先级比栈顶运算符的高，也将运算符压入 s1；
③ 否则，将 s1 栈顶的运算符弹出并压入到 s2 中，并再与 s1 中新的栈顶运算符相比较，直到运算符优先级小于栈顶元素优先级后，操作符再入栈；

操作符是 ( 则无条件入栈s1；

操作符为 )，则将s1依次出栈后入栈到s2，直到匹配到第一个(为止，此操作符直接舍弃，(直接出栈舍弃；

将 s1 中剩余的运算符依次弹出并压入 s2；

依次弹出 s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式。

对于上述算法过程，示例演示将中缀表达式1+((2+3)*4)-5转换为后缀表达式的过程如下：

因此结果为 :1 2 3 + 4 × + 5 –。

代码实现(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)搜索法。

1.栈的一个实际需求

2.栈的介绍

3.栈的实现

4.栈实现综合计算器

5.栈的其他应用场景：

vue项目获取富文本编辑器wangEditor内容导出为word（html转word格式并下载）

dotnet C# 创建 X11 应用时设置窗口背景颜色

Navicat安装与激活教程

TDengine docker安装方法

vue3组件通信与props

sapui5

Alpine Linux apk add DNS lookup error

部分JDK版本的发布时间

工作中用到的脚本合集

合并代码时Beyond Compare设置

10.樹結構的基礎

11.樹結構的應用

5.遞歸

7.排序算法

6.算法的複雜度

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結