Java实现字符串中缀转后缀

中缀转后缀

前期准备

• 需要一个堆栈，一个队列
• 需要一个中缀转后缀的算法

中缀转后缀算法

1.首先对字符串进行遍历

2.

<1>如果是数字，则直接加入到队列。
<2>如果是左括号‘（’，则压栈。
< 3>如果是右括号’）‘，则依次将栈中元素弹出，并加入到队列中，直到遇到左括号。将左括号弹出。
<4>如果是运算符
会遇到四种情况：

1.空栈

2.栈顶元素为左括号

3.栈顶元素为数字

4.栈顶元素为运算符

前三种情况可以直接将运算符压栈，第四种情况，需要判断两个运算符的优先级：

1.若栈顶运算符优先级大于该运算符，则将栈顶运算符弹出，加到队列中，
2.若栈顶运算符优先级小于该运算符，则将该运算符压栈。

3. 遍历结束后，将栈中剩余元素弹出并加到队列中去。

4.注意事项

1. Java有内置的栈和队列（ArrayList，Stack），不过需要调用以下两个类

import java.util.ArrayList;
import java.util.Stack;

2.在判断运算符优先级的时候，最好写一个方法或是类来判断。便于调用。

5.具体代码

       说明：因为作业需要，所以没有调用Java内置的栈，而是自己写了一个栈，仅仅是为了应付这个问题，所以可能会有一些缺漏和不完整。如有不足，还请海涵和指点！谢谢！

堆栈代码

//将堆栈封装成一个类
class Stack {
    private int temp ; //判断标志，起到指针的作用
    private int stackMaxSize; //栈的最大存储空间
    private char[] stackMemory; //字符数组

    //构造方法建栈
    public Stack(int stackMaxSize) {
        this.temp=-1; //统一规定指针初始值为-1
        this.stackMaxSize = stackMaxSize;
        this.stackMemory = new char[this.stackMaxSize - 1];
    }

    //判断栈是否为空
    public boolean isEmpty() {
        if (this.temp == -1) {
            System.out.println("栈空！");
            return true;
        } else {
            System.out.println("栈非空！");
            return false;
        }
    }

    //判断栈是否为满
    public boolean isFull() {
        if (this.temp == this.stackMaxSize - 1) {
            System.out.println("栈满！");
            return true;
        } else {
            System.out.println("栈非满！");
            return false;
        }
    }

    //添加元素
    public void add(char c) {
        if (isFull()) {
            System.out.println("栈满！不能添加！");
        } else {
            this.temp++; //指针上移
            stackMemory[this.temp]=c;
        }
    }

    //弹出栈顶元素
    public char pop() {
        int temp;
        if (isEmpty()) {
            System.out.println("栈空！不能删除！");
            return 0;
        } else {
            temp = this.temp;
            this.temp--; //指针下移
            return this.stackMemory[temp];
        }
    }

    //返回栈顶元素
    public char get() {
        if (isEmpty()) {
            System.out.println("栈空！没有元素！");
            return 0;
        } else
        return this.stackMemory[this.temp];
    }

    //打印栈中元素
    public void display()
    {
        for(int i=this.temp;i>=0;i--)
        {
            System.out.println(stackMemory[i]);
        }
    }
}

判断运算符优先级方法代码

  //判断优先级
    public static int judge(char c1)
    {
        switch(c1)
        {
            case '+':
                return 1;
            case'-':
                return 1;
            case'*':
                return 2;
            case'/':
                return 2;
            default:
                break;
        }
        return 0;
    }
}

中缀转后缀方法代码

 //中缀转后缀
    public static void infixTosuffix(String S) {
        int i = 0;
        ArrayList<Character> l2 = new ArrayList<Character>(); //引入队列l2
        for (i = 0; i < S.length(); i++) { //对字符串进行遍历
            //如果是数字，则直接加入到队列l2中
            if (S.charAt(i) >= 48 && S.charAt(i) <= 57) {
                l2.add(S.charAt(i));
            }
            //如果是左括号，则直接压入栈中
            else if (S.charAt(i) == 40) {
                stack.add(S.charAt(i));
            }
            //如果是右括号，则依次弹出栈中元素并加到队列中
            else if (S.charAt(i) == 41) {
                //直到遇到左括号
                while (!(stack.get() == 40)) {
                    l2.add(stack.pop());
                }
                stack.pop(); //把左括号弹出
            }
            //如果是运算符，则判断他们的优先级
            else {
                //第四种情况：若运算符小于栈顶运算符，则把栈顶运算符弹出并加到队列中
                while (!stack.isEmpty() && judge(S.charAt(i)) <= judge(stack.get())) {
                    l2.add(stack.pop());
                }
                //前三种情况
                stack.add(S.charAt(i));
            }
        }
        //遍历结束后，把栈中剩余元素弹出并加到队列中去
        while(!stack.isEmpty())
        {
            l2.add(stack.pop());
        }
        //输出后缀形式的字符串
        System.out.println(l2);

    }

主函数代码

import java.util.ArrayList;
import java.util.Scanner;

public class 实验4_1 {

    static Stack stack = new Stack(100); //实例化对象

      public static void main(String[] args) {
          System.out.println("请输入要转换的字符串： ");
          Scanner in = new Scanner(System.in);
          String S = in.next();
          System.out.println("转换后的字符串如下： ");
          infixTosuffix(S);
    }

如有问题，还望点出，相互学习，共同进步，谢谢！！！