sol.rb

RubyVM::InstructionSequence.compile_option = {
    tailcall_optimization: true,
    trace_instruction: false
}

# Definition for a binary tree node.
# class TreeNode
#     attr_accessor :val, :left, :right
#     def initialize(val = 0, left = nil, right = nil)
#         @val = val
#         @left = left
#         @right = right
#     end
# end
# @param {TreeNode} root1
# @param {TreeNode} root2
# @return {Integer[]}
def get_all_elements(root1, root2)
    merge(root1 || [], root2 || []).to_a
end

def merge(array_1, array_2)
  return enum_for(__method__, array_1, array_2) unless block_given?

  a = array_1.each
  b = array_2.each
  loop { yield a.peek < b.peek ? a.next : b.next }
  loop { yield a.next }
  loop { yield b.next }
end

class TreeNode
    eval <<-EOF
    def each(&block)
        return to_enum(:each) unless block_given?
        
        # equivalent to these: recursion is suck
        left.each(&block) unless left.nil?
        yield val
        right.each(&block) unless right.nil?
    end
    EOF
end