X*4
发帖数: 101 | 1 给一个string of nested ternary operations例如a?b?c:d:e，build a tree：root是
a，左子树是b?c:d对应的tree ，右子树是e。保证input都是valid的。
不太会写 |
p**********9
发帖数: 51 | 2 如果保证input都是valid的，用一个recursive应该很容易的。因为任何根节点一定从x
？开始。 |
X*4
发帖数: 101 | 3 有代码不
从x
【在 p**********9 的大作中提到】
: 如果保证input都是valid的，用一个recursive应该很容易的。因为任何根节点一定从x
: ？开始。
|
c******w
发帖数: 1108 | 4 第一个？前面的部分是root。
扫描过去找到对应第一个？的：，第一个？与这个：之间的substring是左子树，：的
右边的substring是右子树。
把左右子树对应的substring用recursion。 |
c******w
发帖数: 1108 | 5 好像有点问题
a?b:c?d:e
应该是a是跟，左子树是b，右子树是c?d:e吧？ |
c******w
发帖数: 1108 | 6 我这个跟题目里的例子不一样。
我这个难道不是一个nested ternary？
还有更复杂的形式例如 a?b?c:d:e?f:g |
a******n
发帖数: 103 | 7 右孩子也有孩子怎么办？
a?b?c:d:e?f:g
这样呢？ |
p*****2
发帖数: 21240 | 8
明白了。
【在 c******w 的大作中提到】
: 我这个跟题目里的例子不一样。
: 我这个难道不是一个nested ternary？
: 还有更复杂的形式例如 a?b?c:d:e?f:g
|
p*****2
发帖数: 21240 | 9
这个行吗？
Node dfs(String str, int s, int e){
int i = s;
while(i
i++;
if(i==e){
return new Node(str.substring(s, e+1));
}
int j=i+1;
int count=0;
while(j
if(str.charAt(j) == '?')
count++;
if(str.charAt(j) == ':')
count--;
j++;
}
Node node = new Node(str.substring(s, i));
node.left = dfs(str, i+1, j-1);
node.right= dfs(str, j+1, e);
return node;
}
【在 c******w 的大作中提到】
: 我这个跟题目里的例子不一样。
: 我这个难道不是一个nested ternary？
: 还有更复杂的形式例如 a?b?c:d:e?f:g
|
x*******1
发帖数: 28835 | |
|
|
y**********u
发帖数: 6366 | 11 kao, k哥对您来说小case了
【在 x*******1 的大作中提到】
: G的题目真是千奇百怪，我一个都不会做。
|
c******w
发帖数: 1108 | 12 应该就是这样。其实就是括号match
【在 p*****2 的大作中提到】
:
: 这个行吗？
: Node dfs(String str, int s, int e){
: int i = s;
: while(i: i++;
: if(i==e){
: return new Node(str.substring(s, e+1));
: }
: int j=i+1;
|
p*****2
发帖数: 21240 | 13
多谢大牛。
【在 c******w 的大作中提到】
: 应该就是这样。其实就是括号match
|
p*****2
发帖数: 21240 | 14
大牛，我下个月去SF找你呀。
【在 y**********u 的大作中提到】
: kao, k哥对您来说小case了
|
y**********u
发帖数: 6366 | 15 我是菜鸟不是大牛。。。欢迎欢迎！
【在 p*****2 的大作中提到】
:
: 大牛，我下个月去SF找你呀。
|
x*******1
发帖数: 28835 | 16 准备归了。 跟fb，狗，netflix都永别了。
【在 y**********u 的大作中提到】
: kao, k哥对您来说小case了
|
c******w
发帖数: 1108 | 17 您可别这么说。俺不敢当
【在 p*****2 的大作中提到】
:
: 大牛，我下个月去SF找你呀。
|
x*********3
发帖数: 1438 | 18 貌似没有必要这么复杂， 这个应该是O(n^2)，下面是O(n)的。
简单起见，每个节点只有一个字符，ｓｔｒ的话处理起来也很简单，直接读到：或？就
行了：
Node * dfs(char *& p)
{
if (!p || (!*p)|| *p == ':') return NULL;
Node * n = new Node(*p);
if (*(p+1) == '?')
{
p = p+2;
n->left = dfs(p);
++p;
}
if(*p++ == ':')
{
n->right = dfs(p);
}
return n;
}
【在 p*****2 的大作中提到】
:
: 大牛，我下个月去SF找你呀。
|
p*****2
发帖数: 21240 | 19
这个确实是可以优化。
【在 x*********3 的大作中提到】
: 貌似没有必要这么复杂， 这个应该是O(n^2)，下面是O(n)的。
: 简单起见，每个节点只有一个字符，ｓｔｒ的话处理起来也很简单，直接读到：或？就
: 行了：
: Node * dfs(char *& p)
: {
: if (!p || (!*p)|| *p == ':') return NULL;
: Node * n = new Node(*p);
: if (*(p+1) == '?')
: {
: p = p+2;
|
p*****2
发帖数: 21240 | 20
这个行吗？
int curr = 0;
Node dfs(String str){
if(curr >= str.length())
return null;
int i = curr;
while(i
i++;
Node node = new Node(str.substring(curr, i));
curr = i+1;
if(i
node.left = dfs(str);
node.right = dfs(str);
}
return node;
}
【在 x*********3 的大作中提到】
: 貌似没有必要这么复杂， 这个应该是O(n^2)，下面是O(n)的。
: 简单起见，每个节点只有一个字符，ｓｔｒ的话处理起来也很简单，直接读到：或？就
: 行了：
: Node * dfs(char *& p)
: {
: if (!p || (!*p)|| *p == ':') return NULL;
: Node * n = new Node(*p);
: if (*(p+1) == '?')
: {
: p = p+2;
|
|
|
x*********3
发帖数: 1438 | 21 好像有Ｂｕｇ :)
【在 p*****2 的大作中提到】
:
: 这个行吗？
: int curr = 0;
:
: Node dfs(String str){
: if(curr >= str.length())
: return null;
:
: int i = curr;
:
|
c***r
发帖数: 280 | 22 这个思路不错，我给转成了个c++代码如下。只是觉得你的code里面，最后一个if语句
，是否node->right = dfs(str);该移到if外,在一个else if 里面， 这个else if条件
是 else if (i
我转的C++如下：
int curr = 0;
Node* tree_dfs(string str ) {
if(curr >= str.length())
return NULL;
int i = curr;
while(i
i++;
Node* node = new Node(str.substr(curr, i-curr));
curr = i+1;
if(i
node->left = tree_dfs(str);
}
else if (i
node->right = tree_dfs(str);
}
return node;
}
【在 p*****2 的大作中提到】
:
: 这个行吗？
: int curr = 0;
:
: Node dfs(String str){
: if(curr >= str.length())
: return null;
:
: int i = curr;
:
|
p*****2
发帖数: 21240 | 23
bugfree好难。
【在 x*********3 的大作中提到】
: 好像有Ｂｕｇ :)
|
s******d
发帖数: 9806 | 24 一个stack就可以了，碰到?就压栈，碰到:就弹俩出来，连着:后面的那个，算好结果再
压回去。最后栈里只有一个元素，就是结果。
【在 X*4 的大作中提到】
: 给一个string of nested ternary operations例如a?b?c:d:e，build a tree：root是
: a，左子树是b?c:d对应的tree ，右子树是e。保证input都是valid的。
: 不太会写
|
x*********3
发帖数: 1438 | 25 边界上还有问题，不过最大的问题是最后那个ｅｌｓｅ ｉｆ，肯定不能要ｅｌｓｅ的。
【在 c***r 的大作中提到】
: 这个思路不错，我给转成了个c++代码如下。只是觉得你的code里面，最后一个if语句
: ，是否node->right = dfs(str);该移到if外,在一个else if 里面， 这个else if条件
: 是 else if (i: 我转的C++如下：
: int curr = 0;
: Node* tree_dfs(string str ) {
: if(curr >= str.length())
: return NULL;
: int i = curr;
: while(i
|
c***r
发帖数: 280 | 26 不明白，给指点下？
的。
【在 x*********3 的大作中提到】
: 边界上还有问题，不过最大的问题是最后那个ｅｌｓｅ ｉｆ，肯定不能要ｅｌｓｅ的。
|
x*********3
发帖数: 1438 | 27 这种ｒｅｃｕｒｓｉｖｅ用ｉｆ ｅｌｓｅ的话，左右子树就搞不到一个ｒｏｏｔ上去
了，是吧。 |
X*4
发帖数: 101 | 28 给一个string of nested ternary operations例如a?b?c:d:e，build a tree：root是
a，左子树是b?c:d对应的tree ，右子树是e。保证input都是valid的。
不太会写 |
p**********9
发帖数: 51 | 29 如果保证input都是valid的，用一个recursive应该很容易的。因为任何根节点一定从x
？开始。 |
X*4
发帖数: 101 | 30 有代码不
从x
【在 p**********9 的大作中提到】
: 如果保证input都是valid的，用一个recursive应该很容易的。因为任何根节点一定从x
: ？开始。
|
|
|
c******w
发帖数: 1108 | 31 第一个？前面的部分是root。
扫描过去找到对应第一个？的：，第一个？与这个：之间的substring是左子树，：的
右边的substring是右子树。
把左右子树对应的substring用recursion。 |
c******w
发帖数: 1108 | 32 好像有点问题
a?b:c?d:e
应该是a是跟，左子树是b，右子树是c?d:e吧？
【在 p*****2 的大作中提到】
:
: bugfree好难。
|
c******w
发帖数: 1108 | 33 我这个跟题目里的例子不一样。
我这个难道不是一个nested ternary？
还有更复杂的形式例如 a?b?c:d:e?f:g
【在 p*****2 的大作中提到】
:
: bugfree好难。
|
a******n
发帖数: 103 | 34 右孩子也有孩子怎么办？
a?b?c:d:e?f:g
这样呢？
【在 p*****2 的大作中提到】
:
: bugfree好难。
|
p*****2
发帖数: 21240 | 35
明白了。
【在 c******w 的大作中提到】
: 我这个跟题目里的例子不一样。
: 我这个难道不是一个nested ternary？
: 还有更复杂的形式例如 a?b?c:d:e?f:g
|
p*****2
发帖数: 21240 | 36
这个行吗？
Node dfs(String str, int s, int e){
int i = s;
while(i
i++;
if(i==e){
return new Node(str.substring(s, e+1));
}
int j=i+1;
int count=0;
while(j
if(str.charAt(j) == '?')
count++;
if(str.charAt(j) == ':')
count--;
j++;
}
Node node = new Node(str.substring(s, i));
node.left = dfs(str, i+1, j-1);
node.right= dfs(str, j+1, e);
return node;
}
【在 c******w 的大作中提到】
: 我这个跟题目里的例子不一样。
: 我这个难道不是一个nested ternary？
: 还有更复杂的形式例如 a?b?c:d:e?f:g
|
x*******1
发帖数: 28835 | |
y**********u
发帖数: 6366 | 38 kao, k哥对您来说小case了
【在 x*******1 的大作中提到】
: G的题目真是千奇百怪，我一个都不会做。
|
c******w
发帖数: 1108 | 39 应该就是这样。其实就是括号match
【在 p*****2 的大作中提到】
:
: 这个行吗？
: Node dfs(String str, int s, int e){
: int i = s;
: while(i: i++;
: if(i==e){
: return new Node(str.substring(s, e+1));
: }
: int j=i+1;
|
p*****2
发帖数: 21240 | 40
多谢大牛。
【在 c******w 的大作中提到】
: 应该就是这样。其实就是括号match
|
|
|
p*****2
发帖数: 21240 | 41
大牛，我下个月去SF找你呀。
【在 y**********u 的大作中提到】
: kao, k哥对您来说小case了
|
y**********u
发帖数: 6366 | 42 我是菜鸟不是大牛。。。欢迎欢迎！
【在 p*****2 的大作中提到】
:
: 大牛，我下个月去SF找你呀。
|
x*******1
发帖数: 28835 | 43 准备归了。 跟fb，狗，netflix都永别了。
【在 y**********u 的大作中提到】
: kao, k哥对您来说小case了
|
c******w
发帖数: 1108 | 44 您可别这么说。俺不敢当
【在 p*****2 的大作中提到】
:
: 大牛，我下个月去SF找你呀。
|
x*********3
发帖数: 1438 | 45 貌似没有必要这么复杂， 这个应该是O(n^2)，下面是O(n)的。
简单起见，每个节点只有一个字符，ｓｔｒ的话处理起来也很简单，直接读到：或？就
行了：
Node * dfs(char *& p)
{
if (!p || (!*p)|| *p == ':') return NULL;
Node * n = new Node(*p);
if (*(p+1) == '?')
{
p = p+2;
n->left = dfs(p);
++p;
}
if(*p++ == ':')
{
n->right = dfs(p);
}
return n;
}
【在 p*****2 的大作中提到】
:
: 大牛，我下个月去SF找你呀。
|
p*****2
发帖数: 21240 | 46
这个确实是可以优化。
【在 x*********3 的大作中提到】
: 貌似没有必要这么复杂， 这个应该是O(n^2)，下面是O(n)的。
: 简单起见，每个节点只有一个字符，ｓｔｒ的话处理起来也很简单，直接读到：或？就
: 行了：
: Node * dfs(char *& p)
: {
: if (!p || (!*p)|| *p == ':') return NULL;
: Node * n = new Node(*p);
: if (*(p+1) == '?')
: {
: p = p+2;
|
p*****2
发帖数: 21240 | 47
这个行吗？
int curr = 0;
Node dfs(String str){
if(curr >= str.length())
return null;
int i = curr;
while(i
i++;
Node node = new Node(str.substring(curr, i));
curr = i+1;
if(i
node.left = dfs(str);
node.right = dfs(str);
}
return node;
}
【在 x*********3 的大作中提到】
: 貌似没有必要这么复杂， 这个应该是O(n^2)，下面是O(n)的。
: 简单起见，每个节点只有一个字符，ｓｔｒ的话处理起来也很简单，直接读到：或？就
: 行了：
: Node * dfs(char *& p)
: {
: if (!p || (!*p)|| *p == ':') return NULL;
: Node * n = new Node(*p);
: if (*(p+1) == '?')
: {
: p = p+2;
|
x*********3
发帖数: 1438 | 48 好像有Ｂｕｇ :)
【在 p*****2 的大作中提到】
:
: 这个行吗？
: int curr = 0;
:
: Node dfs(String str){
: if(curr >= str.length())
: return null;
:
: int i = curr;
:
|
c***r
发帖数: 280 | 49 这个思路不错，我给转成了个c++代码如下。只是觉得你的code里面，最后一个if语句
，是否node->right = dfs(str);该移到if外,在一个else if 里面， 这个else if条件
是 else if (i
我转的C++如下：
int curr = 0;
Node* tree_dfs(string str ) {
if(curr >= str.length())
return NULL;
int i = curr;
while(i
i++;
Node* node = new Node(str.substr(curr, i-curr));
curr = i+1;
if(i
node->left = tree_dfs(str);
}
else if (i
node->right = tree_dfs(str);
}
return node;
}
【在 p*****2 的大作中提到】
:
: 这个行吗？
: int curr = 0;
:
: Node dfs(String str){
: if(curr >= str.length())
: return null;
:
: int i = curr;
:
|
p*****2
发帖数: 21240 | 50
bugfree好难。
【在 x*********3 的大作中提到】
: 好像有Ｂｕｇ :)
|
|
|
s******d
发帖数: 9806 | 51 一个stack就可以了，碰到?就压栈，碰到:就弹俩出来，连着:后面的那个，算好结果再
压回去。最后栈里只有一个元素，就是结果。
【在 X*4 的大作中提到】
: 给一个string of nested ternary operations例如a?b?c:d:e，build a tree：root是
: a，左子树是b?c:d对应的tree ，右子树是e。保证input都是valid的。
: 不太会写
|
x*********3
发帖数: 1438 | 52 边界上还有问题，不过最大的问题是最后那个ｅｌｓｅ ｉｆ，肯定不能要ｅｌｓｅ的。
【在 c***r 的大作中提到】
: 这个思路不错，我给转成了个c++代码如下。只是觉得你的code里面，最后一个if语句
: ，是否node->right = dfs(str);该移到if外,在一个else if 里面， 这个else if条件
: 是 else if (i: 我转的C++如下：
: int curr = 0;
: Node* tree_dfs(string str ) {
: if(curr >= str.length())
: return NULL;
: int i = curr;
: while(i
|
c***r
发帖数: 280 | 53 不明白，给指点下？
的。
【在 x*********3 的大作中提到】
: 边界上还有问题，不过最大的问题是最后那个ｅｌｓｅ ｉｆ，肯定不能要ｅｌｓｅ的。
|
x*********3
发帖数: 1438 | 54 这种ｒｅｃｕｒｓｉｖｅ用ｉｆ ｅｌｓｅ的话，左右子树就搞不到一个ｒｏｏｔ上去
了，是吧。 |
k*****L
发帖数: 55 | 55 Let me try:
Node *ternary(string &s) {
if (s.size() == 0) return NULL;
stack st;
bool isLeft = true;
int prev = 0;
for (int i = 0; i < s.size(); ++i) {
if (s.at(i) == ‘?’ || s.at(i) == ‘:’) {
Node *newNode = new Node(s.substr(pref, i - pref));
if (!st.empty()) {
Node *n;
if (isLeft) {
n = st.top();
n->left = newNode;
} else {
n = st.pop();
n->right = newNode;
}
}
if (s.at(i) == ‘?’)
st.push(newNode);
isLeft = true;
pev = i + 1;
} else if (s.at(i) == ‘:’) {
isLeft = false;
prev = i + 1;
}
} else {
continue;
}
}
Node *root = NULL;
while (!st.empty())
root = st.pop();
return root;
}
【在 X*4 的大作中提到】
: 给一个string of nested ternary operations例如a?b?c:d:e，build a tree：root是
: a，左子树是b?c:d对应的tree ，右子树是e。保证input都是valid的。
: 不太会写
|
c******n
发帖数: 4965 | 56 这个就 recursive parse 最简单， 因为操作符左结合的， 反过来不行
【在 X*4 的大作中提到】
: 给一个string of nested ternary operations例如a?b?c:d:e，build a tree：root是
: a，左子树是b?c:d对应的tree ，右子树是e。保证input都是valid的。
: 不太会写
|
l******s
发帖数: 3045 | 57 //Recursive
public static TreeNode buildTree(string express)
{
int i = 0;
while (i < express.Length && express[i] != '?') i++;
TreeNode root = new TreeNode(express.Substring(0, i).Trim());
int index = i, count = 0;
while (index < express.Length && !(count == 0 && express[index] == ':'))
{
if (express[index] == '?') count++;
else if (express[index] == ':') count--;
if(count != 0) index++;
}
if (index >= express.Length) return root;
root.Left = buildTree(express.Substring(i + 1, index - i - 1).Trim());
root.Right = buildTree(express.Substring(index + 1).Trim());
return root;
}
//Iterative
public static TreeNode buildTree_Iterative(string express)
{
Stack stack = new Stack();
StringBuilder subExpress = new StringBuilder();
char lastOp = '\0';
for(int i = 0; i <= express.Length; i++)
if (i == express.Length || express[i] == '?' || express[i] == ':')
{
TreeNode newNode = new TreeNode(subExpress.ToString().Trim());
if(lastOp == '?') stack.Peek().Left = newNode;
else if (lastOp == ':')
{
stack.Pop();
stack.Peek().Right = newNode;
if(stack.Count > 1) stack.Pop();
}
stack.Push(newNode);
if(i < express.Length) lastOp = express[i];
subExpress.Clear();
}
else subExpress.Append(express[i]);
while (stack.Count > 1) stack.Pop();
return stack.Pop();
} |
s**x
发帖数: 7506 | 58
嗯，root 除了左右子树外，还应该有第三棵子树做为？之前的值，这个原题没讲清楚。
【在 a******n 的大作中提到】
: 右孩子也有孩子怎么办？
: a?b?c:d:e?f:g
: 这样呢？
|
s**x
发帖数: 7506 | 59
很不错，感觉要处理?前的值也可以子树就対了。
【在 x*********3 的大作中提到】
: 貌似没有必要这么复杂， 这个应该是O(n^2)，下面是O(n)的。
: 简单起见，每个节点只有一个字符，ｓｔｒ的话处理起来也很简单，直接读到：或？就
: 行了：
: Node * dfs(char *& p)
: {
: if (!p || (!*p)|| *p == ':') return NULL;
: Node * n = new Node(*p);
: if (*(p+1) == '?')
: {
: p = p+2;
|
r*****n
发帖数: 35 | 60 case class TreeNode(value: Char, var left: Option[TreeNode] = None, var
right: Option[TreeNode] = None)
object TreeBuilder {
//recursive version
def recursive(input: String, start: Int): (Int, Option[TreeNode]) ={
if (start >= input.length) {
(start, None)
} else {
val cur = Some(TreeNode(input(start)))
if (start == input.length - 1) {
(start + 1, cur)
} else {
input(start + 1) match {
case '?' =>
val (loffset, l) = recursive(input, start + 2)
val (roffset, r) = recursive(input, loffset)
cur.get.left = l
cur.get.right = r
(roffset, cur)
case ':' =>
(start + 2, cur)
}
}
}
}
// iterative version
def buildTree(input:String): Option[TreeNode] = {
if (input.length == 0) {
return None
}
val stack = new mutable.Stack[TreeNode]()
val root = Some(TreeNode(input(0)))
var cur: TreeNode = root.get
var left = false
(1 until input.length).foreach { x=>
input(x) match {
case '?' =>
left = true
stack.push(cur)
case ':' =>
case _ =>
if (left) {
cur.left = Some(TreeNode(input(x)))
left = false
cur = cur.left.get
} else {
cur = stack.pop()
cur.right = Some(TreeNode(input(x)))
cur = cur.right.get
}
}
}
root
}
} |
|
|
m****t
发帖数: 23 | 61 seems recursive is the easiest. I am still trying to figure out a stack-
based approach:-)
class TreeNode{
public:
string str;
TreeNode* left;
TreeNode* right;
TreeNode(string s) {
str = s;
left = NULL;
right = NULL;
}
};
class Solution {
public:
TreeNode* buildTree(string &A, int& index) {
int index_next = A.find_first_of("?:",index);
if (index_next==string::npos) {
TreeNode* root = new TreeNode(A.substr(index));
index = A.size();
return root;
}
TreeNode* root = new TreeNode(A.substr(index, index_next-index));
if (A[index_next]=='?') {
index = index_next+1;
root->left = buildTree(A, index);
root->right = buildTree(A, index);
} else {
index = index_next+1;
}
return root;
}
TreeNode* buildTree(string &A) {
int index = 0;
return buildTree(A, index);
}
};
【在 X*4 的大作中提到】
: 给一个string of nested ternary operations例如a?b?c:d:e，build a tree：root是
: a，左子树是b?c:d对应的tree ，右子树是e。保证input都是valid的。
: 不太会写
|
m****t
发帖数: 23 | 62 stack based approach
TreeNode* buildTreeStack(string &A) {
stack s_nodes;
stack s_operators;
int index = 0;
while (index
if (A[index]=='?') {
s_operators.push(A[index]);
index++;
} else if (A[index]==':') {
if (s_operators.top()=='?') {
s_operators.push(A[index]);
} else {
// pop three things from the s_nodes, and form the
subtree
TreeNode* new_right = s_nodes.top(); s_nodes.pop();
TreeNode* new_left = s_nodes.top(); s_nodes.pop();
TreeNode* new_root = s_nodes.top(); s_nodes.pop();
s_operators.pop(); s_operators.pop();
new_root->left = new_left;
new_root->right = new_right;
s_nodes.push(new_root);
s_operators.push(A[index]);
}
index++;
} else { // regular node
int index_next = A.find_first_of("?:", index);
if (index_next==string::npos) {
TreeNode* new_node = new TreeNode(A.substr(index));
index = A.size();
s_nodes.push(new_node);
} else {
TreeNode* new_node = new TreeNode(A.substr(index, index_
next-index));
index = index_next;
s_nodes.push(new_node);
}
}
}
while (!s_operators.empty()) {
TreeNode* new_right = s_nodes.top(); s_nodes.pop();
TreeNode* new_left = s_nodes.top(); s_nodes.pop();
TreeNode* new_root = s_nodes.top(); s_nodes.pop();
s_operators.pop(); s_operators.pop();
new_root->left = new_left;
new_root->right = new_right;
s_nodes.push(new_root);
}
return s_nodes.top();
}
【在 m****t 的大作中提到】
: seems recursive is the easiest. I am still trying to figure out a stack-
: based approach:-)
: class TreeNode{
: public:
: string str;
: TreeNode* left;
: TreeNode* right;
: TreeNode(string s) {
: str = s;
: left = NULL;
|
b***e
发帖数: 1419 | 63 你这个题是有歧义的：
a?b:c?d:e
这个string的解释取决于那个符号的优先级高。
【在 X*4 的大作中提到】
: 给一个string of nested ternary operations例如a?b?c:d:e，build a tree：root是
: a，左子树是b?c:d对应的tree ，右子树是e。保证input都是valid的。
: 不太会写
|
