Solution 1 - Recursive DFS
Compare corresponding nodes recursively; both structure and values must match.
Compare corresponding nodes recursively; both structure and values must match.
""" 0100.1 - Same Tree - Solution 1 - Recursive DFS """
#####################################################################################
# Imports
#####################################################################################
#####################################################################################
# Classes
#####################################################################################
class TreeNode:
"""TreeNode Class"""
def __init__(self, v=0, l=None, r=None):
self.val = v
self.left = l
self.right = r
class Solution:
"""Solution Class"""
def isSameTree(self, p: TreeNode | None, q: TreeNode | None) -> bool:
"""Same Tree Function"""
if not p or not q:
return p is q
return (
p.val == q.val
and self.isSameTree(p.left, q.left)
and self.isSameTree(p.right, q.right)
)
#####################################################################################
# Functions
#####################################################################################
def testcase():
"""Test Function"""
print(Solution().isSameTree(TreeNode(1), TreeNode(1))) # True
print(Solution().isSameTree(TreeNode(1), TreeNode(2))) # False
#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
testcase()/** 0100.1 - Same Tree - Solution 1 - Recursive DFS */
/////////////////////////////////////////////////////////////////////////////////////
// Classes
/////////////////////////////////////////////////////////////////////////////////////
class TreeNode {
constructor(val = 0, left = null, right = null) {
this.val = val;
this.left = left;
this.right = right;
}
}
class Solution {
/** Same Tree Function */
isSameTree(p, q) {
if (!p || !q) return p === q;
return (
p.val === q.val &&
this.isSameTree(p.left, q.left) &&
this.isSameTree(p.right, q.right)
);
}
}
/////////////////////////////////////////////////////////////////////////////////////
// Functions
/////////////////////////////////////////////////////////////////////////////////////
function testcase() {
const solution = new Solution();
console.log(solution.isSameTree(new TreeNode(1), new TreeNode(1))); // true
console.log(solution.isSameTree(new TreeNode(1), new TreeNode(2))); // false
}
/////////////////////////////////////////////////////////////////////////////////////
// Main
/////////////////////////////////////////////////////////////////////////////////////
testcase();/** 0100.1 - Same Tree - Solution 1 - Recursive DFS */
/////////////////////////////////////////////////////////////////////////////////////
// Classes
/////////////////////////////////////////////////////////////////////////////////////
class TreeNode {
constructor(
public val: number = 0,
public left: TreeNode | null = null,
public right: TreeNode | null = null,
) {}
}
class Solution {
/** Same Tree Function */
isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
if (!p || !q) return p === q;
return (
p.val === q.val &&
this.isSameTree(p.left, q.left) &&
this.isSameTree(p.right, q.right)
);
}
}
/////////////////////////////////////////////////////////////////////////////////////
// Functions
/////////////////////////////////////////////////////////////////////////////////////
function testcase(): void {
const solution = new Solution();
console.log(solution.isSameTree(new TreeNode(1), new TreeNode(1))); // true
console.log(solution.isSameTree(new TreeNode(1), new TreeNode(2))); // false
}
/////////////////////////////////////////////////////////////////////////////////////
// Main
/////////////////////////////////////////////////////////////////////////////////////
testcase();// 0100.1 - Same Tree - Solution 1 - Recursive DFS
package main
/////////////////////////////////////////////////////////////////////////////////////
// Imports
/////////////////////////////////////////////////////////////////////////////////////
import "fmt"
/////////////////////////////////////////////////////////////////////////////////////
// Structs
/////////////////////////////////////////////////////////////////////////////////////
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
/////////////////////////////////////////////////////////////////////////////////////
// Functions
/////////////////////////////////////////////////////////////////////////////////////
func isSameTree(p *TreeNode, q *TreeNode) bool {
if p == nil || q == nil {
return p == q
}
return p.Val == q.Val && isSameTree(p.Left, q.Left) && isSameTree(p.Right, q.Right)
}
func testcase() {
fmt.Println(isSameTree(&TreeNode{Val: 1}, &TreeNode{Val: 1})) // true
fmt.Println(isSameTree(&TreeNode{Val: 1}, &TreeNode{Val: 2})) // false
}
/////////////////////////////////////////////////////////////////////////////////////
// Main
/////////////////////////////////////////////////////////////////////////////////////
func main() {
testcase()
}// 0100.1 - Same Tree - Solution 1 - Recursive DFS
/////////////////////////////////////////////////////////////////////////////////////
// Structs
/////////////////////////////////////////////////////////////////////////////////////
#[derive(Debug)]
struct TreeNode {
val: i32,
left: Option<Box<TreeNode>>,
right: Option<Box<TreeNode>>,
}
struct Solution;
impl Solution {
pub fn is_same_tree(p: &Option<Box<TreeNode>>, q: &Option<Box<TreeNode>>) -> bool {
match (p, q) {
(None, None) => true,
(Some(a), Some(b)) => {
a.val == b.val
&& Solution::is_same_tree(&a.left, &b.left)
&& Solution::is_same_tree(&a.right, &b.right)
}
_ => false,
}
}
}
fn main() {
let a = Some(Box::new(TreeNode { val: 1, left: None, right: None }));
let b = Some(Box::new(TreeNode { val: 1, left: None, right: None }));
println!("{}", Solution::is_same_tree(&a, &b));
}