LeetCode(100SameTree)

LeetCode(100SameTree)

#include <iostream>

using namespace std;

/**
Given two binary trees, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical and the nodes have the same value.

Example 1:

Input:     1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

Output: true

Example 2:

Input:     1         1
          /           \
         2             2

        [1,2],     [1,null,2]

Output: false

Example 3:

Input:     1         1
          / \       / \
         2   1     1   2

        [1,2,1],   [1,1,2]

Output: false
**/
//Definition for a binary tree node.
struct TreeNode {
    char val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(char x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
    void Create(TreeNode* &T)
    {
        char n;
        cin >> n;
        if(n == '*')T = NULL;
        else
        {
            T = new TreeNode(n);
            Create(T->left);
            Create(T->right);
        }
    }

   /* void PreOrder(TreeNode* T)
    {
        if(T)
         {
            visit(T);
            PreOrder(T->left);
            PreOrder(T->right);
         }
    }*/

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

    TreeNode* root1 = NULL, *root2 = NULL;
/*private:
    void visit(TreeNode* T)
    {
        if(T)
        {
            cout << T->val << " ";
        }
    }*/
};

int main()
{
    Solution su;
    su.Create(su.root1);
    su.Create(su.root2);
    cout << su.isSameTree(su.root1, su.root2);
   /* cout << endl;
    su.PreOrder(su.root1);
    cout << endl;
    su.PreOrder(su.root2);*/
    return 0;
}