思路

數字輸出，運算符進棧，括號匹配出棧，棧頂優(yōu)先級出棧
a、首先使用兩個棧 一個是s1 一個是s2 s1 是用來臨時存儲運算符的， s2 是用來存放輸入的逆波蘭表達式的，
b、從中綴表達式的最左端開始，逐個讀取每一個字符，如果操作數，則壓入s2，如果是左括號，則壓入s1，如果為右括號，則將s1中的運算符依次取出并且壓入s2，直到遇到左括號，但是該左括號出棧 但不壓入s2，如果為操作符， 判斷s1是否為空，如果為空 則將它壓入s2，如果掃描到的比棧頂的元素的優(yōu)先級大 將它入棧，如果掃描到的比小于棧頂或者等于棧頂的優(yōu)先級小，直到掃描到的元素大于棧頂的元素（注意這里是一個循環(huán)），然后判斷s1里面如果還有運算符 則一一出棧壓入到s2中
c、然后這個時候所有的數據全部在s2中，這個時候從的將s2逆置，從棧底開始取元素，開始掃描，如果掃描到的是一個運算符，則將他之前掃描到的兩個元素做運算，得到存儲到該位置，一直掃描，直到棧里還剩一個元素，就得到結果。

代碼實現

自己寫的 就是為了實現可能還有問題 大家可以提出來

  public class ReversePolishUtil {
  /**
    *是一個中綴表達式
    * @param express
    */
  public static void Reverse(String[] express) {
    if (express == null || express.length == 0) {
        拋出異常;
   }
    運來存放運算符
    StackDemo</a> s1 = new StackDemo ();
    用來存放輸入逆波蘭表達式
    StackDemo s2 = new StackDemo ();
    依次遍歷這個數組
    for (int i = 0; i < express.length; i++) {
          String nowChar = express[i];
          Pattern pattern = Pattern.compile("[0-9]*");
          boolean isMacth = pattern.matcher(nowChar).matches();
          if (isMacth) {
          如果是數字 直接壓入s2
          s2.push(nowChar);
          } else {
          否則就是操作符 就得判斷s1 棧頂的元素
          if (s1.empty()) {
          如果為空 直接push
          s1.push(nowChar);
          } else if (nowChar.equals("(")) {
          如果是左括號 直接push s1
            s1.push(nowChar);
          } else if (nowChar.equals(")")) {
          如果是右括號， s1中的運算符依次出棧 壓入到s2中， 直到遇到左括號， 但是左括號是直接出棧的
              while (!s1.empty() && !s1.peek().equals("(")) {
                        s2.push(s1.pop());
                      }
              然后將左括號也給出棧
              s1.pop();
          } else if (nowChar.equals("+") || nowChar.equals("-")) {
          1、如果掃描到的比棧頂的元素的優(yōu)先級大 將它入棧
          2、如果掃描到的比小于棧頂或者等于棧頂的優(yōu)先級小，知道掃描到的元素大于棧頂的元素掃描到的運算符
               while (!s1.empty() && !s1.peek().equals("(")) {
            在這里只要不遇到左括號 就一直出棧，因為優(yōu)先級都比它大
                        s2.push(s1.pop());
                       }
          在這里是要么遇到括號 要么s1出棧為null了
                s1.push(nowChar);
          } else if (nowChar.equals("*") || nowChar.equals("/")) {
          在這里一直出棧的情況是只有當遇到 * 和/
                while (!s1.empty() && s1.peek().equals("*") || s1.peek().equals("?")) {
                         s2.push(s1.pop());//出棧
                      }
                s1.push(nowChar);
          }
      }
    如果s1里面還有操作符 則push到s2里面
    while (!s1.empty()) {
          s2.push(s1.pop());
    }
  while (!s2.empty()) {
    Log.e("Reverse", s2.pop() + "");
    }  
  }
}

然后使用數組手寫一個棧，上面的逆波蘭就用的這個demo

    public class StackDemo {
    //初始數組的大小
    private int capacity = 3;
    //數組中元素的個數
    private int size = 0;
    //由于是數組設計到擴容 ，這里直接是擴容1.5倍
    private int increment = 2;
    private Object[] elementData = new Object[capacity];
    public StackDemo() {
    }

    public StackDemo(int capacity) {
    this.capacity = capacity;
    }
    //實現一個push的方法
    public void push(Object obj) {
    //在這里要判斷是否超出了 如果超過了就得擴容 注意相等也要判斷 坑了
      if (size >= elementData.length) {      
        grow(); //擴容
        }
    elementData[size] = obj;
    size++;
    }

    //移除棧頂的元素
    public Object pop() {
        if (elementData == null || elementData.length == 0 || size == 0) {
            return "";
        }
        size--;
        return elementData[size];
    }
    public boolean empty() {
        if (elementData == null || elementData.length == 0 || size == 0) {
            return true;
        }
        return false;
    }
    /**
     * 查看棧頂元素但是不刪除
     * @return
     */
    public Object peek() {
        if (elementData == null || elementData.length == 0 || size == 0) {
            return "";
        }
        return elementData[size - 1];
    }
    //數組大小的擴容
    private void grow() {
        int newcapacity = (increment * elementData.length);
        elementData = Arrays.copyOf(elementData, newcapacity);
    }

}

最后調用：
String[] string = {"12", "+", "4", "+", "5","*","(","3","-","2",")"};
ReversePolishUtil.Reverse(string); 吧上一篇文章的結果打印出來是沒問題的