thảo luận Leetcode mỗi ngày

class Solution:
    def tree2str(self, root: Optional[TreeNode]) -> str:
        if root is None: return ""
        if root.left is None and root.right is None: return str(root.val)
        return str(root.val) + "(" + self.tree2str(root.left) +")" + ("" if root.right is None else "(" + self.tree2str(root.right) +")")

def tree2str(root)
  return '' if root.nil?

  left = tree2str(root.left)
  right = tree2str(root.right)
  if right == '' && left != ''
    "#{root.val}(#{left})"
  elsif right == '' && left == ''
    root.val.to_s
  else
    "#{root.val}(#{left})(#{right})"
  end
end

defmodule Solution do
  def tree2str(node, format \\ &no_outer/1) do
    case node do
      %TreeNode{val: v, left: nil, right: nil} ->
        "#{v}" |> format.()

      %TreeNode{val: v, left: l, right: nil} ->
        "#{v}#{tree2str(l, &with_outer/1)}" |> format.()

      %TreeNode{val: v, left: nil, right: r} ->
        "#{v}()#{tree2str(r, &with_outer/1)}" |> format.()

      %TreeNode{val: v, left: l, right: r} ->
        "#{v}#{tree2str(l, &with_outer/1)}#{tree2str(r, &with_outer/1)}" |> format.()
    end
  end

  defp no_outer(s), do: s
  defp with_outer(s), do: "(#{s})"
end

class Solution:
    def tree2str(self, root: Optional[TreeNode]) -> str:
        res = []
        def dfs(node):
            res.append(str(node.val))
            if not node.left and not node.right:
                return
            if node.left:
                res.append("(")
                dfs(node.left)
                res.append(")")
            if node.right:
                if not node.left:
                    res.append("()")
                    res.append("(")
                    dfs(node.right)
                    res.append(")")
                else:
                    res.append("(")
                    dfs(node.right)
                    res.append(")")
                    
        dfs(root)
        return "".join(res)

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        Stack<TreeNode> stack=new Stack<>();
        List<Integer> res=new ArrayList<>();
        TreeNode node=root;
        while(node!=null){
            stack.push(node);
            node=node.left;
        }
        while(stack.size()>0){
            node=stack.pop();
            res.add(node.val);
            node=node.right;
            while(node!=null){
                stack.add(node);
                node=node.left;
            }
        }
        return res;
    }
}

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        def dfs(node):
            if not node:
                return
            
            dfs(node.left)
            res.append(node.val)
            dfs(node.right)
        dfs(root)
        return res

class Solution {
    /**
     * @param TreeNode $root
     * @return Integer[]
     */
    function inorderTraversal($root) {
        return $root === null ? [] : array_merge($this->inorderTraversal($root->left), [$root->val], $this->inorderTraversal($root->right));
    }
}

def inorder_traversal(root)
  stack = []
  curr = root
  res = []
  until curr.nil? && stack.empty?
    while curr
      stack << curr
      curr = curr.left
    end
    curr = stack.pop
    res << curr.val
    curr = curr.right
  end
  res
end

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<variant<TreeNode*, int>> st;
        st.emplace(root);
        while (!st.empty()) {
            auto v = move(st.top());
            st.pop();
            visit(overloaded{
                [&](int val) { res.push_back(val); },
                [&](TreeNode* p) {
                    if (p == nullptr) return;
                    st.emplace(p->right);
                    st.emplace(p->val);
                    st.emplace(p->left);
                }
            }, v);
        }
        return res;
    }
};

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        return self.inorderTraversal(root.left) + [root.val] + self.inorderTraversal(root.right) if root is not None else []

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        inorder(root, ans);
        return ans;
    }
    void inorder(TreeNode root, List<Integer> nums)
    {
        if(root == null)
        {
            return;
        }
        inorder(root.left, nums);
        nums.add(root.val);
        inorder(root.right, nums);
    }
}