import java.util.Arrays;
import java.util.Scanner;

//簡易計算器的編寫 
//中綴表示式轉字尾表示式  ,得出結果用於逆波蘭數輸出

//例如 輸入:(11+2.2)*3.1+(30*45)-((1.1+23)*3.3)/5.2
//轉換成字尾表示式: 11 2.2 + 3.1 * 30 45 * + 1.1 23 + 3.3 * 5.2 / - 
//輸出結果:1375.6257692307693
public class TurnRPN {
	public static void main(String[] args) {
		
		char[] s = getChar();
		String expression = getExpression(s);
		System.out.print("轉換成字尾表示式: ");
		System.out.println(expression);
		//將字串轉換成字元陣列
		char[] s2 = expression.toCharArray();
		ArrStack as = rpn(s2);
		System.out.print("輸出結果:");
		as.listStack();
	}

	// 將輸入的字串轉換成字元陣列
	public static char[] getChar() {
		Scanner sc = new Scanner(System.in);
		// 將輸入的字串轉換成一個字元陣列
		System.out.println("請輸入中綴表示式(請不要輸入空格): ");
		char[] s = sc.nextLine().toCharArray();
		return s;
	}

	// 中綴表示式轉字尾表示式
	public static String getExpression(char[] s) {
		ArrStack as = new ArrStack();
		// 建立字串儲存字尾表示式
		String arr = "";
		for (int i = 0; i < s.length; i++) {
			// 如果是數字或者.直接放入字串中
			if (isNumber(s[i]) || s[i] == '.') {
				arr = arr + s[i];
				// 判斷數字是否完全輸入,如果全部輸入完畢,則在後面加上空格
				if (i != s.length - 1) {
					if (!isNumber(s[i + 1]) && s[i + 1] != '.') {
						arr = arr + " ";
					}
				} else {
					// 如果字元的最後一位是數字,則直接加空格(與最後出棧的運算子字元區分)
					arr = arr + " ";
				}
				// 如果是運算子字元,則判斷後入棧
			} else if (s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/') {
				// 如果是= -則判斷棧頂元素是否為 * / 如果是,先將棧頂元素出棧後再入棧 否則,直接入棧
				if (s[i] == '+' || s[i] == '-') {
					if (!as.isEmpty()) { // 判斷棧是否為空
						char r = as.getTop();
						while (r == '+' || r == '-' || r == '*' || r == '/') {
							r = as.stackPop();
							arr = arr + r + " ";
							// 如果棧為空,則直接跳出迴圈
							if (!as.isEmpty()) {
								r = as.getTop();
							} else {
								break;
							}
						}
					}
					as.stackPush(s[i]);
				} else {
					as.stackPush(s[i]);
				}
				// 如果字元是(直接入棧,如果)則棧頂元素依次出棧,直到出棧元素是(為止
			} else if (s[i] == '(') {
				as.stackPush(s[i]);
			} else if (s[i] == ')') {
				char r = as.stackPop();
				while (r != '(') {
					arr = arr + r + " ";
					r = as.stackPop();
				}
			}
		}
		// 將棧中剩餘的元素依次存入字串中
		while (!as.isEmpty()) {
			char r = as.stackPop();
			arr = arr + r + " ";
		}
		return arr;
	}

	// 逆波蘭表示式求值
	public static ArrStack rpn(char[] s) {
		ArrStack as = new ArrStack();
		double num = 0;
		// 定義空字串存入字元
		String arr = "";
		double a = 0;
		double b = 0;
		double result = 0;
		for (int i = 0; i < s.length; i++) {
			// 如果是數字或者.則推入棧中
			if (isNumber(s[i]) || s[i] == '.') {
				arr = arr + s[i];
			} else if (s[i] == ' ') {
				// 遇到空格,將資料取出轉成double型別推入棧中
				if (arr == "") {
					continue;
				} else {
					num = Double.valueOf(arr);
					as.stackPush(num);
					// 字串置空
					arr = "";
				}

			} else {
				// 遇到運算子字元,彈出棧頂前兩個數進行運算後再壓入棧中
				switch (s[i]) {
				case '+':
					a = as.stackPop();
					b = as.stackPop();
					result = b + a;
					as.stackPush(result);
					break;
				case '-':
					a = as.stackPop();
					b = as.stackPop();
					result = b - a;
					as.stackPush(result);
					break;
				case '*':
					a = as.stackPop();
					b = as.stackPop();
					result = b * a;
					as.stackPush(result);
					break;
				case '/':
					a = as.stackPop();
					b = as.stackPop();
					if (a == 0) {
						System.out.println("除數不能為0!");
						break;
					}
					result = b / a;
					as.stackPush(result);
					break;

				}
			}
		}
		return as;

	}

	// 判斷字元是否為數字
	public static boolean isNumber(char c) {
		if (c >= 48 && c <= 57) {
			return true;
		}
		return false;
	}

	// 建立順序棧
	public static class ArrStack {
		// 定義陣列儲存元素
		private Object[] elementData;
		// 定義棧的當前長度
		private int size;
		// 定義棧的當前容量
		private int capacity;
		// 定義棧頂
		public int top;

		// 初始化,預設建立一個容量為50的陣列
		public ArrStack() {
			elementData = new Object[50];
			capacity = 50;
		}

		// 初始化,自定義容量陣列
		public ArrStack(int n) {
			elementData = new Object[n];
			capacity = n;
		}

		// 入棧
		public <T> void stackPush(T data) {
			// 如果容量滿了,則新建一個數組擴充容量
			if (size >= capacity) {
				int newLength = (capacity * 3 / 2) + 1;
				elementData = Arrays.copyOf(elementData, newLength);
				capacity = newLength;
			}
			elementData[top] = data;
			top++;
			size++;
		}

		// 出棧
		public <T> T stackPop() {
			if (size == 0) {
				System.out.println("當前為空棧");
				return null;
			} else {
				T data = (T) this.elementData[top - 1];
				top--;
				size--;
				return data;
			}

		}

		// 遍歷棧
		public void listStack() {
			if (size == 0) {
				System.out.println("空棧");
			} else if (size == 1) {
				System.out.println(elementData[top - 1]);
				// System.out.println("棧的長度" + size);
			} else {
				for (int i = 0; i < size; i++) {
					System.out.print(elementData[i] + " ");
				}
				System.out.println("棧的長度" + size);
			}
		}

		// 返回當前容量
		public void capacity() {
			System.out.println("當前最大容量" + capacity);

		}

		// 返回當前棧頂的值
		public <T> T getTop() {
			T data = (T) elementData[top - 1];
			return data;
		}

		// 判空
		public boolean isEmpty() {
			return size == 0;
		}
	}
}