Leetcode: Ternary Expression Parser

Given a string representing arbitrarily nested ternary expressions, calculate the result of the expression. You can always assume that the given expression is valid and only consists of digits 0-9, ?, :, T and F (T and F represent True and False respectively).

Note:

The length of the given string is ≤ 10000.
Each number will contain only one digit.
The conditional expressions group right-to-left (as usual in most languages).
The condition will always be either T or F. That is, the condition will never be a digit.
The result of the expression will always evaluate to either a digit 0-9, T or F.
Example 1:

Input: "T?2:3"

Output: "2"

Explanation: If true, then result is 2; otherwise result is 3.
Example 2:

Input: "F?1:T?4:5"

Output: "4"

Explanation: The conditional expressions group right-to-left. Using parenthesis, it is read/evaluated as:

             "(F ? 1 : (T ? 4 : 5))"                   "(F ? 1 : (T ? 4 : 5))"
          -> "(F ? 1 : 4)"                 or       -> "(T ? 4 : 5)"
          -> "4"                                    -> "4"
Example 3:

Input: "T?T?F:5:3"

Output: "F"

Explanation: The conditional expressions group right-to-left. Using parenthesis, it is read/evaluated as:

             "(T ? (T ? F : 5) : 3)"                   "(T ? (T ? F : 5) : 3)"
          -> "(T ? F : 3)"                 or       -> "(T ? F : 5)"
          -> "F"                                    -> "F"

My First Solution:

Use Stack and String operation, from the back of the string, find the first '?', push the right to stack. Depends on whether the char before '?' is 'T' or 'F', keep the corresponding string in the stack

 public class Solution {
     public String parseTernary(String expression) {
         Stack<String> st = new Stack<String>();
         int pos = expression.lastIndexOf("?");
         while (pos > 0) {
             if (pos < expression.length()-1) {
                 String str = expression.substring(pos+1);
                 String[] strs = str.split(":");
                 for (int i=strs.length-1; i>=0; i--) {
                     if (strs[i].length() > 0)
                         st.push(strs[i]);
                 }
             }
             String pop1 = st.pop();
             String pop2 = st.pop();
             if (expression.charAt(pos-1) == 'T') st.push(pop1);
             else st.push(pop2);
             expression = expression.substring(0, pos-1);
             pos = expression.lastIndexOf("?");
         }
         return st.pop();
     }
 }

Better solution, refer to https://discuss.leetcode.com/topic/64409/very-easy-1-pass-stack-solution-in-java-no-string-concat/2

No string contat/substring operation

 public String parseTernary(String expression) {
     if (expression == null || expression.length() == 0) return "";
     Deque<Character> stack = new LinkedList<>();

     for (int i = expression.length() - 1; i >= 0; i--) {
         char c = expression.charAt(i);
         if (!stack.isEmpty() && stack.peek() == '?') {

             stack.pop(); //pop '?'
             char first = stack.pop();
             stack.pop(); //pop ':'
             char second = stack.pop();

             if (c == 'T') stack.push(first);
             else stack.push(second);
         } else {
             stack.push(c);
         }
     }

     return String.valueOf(stack.peek());
 }