1 栈（Stack）
- 栈是一个先入后出（FILO）的有序列表
- 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除一端，为变化的一端，成为栈顶（Top），另一端为固定的一端，称为栈底（Bottom）。
- 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
栈的应用场景
- 1 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完再将地址取出，回到原来的程序中
- 2 处理递归调用：和子程序调用类似，只是出了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中
- 3 表达式的转换与求值（实际解决）
- 4 二叉树的遍历
- 5 图形的深度优先（depth-first）搜索法
1.1 数组模拟栈
思路
- 1.使用数组模拟栈
- 2.定义top表示栈顶，初始化为-1
- 3.入栈的操作，当有数据入栈时，top++;stack[top]=data;
- 4.出栈的操作，int value = stack[top];top--;return value;
代码实现
/**
* @author DSH
* @date 2020/4/11
* @description 数组模拟栈
*/
public class ArrayStackDemo {
public static void main(String[] args) {
ArrayStack arrayStack = new ArrayStack(8);
String key = "";
boolean loop = true;//控制是否退出菜单
// arrayStack.list();
// arrayStack.pop();
Scanner scanner = new Scanner(System.in);
while (loop) {
System.out.println("show:表示显示栈");
System.out.println("push:添加数据到栈");
System.out.println("pop:表示从栈中取出数据");
System.out.println("exit:退出程序");
System.out.println("请输入你的选择");
key = scanner.next();
switch (key) {
case "show":
arrayStack.list();
break;
case "push":
System.out.println("请输入一个数");
int value = scanner.nextInt();
arrayStack.push(value);
break;
case "pop":
try {
int res = arrayStack.pop();
System.out.printf("出栈的数据是%d\n", res);
} catch (Exception e) {
e.printStackTrace();
}
break;
case "exit":
scanner.close();
loop = false;
break;
}
}
System.out.println("程序退出了");
}
}
//定义一个类 表示栈结构
class ArrayStack{
private int maxSize; //栈的大小
private int[] stack; //数组模拟栈，数据放在该数组
private int top = -1;//top表示栈顶
public ArrayStack(int maxSize){
this.maxSize = maxSize;
stack = new int[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]);
}
}
}
1.2 单链表模拟栈
/**
* @author DSH
* @date 2020/4/11
* @description 单链表实现栈结构
*/
public class SingleLinkedListStackDemo {
public static void main(String[] args) {
SingleLinkedListStack arrayStack = new SingleLinkedListStack(5);
String key = "";
boolean loop = true;//控制是否退出菜单
Scanner scanner = new Scanner(System.in);
while (loop) {
System.out.println("show:表示显示栈");
System.out.println("push:添加数据到栈");
System.out.println("pop:表示从栈中取出数据");
System.out.println("exit:退出程序");
System.out.println("请输入你的选择");
key = scanner.next();
switch (key) {
case "show":
arrayStack.list();
break;
case "push":
System.out.println("请输入一个数");
int value = scanner.nextInt();
Node node = new Node(value);
arrayStack.push(node);
break;
case "pop":
try {
int res = arrayStack.pop();
System.out.printf("出栈的数据是%d\n", res);
} catch (Exception e) {
e.printStackTrace();
}
break;
case "exit":
scanner.close();
loop = false;
break;
}
}
System.out.println("程序退出了");
}
}
class SingleLinkedListStack{
//栈的最大容量
private int maxSize ;
// 先初始化一个头结点，头结点不动
private Node head = new Node(0);
//定义一个节点，代表栈顶所指节点
private Node top = null;
// 创建一个获取头结点的方法
public Node getHead() {
return head;
}
public SingleLinkedListStack(int size){
this.maxSize = size;
}
public void push(Node node){
if (getLength(head)>=maxSize){
System.out.println("栈空间已满");
return;
}
//因为head节点不能动，因此我们需要一个辅助指针temp
Node temp = head;
//遍历链表，找到最后
while (true){
if (temp.next==null){//找到了，跳出循环
break;
}
//如果没有找到，就将temp后移
temp = temp.next;
}
//当退出while循环时，temp就指向了链表的最后
temp.next = node;
top = node;
}
public int pop(){
boolean flag = false;//标记是否找到待删除节点
Node temp = head;
//找到弹出节点的上一个节点temp
// 若找到了，原来temp.next = top，令temp.next = null，同时令top = temp
while (true){
if (temp.next==null){
System.out.println("单链表栈为空");
break;
}
//找到要pop节点的上一个节点
if(temp.next==top){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
int val = temp.next.value;//其实就是top
temp.next = null;
top = temp;
return val;
}else {
throw new RuntimeException("弹不出来了");
}
}
//显示链表（遍历）
public void list(){
if (head.next == null){
System.out.println("链表为空");
return;
}
//因为头节点不能动，所以需要一个辅助变量来遍历
Node temp = head.next;
while (true){
//判断是否为空
if (temp == null){
break;
}
System.out.println(temp.value);
//将temp后移
temp = temp.next;
}
}
public static int getLength(Node head){
if (head.next == null){//空链表
return 0;
}
int length = 0;
//辅助变量，不统计头节点
Node cur = head.next;
while (cur!=null){
length++;
cur = cur.next;
}
return length;
}
}
//先创建一个节点类Node
class Node {
public int value;//存储的数据
public Node next;//下一个节点
//构造器
public Node(int value) {
this.value = value;
}
}
1.3 使用栈实现一个综合计算器(中缀表达式)
722-5+1-5+3-4
- ①通过一个index值（索引），来遍历我们的表达式
- ②如果我们发现是一个数字，就直接入数栈
- ③如果发现扫描到是一个符号，就分如下情况
- 如果发现当前的符号栈为空，就直接入栈
- 如果符号栈有操作符，就进行比较，
- 如果当前操作符的优先级小于或者等于栈中（栈顶）的操作符，就需要从数栈中pop出两个数，再从符号栈中pop出一个符号，进行运算，将得到的结果入数栈，然后将当前的操作符入符号栈；
- 如果当前的操作符的优先级大于栈中（栈顶）的操作符，就直接入符号栈
- ④当表达式扫描完毕，就顺序的从数栈和符号栈中pop出响应的数和符号，并运行
- ⑤最后在数栈中只有一个数字，就是表达式的结果
验证：3+2x6-2 的结果
①3入栈数栈 +入栈符号栈；
②2入栈数栈，*入栈符号栈；6入栈；数栈
③2pop，6pop，* pop，2x6=12，12入栈；
④-入栈符号栈，2入数栈
⑤ pop 2 ，pop 12 ，12-2=10；
⑥pop10，pop3，10+3= 13；
⑦栈顶元素13即为计算结果
代码实现
/**
* @author DSH
* @date 2020/4/13
* @description 栈实现综合计算器
*/
public class Calculator {
public static void main(String[] args) {
//完成表达式的运算
// String expression = "30+2*6-2";
String expression = "7*2*2-5+1-5+3-4";
//创建数栈和符号栈
ArrayStack2 numStack = new ArrayStack2(10);
ArrayStack2 operStack = new ArrayStack2(10);
//定义需要的相关变量
int index = 0;
int num1 = 0;
int num2 = 0;
int oper = 0;
int res = 0;
char ch = ' ';//将每次扫描得到的char保存到ch
String keepNum = "";//用于拼接多位数
//开始while扫描expression
while (true){
//一次得到expression的每一个字符
ch = expression.substring(index,index+1).charAt(0);
//判断ch是符号还是数字
if (operStack.isOper(ch)){//如果是运算符
//判断当前的符号栈是否为空
if (!operStack.isEmpty()){
//如果符号栈有操作符，就进行比较，
//- 如果当前操作符的优先级小于或者等于栈中（栈顶）的操作符，就需要从数栈中pop出两个数，再从符号栈中pop出一个符号，进行运算，将得到的结果入数栈，然后将当前的操作符入符号栈；
//- 如果当前的操作符的优先级大于栈中（栈顶）的操作符，就直接入符号栈
if (operStack.priority(ch)<=operStack.priority(operStack.peak())){
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1,num2,oper);
//计算结果入数栈
numStack.push(res);
//然后将当前的操作符入栈
operStack.push(ch);
}else {
operStack.push(ch);
}
}else {
//如果为空直接入符号栈
operStack.push(ch);
}
}else {//如果是数，直接入数栈
// numStack.push(ch-48);//根据ASCII码表 char 和 int的关系
//1 当处理多位数时，不能发现是一个数就立即数栈，因为其可能是多位数
//2 在处理数，需要向expression的表达式的index后再看一位，如果是数，就继续扫描，如果是符号，才入栈
//3.所以需要定义一个字符串变量，用于拼接
//处理多位数
keepNum += ch;
//如果ch已经是expression的最后一位，就直接入栈
if (index == expression.length()-1){
numStack.push(Integer.parseInt(keepNum));
}else {
//判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
//向后看
if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
//如果后一位是运算符，则入栈
numStack.push(Integer.parseInt(keepNum));
//清空keepNum
keepNum = "";
}
}
}
//index +1 ，并判断是否扫描到expression的最后
index++;
if (index>=expression.length()){
break;//扫描结束
}
}
//当表达式扫描完毕，就顺序的从数栈和符号栈中pop出响应的数和符号，并运行
//最后在数栈中只有一个数字，就是表达式的结果
while (true){
//如果符号栈为空，则计算到最后结果，数栈中只有一个数字（结果）
if (operStack.isEmpty()){
break;
}
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1,num2,oper);
numStack.push(res);//入栈
}
int res2 = numStack.pop();
System.out.printf("表达式 %s = %d",expression,res2);
}
}
//定义一个类 表示栈结构
class ArrayStack2 {
private int maxSize; //栈的大小
private int[] stack; //数组模拟栈，数据放在该数组
private int top = -1;//top表示栈顶
public ArrayStack2(int maxSize) {
this.maxSize = maxSize;
stack = new int[maxSize];
}
//返回当前栈顶元素的值，不是真正的出栈
public int peak(){
return stack[top];
}
//栈满
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]);
}
}
//返回运算符的优先级，优先级是程序员来确定，优先级使用数字表示
//数字越大，优先级就越高
public int priority(int oper){
if (oper =='*'||oper=='/'){
return 1;
}else if (oper=='+'||oper=='-'){
return 0;
}else {
return -1;//假定目前的表达式只有+-*/
}
}
//判断是不是一个运算符
public boolean isOper(char val){
return val =='+'||val =='-'||val =='*'||val =='/';
}
public int cal(int num1,int num2,int oper){
int res = 0;//用于存放计算结果
switch (oper){
case '+':
res = num1+num2;
break;
case '-':
res = num2-num1;
break;
case '*':
res = num1*num2;
break;
case '/':
res = num2/num1;
break;
default:
break;
}
return res;
}
}
1.4前缀、中缀、后缀表达式（逆波兰表达式）
运算(3+4)x5-6
- 前缀表达式：-x+3456
- 中缀表达式：(3+4)x5-6
- 后缀表达式：3 4 + 5 x 6 -
前缀表达式
前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前
举例说明：(3+4)x5-6 对应的表达式就是-x+3456
中缀表达式
- 常见的运算表达式
- 中缀表达式的求值对于计算机来说不好操作，因此，在计算结果时，往往会将中缀表达式转成其他表达式来操作（一般转成后缀表达式）
后缀表达式
1.5 逆波兰计算器实现（后缀表达式）
要求
- 1） 输入一个逆波兰表达式，使用栈（Stack），计算其结果
- 2） 支持小括号和多位整数（不支持小数）
- 3） 思路分析
- 4） 代码实现
运算
- 1） 从左至右扫描，将3和4压入堆栈
- 2） 遇到+运算符，因此弹出3和4（4为栈顶元素，3位次顶元素），计算出3+4的值，为7，将7入栈
- 3） 将5入栈
- 4） 接下来是x运算符，因此弹出5和7 计算出7x5 = 35，将35入栈
- 5） 将6入栈
- 6） 遇到-运算符，计算出35-6的值，即为29，由此得出计算结果
代码实现
/**
* @author DSH
* @date 2020/4/14
* @description 逆波兰计算器实现
*/
public class PolandNotation {
public static void main(String[] args) {
//定义一个逆波兰表达式
//（3+4）x5-6 => 3 4 + 5 x 6 -
// 4x5-8+60+8/2 => 4 5 x 8 - 60 + 8 2 / +
//为了方便分割字符串，用空格隔开
// String suffixExpression = "3 4 + 5 x 6 -";
String suffixExpression = "4 5 x 8 - 60 + 8 2 / +";
//思路
//1 先将suffixExpression放到ArrayList中
//2 将ArrayList传递给一个方法，遍历ArrayList配合栈完成计算
List<String> rpnList = getListString(suffixExpression);
int res = calculate(rpnList);
System.out.printf("计算表达式%s的结果是%d",suffixExpression,res);
}
//将一个逆波兰表达式，依次将数据和运算符放入到arrayList中
public static List<String> getListString(String suffixExpression){
String[] slist =suffixExpression.split(" ");
List<String> list = new ArrayList<>();
for (String ele : slist){
list.add(ele);
}
return list;
}
//完成对逆波兰表达式的计算
/**
* 1 从左至右扫描，将3和4压入堆栈
* 2 遇到+运算符，因此弹出3和4（4为栈顶元素，3位次顶元素），计算出3+4的值，为7，将7入栈
* 3 将5入栈
* 4 接下来是x运算符，因此弹出5和7 计算出7x5 = 35，将35入栈
* 5 将6入栈
* 6 遇到-运算符，计算出35-6的值，即为29，由此得出计算结果
*/
public static int calculate(List<String> ls){
Stack<String> stack = new Stack<>();
for (String s:ls){
//使用正则表达式来取数
if (s.matches("\\d+")){//匹配的是多位数
stack.push(s);
}else {//运算符
//pop出两个数并运算，再入栈
int num1 = Integer.parseInt(stack.pop());
int num2 = Integer.parseInt(stack.pop());
int res = cal(num1,num2,s);
stack.push(res+"");
}
}
//最后留在stack中的数据就是运算结果
return Integer.parseInt(stack.pop());
}
public static int cal(int num1,int num2,String oper){
int res = 0;//用于存放计算结果
switch (oper){
case "+":
res = num1+num2;
break;
case "-":
res = num2-num1;
break;
case "x":
res = num1*num2;
break;
case "/":
res = num2/num1;
break;
default:
throw new RuntimeException("运算符有误");
}
return res;
}
}
1.5 后缀表达式转中缀表达式
后缀表达式适合计算机进行计算，但是人却不容易写出来，尤其是表达式很长的情况下，因此在开发中，需要将中缀表达式转成后缀表达式
具体步骤如下：
- 1）初始化两个栈，运算符栈s1和存储中间结果的栈s2
- 2）从左到右扫描中缀表达式
- 3）遇到操作数时，将其压入s2
- 4）遇到运算符时，比较其余s1栈顶运算符的优先级：
- ①如果s1为空，或栈顶运算符为左括号“（”,则直接将此运算符入栈
- ②否则，若优先级比栈顶运算符的高，也将运算符压入s1；
- ③否则，将s1栈顶的运算符弹出并压入到s2中，再次转到（4-1）与s1中新的栈顶运算符相比较
- 5）遇到括号时：
- ①如果是左括号“（” ，则直接压入s1
- ②如果是右括号“）”，则依次弹出s1栈顶的运算符，并压入s2，知道遇到左括号为止，此时将这一对括号丢弃
- 6）重复步骤2-5，直到表达式的最右边
- 7）将s1中剩余的运算符依次弹出并压入s2
- 8）依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
中缀表达式1+((2+3)x4)-5 =>后缀表达式1 2 3 + 4 x + 5 -
代码实现
/**
* @author DSH
* @date 2020/4/14
* @description 中缀表达式转后缀表达式
*/
public class PolandNotation2 {
public static void main(String[] args) {
//完成将一个中缀表达式转后缀表达式的功能
//说明
//1. 中缀表达式1+((2+3)x4)-5 =>后缀表达式1 2 3 + 4 x + 5 -
//2. 由于直接对字符串操作不方便，因此先将1+((2+3)x4)-5 转成中缀表达式对应的list
//即 1+((2+3)x4)-5 =》[1,+,(,(,2,+,3,),x,4,),-,5]
//3. 将得到的中缀表达式对应的list转换为后缀表达式对应的list
// 即 [1,+,(,(,2,+,3,),x,4,),-,5] => [1,2,3,+,4,x,+,5,-]
String expression = "1+((2+3)x4)-5";
List<String> infixExpressionList = toInfixExpressionList(expression);
System.out.println("中缀表达式对应的list="+infixExpressionList);//[1, +, (, (, 2, +, 3, ), x, 4, ), -, 5]
List<String> parseSuffixExpressionList = parseSuffixExpressionList(infixExpressionList);
System.out.println("后缀表达式对应的list="+parseSuffixExpressionList);//[1, 2, 3, +, 4, x, +, 5, -]
int result = calculate(parseSuffixExpressionList);
System.out.printf("计算表达式%s的结果是%d",expression,result);
}
//--------------------完整逆波兰计算器步骤 start--------------------
//第一步 .将中缀表达式转成对应的list
public static List<String> toInfixExpressionList(String s){
//定义一个List，存放中缀表达式对应的内容
List<String> ls = new ArrayList<>();
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++;
}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
// 即 [1,+,(,(,2,+,3,),x,4,),-,5] => [1,2,3,+,4,x,+,5,-]
public static List<String> parseSuffixExpressionList(List<String> ls){
//定义两个栈
Stack<String> s1 = new Stack<>();//符号栈
//因为s2 在整个转换过程中，没有pop的操作，而且后面还要逆序输出，较为麻烦，所以这里直接使用List<String> s2替代
List<String> s2 = new ArrayList<>();//存储中间结果的栈，可以用ArrayList
//遍历ls
for (String item : ls){
if (item.matches("\\d+")){
//数字 加入s2
s2.add(item);
}else if (item.endsWith("(")){
//左括号，压入符号栈
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
}
//第三步 完成对逆波兰表达式的计算
public static int calculate(List<String> ls){
Stack<String> stack = new Stack<>();
for (String s:ls){
//使用正则表达式来取数
if (s.matches("\\d+")){//匹配的是多位数
stack.push(s);
}else {//运算符
//pop出两个数并运算，再入栈
int num1 = Integer.parseInt(stack.pop());
int num2 = Integer.parseInt(stack.pop());
int res = cal(num1,num2,s);
stack.push(res+"");
}
}
//最后留在stack中的数据就是运算结果
return Integer.parseInt(stack.pop());
}
public static int cal(int num1,int num2,String oper){
int res = 0;//用于存放计算结果
switch (oper){
case "+":
res = num1+num2;
break;
case "-":
res = num2-num1;
break;
case "x":
res = num1*num2;
break;
case "/":
res = num2/num1;
break;
default:
throw new RuntimeException("运算符有误");
}
return res;
}
//--------------------完整逆波兰计算器步骤 end--------------------
}
//返回一个运算符对应的优先级
class Operation{
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 = ADD;
break;
case "-":
result = SUB;
break;
case "x":
result = MUL;
break;
case "/":
result = DIV;
break;
default:
System.out.println("不存在该运算符");
break;
}
return result;
}
}
