【数据结构与算法】-【栈】

一、栈

1.栈的介绍

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

出栈(pop)

入栈(push)

2.栈的应用场景

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

3.数组模拟栈

实现栈的思路分析
①使用数组来模拟栈
②定义一个 top 来表示栈顶，初始化 为 -1
③入栈的操作，当有数据加入到栈时， top++; stack[top] = data;
④出栈的操作， int value = stack[top]; top–, return value

代码实现

//定义一个 ArrayStack 表示栈
class ArrayStack {
	private int maxSize; // 栈的大小
	private int[] stack; // 数组，数组模拟栈，数据就放在该数组
	private int top = -1;// top表示栈顶，初始化为-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;
	}
	//入栈-push
	public void push(int value) {
		//先判断栈是否满
		if(isFull()) {
			System.out.println("栈满");
			return;
		}
		top++;
		stack[top] = value;
	}
	//出栈-pop, 将栈顶的数据返回
	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]);
		}
	}
	
}

---

java中stack演示

import java.util.Stack;

//演示栈Stack的基本使用
public class TestStack {

	public static void main(String[] args) {
		Stack<String> stack = new Stack();
		// 入栈
		stack.add("jack");
		stack.add("tom");
		stack.add("smith");

		// 出栈
		// smith, tom , jack
		while (stack.size() > 0) {
			System.out.println(stack.pop());//pop就是将栈顶的数据取出
		}
	}

}

---

二、表达式

1.前缀表达式(波兰表达式)

前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前。
示例：
(3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6

前缀表达式的计算机求值

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

例如: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达式求值步骤如下:
①从右至左扫描，将6、5、4、3压入堆栈；
②遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得7，再将7入栈；
③接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈；
④最后是-运算符，计算出35-6的值，即29，由此得出最终结果。

2.中缀表达式

中缀表达式就是常见的运算表达式，如(3+4)×5-6，中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式.)。

3.后缀表达式

后缀表达式又称逆波兰表达式,与前缀表达式相似，只是运算符位于操作数之后。
示例：
(3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –

后缀表达式的计算机求值

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

例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:
①从左至右扫描，将3和4压入堆栈；
②遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
将5入栈；
③接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
将6入栈；
④最后是-运算符，计算出35-6的值，即29，由此得出最终结果。

4.中缀表达式转换为后缀表达式

后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将中缀表达式转成后缀表达式。

具体步骤:

①初始化两个栈：运算符栈s1和储存中间结果的栈s2；
②从左至右扫描中缀表达式；
③遇到操作数时，将其压s2；
④遇到运算符时，比较其与s1栈顶运算符的优先级：

1）如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
2）否则，若优先级比栈顶运算符的高，也将运算符压入s1；
3）否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；

⑤遇到括号时：

1) 如果是左括号“(”，则直接压入s1
2) 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃。

⑥重复步骤2至5，直到表达式的最右边；
⑦将s1中剩余的运算符依次弹出并压入s2；
⑧依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式；

图解流程

代码实现

方法：将中缀表达式转成对应的List

//  s="1+((2+3)×4)-5";
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;//返回
}

---

方法：将得到的中缀表达式对应的List => 后缀表达式对应的List

// ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
public static List<String> parseSuffixExpreesionList(List<String> ls) {
	//定义两个栈
	Stack<String> s1 = new Stack<String>(); // 符号栈
	//说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
	//因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
	//Stack<String> s2 = new Stack<String>(); // 储存中间结果的栈s2
	List<String> s2 = new ArrayList<String>(); // 储存中间结果的Lists2
	
	//遍历ls
	for(String item: ls) {
		//如果是一个数，加入s2【正则表达式  \ 转义 \d 数字 +代表一个或多个】
		if(item.matches("\\d+")) {
			s2.add(item);
		} else if (item.equals("(")) {
			s1.push(item);
		} else if (item.equals(")")) {
			//如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
			while(!s1.peek().equals("(")) {
				s2.add(s1.pop());
			}
			s1.pop();//!!! 将 ( 弹出 s1栈， 消除小括号
		} else {
			//当item的优先级小于等于s1栈顶运算符, 将s1栈顶的运算符弹出并加入到s2中，再次转到(4.1)与s1中新的栈顶运算符相比较
			//问题：我们缺少一个比较优先级高低的方法
			while(s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item) ) {
				s2.add(s1.pop());
			}
			//还需要将item压入栈
			s1.push(item);
		}
	}
	
	//将s1中剩余的运算符依次弹出并加入s2
	while(s1.size() != 0) {
		s2.add(s1.pop());
	}

	return s2; //注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
	
}

---