Same Tree

bool isSameTree(TreeNode* p, TreeNode* q) {
    function<string(TreeNode*)> ser = [&](TreeNode* node) -> string {
        return node ? to_string(node->val) + "," + ser(node->left) + "," + ser(node->right) : "#";
    };
    return ser(p) == ser(q);
}

public boolean isSameTree(TreeNode p, TreeNode q) {
    return ser(p).equals(ser(q));
}

private String ser(TreeNode node) {
    return node != null ? node.val + "," + ser(node.left) + "," + ser(node.right) : "#";
}

def is_same_tree(p, q):
    def ser(node):
        return f"{node.val},{ser(node.left)},{ser(node.right)}" if node else '#'
    return ser(p) == ser(q)

function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
  const ser = (node: TreeNode | null): string =>
    node ? `${node.val},${ser(node.left)},${ser(node.right)}` : '#';
  return ser(p) === ser(q);
}

bool isSameTree(TreeNode* p, TreeNode* q) {
    if (!p && !q) return true;
    if (!p || !q || p->val != q->val) return false;
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

public boolean isSameTree(TreeNode p, TreeNode q) {
    if (p == null && q == null) return true;
    if (p == null || q == null || p.val != q.val) return false;
    return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}

def is_same_tree(p, q):
    if not p and not q: return True
    if not p or not q or p.val != q.val: return False
    return is_same_tree(p.left, q.left) and is_same_tree(p.right, q.right)

function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
  if (!p && !q) return true;
  if (!p || !q || p.val !== q.val) return false;
  return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}

bool isSameTree(TreeNode* p, TreeNode* q) {
    vector<pair<TreeNode*, TreeNode*>> stack = {{p, q}};
    while (!stack.empty()) {
        auto [a, b] = stack.back(); stack.pop_back();
        if (!a && !b) continue;
        if (!a || !b || a->val != b->val) return false;
        stack.push_back({a->right, b->right});
        stack.push_back({a->left, b->left});
    }
    return true;
}

public boolean isSameTree(TreeNode p, TreeNode q) {
    Deque<TreeNode[]> stack = new ArrayDeque<>(); stack.push(new TreeNode[]{p, q});
    while (!stack.isEmpty()) {
        TreeNode[] top = stack.pop(); TreeNode a = top[0], b = top[1];
        if (a == null && b == null) continue;
        if (a == null || b == null || a.val != b.val) return false;
        stack.push(new TreeNode[]{a.right, b.right});
        stack.push(new TreeNode[]{a.left, b.left});
    }
    return true;
}

def is_same_tree(p, q):
    stack = [(p, q)]
    while stack:
        a, b = stack.pop()
        if not a and not b: continue
        if not a or not b or a.val != b.val: return False
        stack.append((a.right, b.right))
        stack.append((a.left, b.left))
    return True

function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
  const stack: [TreeNode | null, TreeNode | null][] = [[p, q]];
  while (stack.length > 0) {
    const [a, b] = stack.pop()!;
    if (!a && !b) continue;
    if (!a || !b || a.val !== b.val) return false;
    stack.push([a.right, b.right]);
    stack.push([a.left, b.left]);
  }
  return true;
}

bool isSameTree(TreeNode* p, TreeNode* q) {
    if (!p || !q) return p == q;
    vector<TreeNode*> sa = {p};
    vector<TreeNode*> sb = {q};
    while (!sa.empty()) {
        TreeNode* a = sa.back(); sa.pop_back();
        TreeNode* b = sb.back(); sb.pop_back();
        if (a->val != b->val) return false;
        if (!a->left != !b->left || !a->right != !b->right) return false;
        if (a->right) { sa.push_back(a->right); sb.push_back(b->right); }
        if (a->left) { sa.push_back(a->left); sb.push_back(b->left); }
    }
    return true;
}

public boolean isSameTree(TreeNode p, TreeNode q) {
    if (p == null || q == null) return p == q;
    Deque<TreeNode> sa = new ArrayDeque<>(); sa.push(p);
    Deque<TreeNode> sb = new ArrayDeque<>(); sb.push(q);
    while (!sa.isEmpty()) {
        TreeNode a = sa.pop();
        TreeNode b = sb.pop();
        if (a.val != b.val) return false;
        if ((a.left == null) != (b.left == null) || (a.right == null) != (b.right == null)) return false;
        if (a.right != null) { sa.push(a.right); sb.push(b.right); }
        if (a.left != null) { sa.push(a.left); sb.push(b.left); }
    }
    return true;
}

def is_same_tree(p, q):
    if not p or not q: return p is q
    sa = [p]
    sb = [q]
    while sa:
        a = sa.pop()
        b = sb.pop()
        if a.val != b.val: return False
        if (a.left is None) != (b.left is None) or (a.right is None) != (b.right is None): return False
        if a.right: sa.append(a.right); sb.append(b.right)
        if a.left: sa.append(a.left); sb.append(b.left)
    return True

function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
  if (!p || !q) return p === q;
  const sa: TreeNode[] = [p];
  const sb: TreeNode[] = [q];
  while (sa.length > 0) {
    const a = sa.pop()!;
    const b = sb.pop()!;
    if (a.val !== b.val) return false;
    if (!a.left !== !b.left || !a.right !== !b.right) return false;
    if (a.right) { sa.push(a.right); sb.push(b.right!); }
    if (a.left) { sa.push(a.left); sb.push(b.left!); }
  }
  return true;
}