检查两个二叉搜索树是否相同

给定两个二进制搜索树的根节点。任务是，如果两个二叉搜索树相同，则打印1；否则，打印0。如果两个树在结构上相同并且节点具有相同的值，则打印两个相同的树。

树1

树2

在上图中，Tree1和Tree2相同。

为了确定两棵树是否相同，我们需要同时遍历两棵树，而遍历时则需要比较数据和树的子级。

下面是检查两个BST是否相同的分步算法：

1. 如果两棵树都为空，则返回1。
2. 否则，如果两棵树都不为空
   • 检查根节点的数据(tree1-> data == tree2-> data)
   • 递归检查左子树，即调用sameTree(tree1-> left_subtree，tree2-> left_subtree)
   • 递归检查右子树，即调用sameTree(tree1-> right_subtree，tree2-> right_subtree)
   • 如果以上三个步骤返回的值为true，则返回1。
3. 否则返回0(一个为空，另一个不为空)。

下面是上述方法的实现：

C++

// C++ program to check if two BSTs
// are identical
  
#include 
using namespace std;
  
// BST node
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};
  
// Utility function to create a new Node
struct Node* newNode(int data)
{
    struct Node* node = (struct Node*)
        malloc(sizeof(struct Node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
  
    return node;
}
  
// Function to perform inorder traversal
void inorder(Node* root)
{
    if (root == NULL)
        return;
  
    inorder(root->left);
  
    cout << root->data << " ";
  
    inorder(root->right);
}
  
// Function to check if two BSTs
// are identical
int isIdentical(Node* root1, Node* root2)
{
    // Check if both the trees are empty
    if (root1 == NULL && root2 == NULL)
        return 1;
    // If any one of the tree is non-empty
    // and other is empty, return false
    else if (root1 != NULL && root2 == NULL)
        return 0;
    else if (root1 == NULL && root2 != NULL)
        return 0;
    else { // Check if current data of both trees equal
        // and recursively check for left and right subtrees
        if (root1->data == root2->data && isIdentical(root1->left, root2->left)
            && isIdentical(root1->right, root2->right))
            return 1;
        else
            return 0;
    }
}
  
// Driver code
int main()
{
    struct Node* root1 = newNode(5);
    struct Node* root2 = newNode(5);
    root1->left = newNode(3);
    root1->right = newNode(8);
    root1->left->left = newNode(2);
    root1->left->right = newNode(4);
  
    root2->left = newNode(3);
    root2->right = newNode(8);
    root2->left->left = newNode(2);
    root2->left->right = newNode(4);
  
    if (isIdentical(root1, root2))
        cout << "Both BSTs are identical";
    else
        cout << "BSTs are not identical";
  
    return 0;
}

Java

// Java program to check if two BSTs
// are identical
class GFG
{
  
// BST node
static class Node 
{
    int data;
    Node left;
    Node right;
};
  
// Utility function to create a new Node
static Node newNode(int data)
{
    Node node = new Node();
    node.data = data;
    node.left = null;
    node.right = null;
  
    return node;
}
  
// Function to perform inorder traversal
static void inorder(Node root)
{
    if (root == null)
        return;
  
    inorder(root.left);
  
    System.out.print(root.data + " ");
  
    inorder(root.right);
}
  
// Function to check if two BSTs
// are identical
static int isIdentical(Node root1, 
                       Node root2)
{
    // Check if both the trees are empty
    if (root1 == null && root2 == null)
        return 1;
          
    // If any one of the tree is non-empty
    // and other is empty, return false
    else if (root1 != null && 
             root2 == null)
        return 0;
    else if (root1 == null && 
             root2 != null)
        return 0;
    else 
    { 
        // Check if current data of both trees equal
        // and recursively check for left and right subtrees
        if (root1.data == root2.data && 
            isIdentical(root1.left, root2.left) == 1 && 
            isIdentical(root1.right, root2.right) == 1)
            return 1;
        else
            return 0;
    }
}
  
// Driver code
public static void main(String[] args)
{
    Node root1 = newNode(5);
    Node root2 = newNode(5);
    root1.left = newNode(3);
    root1.right = newNode(8);
    root1.left.left = newNode(2);
    root1.left.right = newNode(4);
  
    root2.left = newNode(3);
    root2.right = newNode(8);
    root2.left.left = newNode(2);
    root2.left.right = newNode(4);
  
    if (isIdentical(root1, root2)==1)
        System.out.print("Both BSTs are identical");
    else
        System.out.print("BSTs are not identical");
}
}
  
// This code is contributed by 29AjayKumar

Python3

# Python3 program to contrcut all unique
# BSTs for keys from 1 to n 
  
# Binary Tree Node 
""" A utility function to create a
new BST node """
class newNode: 
  
    # Construct to create a newNode 
    def __init__(self, data): 
        self.data = data
        self.left = None
        self.right = None
  
# Function to perform inorder traversal 
def inorder(root) :
  
    if (root == None): 
        return
  
    inorder(root.left) 
  
    print(root.data, end = " ") 
  
    inorder(root.right) 
  
# Function to check if two BSTs 
# are identical 
def isIdentical(root1, root2) :
  
    # Check if both the trees are empty 
    if (root1 == None and root2 == None) :
        return 1
          
    # If any one of the tree is non-empty 
    # and other is empty, return false 
    elif (root1 != None and root2 == None) :
        return 0
    elif (root1 == None and root2 != None) :
        return 0
    else: # Check if current data of both trees 
          # equal and recursively check for left 
          # and right subtrees 
        if (root1.data == root2.data and 
            isIdentical(root1.left, root2.left) 
            and isIdentical(root1.right, root2.right)) :
            return 1
        else:
            return 0
      
# Driver Code 
if __name__ == '__main__':
  
    root1 = newNode(5) 
    root2 = newNode(5) 
    root1.left = newNode(3) 
    root1.right = newNode(8) 
    root1.left.left = newNode(2) 
    root1.left.right = newNode(4) 
  
    root2.left = newNode(3) 
    root2.right = newNode(8) 
    root2.left.left = newNode(2) 
    root2.left.right = newNode(4) 
  
    if (isIdentical(root1, root2)): 
        print("Both BSTs are identical")
    else:
        print("BSTs are not identical")
  
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)

C#

// C# program to check if two BSTs
// are identical
using System;
  
class GFG
{
  
// BST node
class Node 
{
    public int data;
    public Node left;
    public Node right;
};
  
// Utility function to create a new Node
static Node newNode(int data)
{
    Node node = new Node();
    node.data = data;
    node.left = null;
    node.right = null;
  
    return node;
}
  
// Function to perform inorder traversal
static void inorder(Node root)
{
    if (root == null)
        return;
  
    inorder(root.left);
  
    Console.Write(root.data + " ");
  
    inorder(root.right);
}
  
// Function to check if two BSTs
// are identical
static int isIdentical(Node root1, 
                       Node root2)
{
    // Check if both the trees are empty
    if (root1 == null && root2 == null)
        return 1;
          
    // If any one of the tree is non-empty
    // and other is empty, return false
    else if (root1 != null && 
             root2 == null)
        return 0;
    else if (root1 == null && 
             root2 != null)
        return 0;
    else
    { 
        // Check if current data of both trees equal
        // and recursively check for left and right subtrees
        if (root1.data == root2.data && 
            isIdentical(root1.left, root2.left) == 1 && 
            isIdentical(root1.right, root2.right) == 1)
            return 1;
        else
            return 0;
    }
}
  
// Driver code
public static void Main(String[] args)
{
    Node root1 = newNode(5);
    Node root2 = newNode(5);
    root1.left = newNode(3);
    root1.right = newNode(8);
    root1.left.left = newNode(2);
    root1.left.right = newNode(4);
  
    root2.left = newNode(3);
    root2.right = newNode(8);
    root2.left.left = newNode(2);
    root2.left.right = newNode(4);
  
    if (isIdentical(root1, root2) == 1)
        Console.Write("Both BSTs are identical");
    else
        Console.Write("BSTs are not identical");
}
}
  
// This code is contributed by PrinciRaj1992

输出：

Both BSTs are identical