Java数据结构与算法:栈

A_Tai2333333

已于 2024-07-11 10:25:06 修改

阅读量100

点赞数 1

分类专栏： Java数据结构文章标签： java

于 2024-06-19 09:47:58 首次发布

本文链接：https://blog.csdn.net/m0_50460160/article/details/139793367

版权

Java数据结构专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、栈的介绍

1.栈的英文为(stack)

2.栈是一个先入后出(FILO-First In Last Out)的有序列表;

3.栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。

4.根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

5.出栈和入栈

二、栈的应用场景

1.子程序的调用:在跳往子程序前，会先将下个指令的地址存到堆中，直到子程序执行完后再将地址取出，以回到原来的程序中；

2.处理递归调用:和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。

3.表达式的转换与求值(实际解决)；

4.二叉树的遍历

5.图形的深度优先(depth-first)搜索法；

三、栈的代码实现

1.思路分析:

(1)使用数组模拟栈

(2)定义一个top表示栈顶，初始化为-1

(3)当有数据加入到栈时，令top++,并且令stack[top] = data;

(4)当有数据出栈时，令value = stack[top];top--;

2.代码实现:

class ArrayStack{
    private int maxSize;
    private int[] stack;
    private int top = -1;
    public ArrayStack(int maxSize){
        this.maxSize = maxSize;
        this.stack = new int[this.maxSize];
    }
    public boolean isFull(){
        return this.top == this.maxSize - 1;
    }
    public boolean isEmpty(){
        return this.top == -1;
    }
    public void push(int value){
        if(this.isFull()){
            System.out.println("Full");
            return;
        }else{
            this.top++;
            this.stack[this.top] =  value;
        }
    }
    public int pop(){
        if(this.isEmpty()){
            throw new RuntimeException("Empty");
        }else{
            int value = this.stack[this.top--];
            return value;
        }
    }
}

二、栈实现综合计算器

1.思路分析:

(1)设置两个栈，一个存放数字，一个存放符号

(2)通过一个index值(索引)来遍历我们的表达式

(3)如果我们发现是一个数字,就直接入数栈

(4)如果发现扫描到是一个符号,就分如下情况:

a.如果发现当前的符号栈为空，就直接入栈；

b.如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈顶的操作符，就需要从数栈中pop出两个数，在从符号栈中pop出一个符号，进行运算，将得到结果并将其送入数栈，然后将当前的操作符送入符号栈，如果当前的操作符的优先级大于栈中的操作符，则直接送入符号栈;

(5).当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并进行运算;

(6).最后在数栈中只有一个数字，就是该表达式的结果

2.代码实现

class ArrayStack{
    private int maxSize;
    private int[] stack;
    private int top = -1;
    public ArrayStack(int maxSize){
        this.maxSize = maxSize;
        this.stack = new int[this.maxSize];
    }
    public int peek(){
        if(this.isEmpty()){
            throw new RuntimeException("Empty!");
        }else{
            return this.stack[this.top];
        }
    }
    public boolean isFull(){
        return this.top == this.maxSize - 1;
    }
    public boolean isEmpty(){
        return this.top == -1;
    }
    public void push(int value){
        if(this.isFull()){
            System.out.println("Full");
            return;
        }else{
            this.top++;
            this.stack[this.top] =  value;
        }
    }
    public int pop(){
        if(this.isEmpty()){
            throw new RuntimeException("Empty");
        }else{
            int value = this.stack[this.top--];
            return value;
        }
    }
    public int priority(int operator){
        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,char oper){
        int res = 0;
        switch(oper){
            case '+':
              res = num1 + num2;
              break;
            case '-':
              res = num1 - num2;
              break;
            case '*':
              res = num1 * num2;
              break;
            case '/':
              res = num1 / num2;
              break;
        }
        return res;
    }
}
String exp = "3+2*6-2";
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 = '';
String keepNum = "";
while(true){
    ch = exp.charAt(index);
    if(operStack.isOper(ch)){
        if(!operStack.isEmpty()){
            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{
        keepNum+=ch;
        if(index==expression.length()-1){
            numStack.push(Interget.parseInt(keepNum));
        }
        else
        {
        if(operStack.isOper(expression.charAt(index+1))){
            numStack.push(Interget.parseInt(keepNum));
            keepNum="";
            }
        }
    }
    index++;
    if(index==expression.length()){
        break;
    }
}
while(true){
    if(operStack.isEmpty()){
        break;
    }
     num1 = numStack.pop();
     num2 = numStack.pop();
     oper = operStack.pop();
     res = numStack.cal(num1,num2,oper);
     numStack.push(res);      
}
System.out.println(numStack.pop());

三、前缀、中缀、后缀表达式

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

前缀表达式又称波兰表达式，前缀表达式的运算符位于操作数之前

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

2.中缀表达式:

中缀表达式是最常见的运算表达式，对人类是最熟悉的，在计算机中通常会将中缀表达式转换为其他的表达式来计算

3.后缀表达式(逆波兰表达式):

后缀表达式又称逆波兰表达式，后缀表达式的运算符位于操作数之后

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

4.逆波兰表达式的计算

public List<String> getListString(String suffixExpression){
    String[] split = suffixExpression.split(" ");
    List<String> list = new ArrayList<String>();
    for(String ele:split){
        list.add(ele);
    }
    return list;
}
public int calculate(List<String> ls){
    Stack<String> stack = new Stack<String>();
    for(String ele:ls){
        if(ele.matches("\\d+")){
        stack.push(ele);
        }else{
        int num2 = Integer.parseInt(stack.pop());
        int num1 = Integer.parseInt(stack.pop());
        int res = 0;
        if(ele.equals("+")){
            res = num1 + num2;
        }else if(ele.equals("-")){
            res = num1 - num2;
        }else if(ele.equals("*")){
            res = num1 * num2;
        }else{
            res = num1 / num2;
        }
        stack.push(res+"");
        }
        
    }
    return Integer.parseInt(stack.pop());
}

5.中缀转后缀表达式

(1)初始化两个栈:运算符栈s1和储存中间结果的栈s2;

(2)从左至右扫描中缀表达式;

(3)遇到操作数时，将其压入s2;

(4)遇到运算符时，比较其与s1栈顶运算符的优先级:

a.如果s1为空，或栈顶运算符为左括号'('，则直接将此运算符入栈;

b.否则，若优先级比栈顶运算符的高，也将运算符压入s1;

c.否则,将s1栈顶的运算符弹出并压入到s2中，再次转到a中与s1中新的栈顶运算符相比较;

(5)遇到括号时:

a.如果是左括号“("，则直接压入s1;

b.如果是右括号“)"，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃;

(6)重复步骤2至5，直到表达式的最右边;

(7)将s1中剩余的运算符依次弹出并压入s2;

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

6.中缀转后缀表达式代码实现

String expression = "1+((2+3)*4)-5";
ArrayList<String> list = new ArrayList<>();
String str = "";
for(int i =0;i<expression.length();i++){
    if(expression.charAt(i)<'0'||expression.charAt(i)>'9'){
        list.add(expression.charAt(i));
    }else{
        str = "";
        char c = expression.charAt(i);
        while(i<expression.length()&&c>='0'||c<='9'){
            str += c;
        }
        list.add(str);    
    }
}
Stack<String> s1 = new Stack<String>();
ArrayList<String> s2 = new ArrayList<String>();
for(String ss:list){
    if(ss.match("\\d+")){
        s2.add(ss);
    }else if(ss.equals("(")){
        s1.push(ss);
    }else if(ss.equals(")")){
        while(!s1.peek().equals("(")){
            s2.add(s1.pop());
        }
        s1.pop();
    }else{                     
    while(s1.size()!=0&&Opera.getValue(s1.peek())>=Opera.getValue(ss.peek())){
        s2.add(s1.pop());
    }
        s1.push(ss);
    }
}
while(s1.size()!=0{
    s2.add(s1.pop());
}
System.out.println(s2);
class Opera{
    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){
        switch(operation){
            case "+":
                return this.ADD;
            case "-":
                return this.SUB;
            case "*":
                return this.MUL;
            case "/":
                return this.DIV;   
        }
    }
    
}