数据结构(四)---栈
栈
手写数组模拟栈
(1)栈类
数组模拟栈的思路分析:
1-使用数组来模拟栈
2-定义一个top来表示栈顶,初始化为-1
3-入栈的操作,当有数据加入到栈时,top++; stack[top]=data;
4-出栈的操作,int value=stack[top]; top–, return value
//定义一个类,表示栈
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;
}
//入栈操作
public void push(int value){
//先判断栈是不是满了
if (isFull()){
System.out.println("栈已经满了");
return;
}
//不为满的时候,top后移,把值插入到数组里去
top++;
stack[top]=value;
}
//出栈操作
public int pop(){
//先判断栈是不是空的
if (isEmpty()){
//抛出异常
throw new RuntimeException("栈是空的");
}
int outValue = stack[top];
top--;
return outValue;
}
//遍历栈的值
public void list(){
//先判断栈是不是空的,如果是空的就抛出异常
if (isEmpty()){
System.out.println("栈为空");
return;
}
//从栈顶开始往下逐个显示数据
for (int i = top; i >= 0; i--) {
int value=stack[i];
System.out.printf("stack[%d] = %d\n",i,stack[i]);
}
}
}
(2)测试类
public class ArrayStackDemo {
public static void main(String[] args) {
ArrayStack stack=new ArrayStack(10);
//测试添加
stack.push(8);
stack.push(3);
stack.push(6);
stack.push(1);
stack.push(4);
stack.push(6);
stack.push(9);
//测试删除
stack.pop();
//测试遍历
stack.list();
}
}
手写链表模拟栈
(1)创建节点类
class Node{
private int value;//节点的值
private Node next;//栈顶指针节点
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
// public Node(int value) {
// this.value = value;
// }
}
(2)创建栈类
class ListStack{
private Node base;
private Node top;
private Integer size;
//栈的初始化
public void InitStack(){
top=base=new Node();
size=0;
}
//获取栈的大小
public int StackLenth(){
return this.size;
}
//入栈
public void Push(int value){
Node newNode=new Node();
newNode.setValue(value);
top.setNext(newNode);
top=newNode;
size++;
}
//出栈
public int Pop(){
if (base==top){
throw new RuntimeException("栈为空");
}
int value=top.getValue();
size--;
Node node=base;
while (node.getNext().getNext()!=null){
node=node.getNext();
}
node.setNext(null);
top=node;
return value;
}
//遍历栈
public void list(){
if (base==top){
System.out.println("栈为空");
}
for (int i = size; i > 0; i--) {
// System.out.printf("stack[%d]=%d",i,i);
}
}
}
栈实现综合计算器
(1)先用数组创建一个栈
//先创建一个栈
//定义一个类,用数组表示栈,需要扩展功能
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;
}
//入栈操作
public void push(int value) {
//先判断栈是不是满了
if (isFull()) {
System.out.println("栈已经满了");
return;
}
//不为满的时候,top后移,把值插入到数组里去
top++;
stack[top] = value;
}
//出栈操作
public int pop() {
//先判断栈是不是空的
if (isEmpty()) {
//抛出异常
throw new RuntimeException("栈是空的");
}
int outValue = stack[top];
top--;
return outValue;
}
//遍历栈的值
public void list() {
//先判断栈是不是空的,如果是空的就抛出异常
if (isEmpty()) {
System.out.println("栈为空");
return;
}
//从栈顶开始往下逐个显示数据
for (int i = top; i >= 0; i--) {
int value = stack[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;
}
//返回当前栈顶的值,但是不是真正的出栈pop
public int peek() {
return stack[top];
}
}
(2)使用栈类实现计算器
/**
* 使用栈来完成表达式的计算思路:
* 中缀表达式计算器
* <p>
* 1)通过一个index值(索引),来遍历我们的表达式
* 2)如果我们发现是一个数字,就直接入栈
* 3)如果我们扫描到的是一个符号,就分一下情况
* 3.1)如果发现当前的符号栈是空的,直接入栈
* 3.2)如果符号栈有操作符,就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符
* 就需要从数栈里pop出两个数,再从符号栈里pop出一个符号,进行运算,把得到的结果再push入数栈,当前符号入符号栈
* 如果当前的操作符的优先级大于栈中的操作符,就直接入符号栈
* 4)当表达式扫描完毕,就顺序的从数栈和符号栈中pop出相应的数和符号,并且运行
* 5)最后,在数栈只有一个数字,就是表达式的结果
*
* @ClassName: Calculator
* @Author: AllenSun
* @Date: 2019/11/3 14:00
*/
public class Calculator {
public static void main(String[] args) {
//根据前面的思路,完成表达式的计算
String expression = "7*2*2-5+1-5+3-4";
//创建两个栈,一个是数栈,一个是符号栈
ArrayStack numStack = new ArrayStack(10);
ArrayStack operStack = new ArrayStack(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是什么,做相应的处理
//1-如果是运算符号
if (operStack.isOper(ch)) {
//判断当前的符号栈是不是空的
if (!operStack.isEmpty()) {
//处理,如果符号栈有操作符,就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符
//就需要从数栈里pop出两个数,再从符号栈里pop出一个符号,进行运算,把得到的结果再push入数栈,当前符号入符号栈
if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
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 {
//如果是数,就直接入数栈
//1-注意多位数72,当发现数字时直接入栈,就会把7入栈,只能分别字符7,而不是数字72
//2-在处理数时,需要向expression表达式的index后再看一位,如果后一位还是数,那就往后扫描,如果是符号才入栈
//3-因此我们需要定义一个变量(字符串变量)
//处理多位数,先拼接ch
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))) {
//如果后一位是运算符,就入栈keepNum=“1”或者“123”
numStack.push(Integer.parseInt(keepNum));
//重要部分!!!要清空原来的keepNum
keepNum = "";
}
//判断下一个字符是不是数字,如果是数字就继续往下扫描
// numStack.push(ch-48);//这里的数字只是一个符号,要根据asiic码转化成数字
}
//让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);//入栈
}
//把数栈的最后一个数pop出来,就是结果
System.out.printf("表达式%s = %d", expression, numStack.pop());
}
}
中缀改后缀逆波兰计算器
前缀表达式
从右往左扫描表达式,遇到数字就把数字压入堆栈,遇到运算符就弹出栈顶的两个数
用运算符对它们做相应的计算(栈顶元素和次顶元素),并把结果入栈
重复上面过程直到表达式最左端,最后运算出来的值就是表达式的结果
中缀表达式
1)中缀表达式是常见的表达式,比如(3+4)*5
2) 中缀表达式适合人的逻辑思维,但是不适合计算机的思维,所以在计算的时候,往往会把中缀表达式转成其他表达式来操作
(一般都是转换成后缀表达式)
后缀表达式(逆波兰表达式)
1)跟前缀表达式相似,知识运算符位于操作数之后
2)举例:(3+4)*5-6,对应的后缀表达式就是3 4 + 5 * 6 -
中缀表达式转后缀表达式
1)初始化两个栈:运算符栈s1和存储中间结果的栈s2
2)从左往右扫描中缀表达式
3)遇到操作数时,将其压入数栈
4)遇到运算符时:
1-如果s1运算符栈是空的,或者栈顶运算符为左括号(,那就直接把这个运算符入栈
2-否则,如果当前的运算符的优先级比栈顶运算符高,也是直接把这个运算符入栈
3-否则,就把s1运算符栈栈顶的运算符弹出并压入到s2数栈里,再次站到(4-1)与s1中断的栈顶运算符比较
5)如果遇到括号:
1-如果是左括号(,就直接押入s1运算符栈
2-如果是右括号),则依次弹出s1栈顶的运算符,并且压入s2,直到遇到左括号为止,此时把这一对括号丢弃
6)重复步骤2至5,直到表达式的最右边
7)把s1种剩余的运算符依次弹出并压入s2
8)依次弹出s2种的元素并且输出,结果的逆序就是中缀表达式对应的后缀表达式
(1)创建类回运算符对应的优先级
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 "*":
result = MUL;
break;
case "/":
result = DIV;
break;
default:
System.out.println("不存在该运算符");
break;
}
return result;
}
}
(2)计算器
public class PolandNotation {
public static void main(String[] args) {
//完成把一个中缀表达式转成后缀表达式的功能
//因为直接对字符串进行操作很不方便,所以要先把“中缀表达式字符串”转成“对应的List”,方便操作
//把得打的中缀表达式的List => 后缀表达式对应的List
String expression = "10+((2+3)*4)-5";
List<String> infixExpressionList = toInfixExpressionList(expression);
System.out.println("中序字符串转List后为:" + infixExpressionList);
List<String> parseSuffixExpression = parseSuffixExpression(infixExpressionList);
System.out.println("中序List转后续List为:" + parseSuffixExpression);
int res02=calculate(parseSuffixExpression);
System.out.println("后序List计算结果为:"+res02);
//先定义一个逆波兰表达式(后缀表达式)
//(3+4)*5-6 => 3 4 + 5 * 6 -
//为了方便,逆波兰表达式的数字和符号使用空格隔开
String suffixExpression = "30 4 + 5 * 6 - ";
//思路
//1-先把表达式方法一个ArrayList中去
//2-把ArrayList传递给一个方法,遍历ArrayList配合栈完成计算
List<String> List = getListString(suffixExpression);
System.out.println("rpnList=" + List);
int res = calculate(List);
System.out.println("计算结果为:" + res);
}
/**把一个逆波兰表达式,一次把数据和运算符放入到Arraylist中去
* 放到ArrayList中后方便取值,不然还要用index挨个遍历取
* @MethodName: getListString
* @Author: AllenSun
* @Date: 2019/11/3 19:44
*/
public static List<String> getListString(String suffixExpression) {
//把suffixExpression分割
String[] split = suffixExpression.split(" ");//按空格来分割
List<String> list = new ArrayList<String>();
for (String s : split) {
list.add(s);
}
return list;
}
/**
* 把一个中缀表达式转成对应的List
*
* @MethodName:
* @Author: AllenSun
* @Date: 2019/11/3 18:42
*/
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 = "";//先清空
while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
str += c;//拼接
i++;
}
//拼接完以后把拼接后的多位数str加进去
ls.add(str);
}
} while (i < s.length());
return ls;
}
/**
* 把中缀表达式对应的List 改成 后缀表达式的List
*
* @MethodName:
* @Author: AllenSun
* @Date: 2019/11/3 19:06
*/
public static List<String> parseSuffixExpression(List<String> ls) {
//定义两个栈
Stack<String> s1 = new Stack<String>();
//因为s2这个栈,在整个转换过程中,没有pop操作,而且后面我们还需要逆序操作
//所以,就可以把栈Stack换成链表List,存储中间结果
List<String> s2 = new ArrayList<String>();
//遍历ls
for (String item : ls) {
//如果是一个数,那就入s2,用正则表达式取数
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();//把(弹出
} else {
//当item的优先级 小于等于 s1栈顶的运算符的优先级
//就把s1运算符栈栈顶的运算符弹出并压入到s2数栈里,再次站到与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;
}
/**
* 完成对逆波兰表达式的运算(后缀表达式的计算)
* 1)从左往右扫描,把3和4压入堆栈
* 2)遇到+运算符,因此弹出4和3(4是栈顶元素,3是次顶元素),计算出3+4的值,得7,再把7入栈
* 3)把5入栈
* 4)接下来遇到*运算符,因此弹出5和7,计算出7*5=35,把35入栈
* 5)把6入栈
* 6)最后是-运算符,计算出35-6的值,得29,由此得出最终结果
*
* @MethodName:
* @Author: AllenSun
* @Date: 2019/11/3 16:30
*/
public static int calculate(List<String> list) {
//先创建一个栈,只需要一个栈即可
Stack<String> stack = new Stack<>();
//遍历list,并放到栈里
for (String item : list) {
//使用正则表达式取出数
if (item.matches("\\d+")) {//取出多位数
//如果是数,直接入栈
stack.push(item);
} else {
//如果是运算符,就pop两个数并且运算,然后再把数入栈
//parseInt() 方法用于将字符串参数作为有符号的十进制整数进行解析
int num2 = Integer.parseInt(stack.pop());//数取出来时是字符串,用parseInt转换成十进制int整数
int num1 = Integer.parseInt(stack.pop());
int res = 0;
if (item.equals("+")) {
res = num1 + num2;
} else if (item.equals("-")) {
res = num1 - num2;//因为是从左往右扫描,入栈时左边先入栈,出栈时右边先出栈,所以后出栈的num1-先出栈的num2
} else if (item.equals("*")) {
res = num1 * num2;
} else if (item.equals("/")) {
res = num1 / num2;
} else {
throw new RuntimeException("运算符有误!");
}
//求出结果res之后,还要把这个值入栈,stack泛型放的是字符串,所以res要转成字符串
stack.push(res + "");//还能这么转成字符串:加一个空串
}
}
//for循环结束后,留在stack栈里的数就是最终的结果
return Integer.parseInt(stack.pop());//最终的数只是字符串,要转成十进制整数
}
}