【leetcode】Same Tree和Balanced Binary Tree

#include<iostream>
#include<vector>
#include<deque>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val):val(val),left(NULL),right(NULL){};
};

class Solution //same tree
{
public:
    bool sametree(TreeNode* p,TreeNode*q)
    {
        deque<TreeNode*>result;
        result.push_back(p);
        result.push_back(q);
        while(!result.empty())
        {
            TreeNode* node1=result.front();
            result.pop_front();
            TreeNode* node2=result.front();
            result.pop_front();
            if(!node1&&!node2)
                continue;
            if(!node1||!node2)
                return false;
            if(node1->val!=node2->val)
                return false;
            result.push_back(node1->left);
            result.push_back(node2->left);
            result.push_back(node1->right);
            result.push_back(node2->right);
        }
        return true;
    }
};

class Solution1   //balance binary tree
{
public:
    int balanceHeight(TreeNode* root)
    {
        if(root==nullptr)
            return 0;
        int left=balanceHeight(root->left);
        int right=balanceHeight(root->right);
        if(left<0||right<0||abs(left-right)>1)
            return -1;
        return max(left,right)+1;
    }
    bool isbalance(TreeNode* root)
    {
        return balanceHeight(root)>=0;
    }
};

void main()
{
    TreeNode* node1=new TreeNode(6);
    TreeNode* node2=new TreeNode(2);
    TreeNode* node3=new TreeNode(4);
    TreeNode* node4=new TreeNode(1);
    TreeNode* node5=new TreeNode(3);
    TreeNode* node6=new TreeNode(5);
    TreeNode* node7=new TreeNode(7);
    node1->left=node2;
    node1->right=node3;
    node2->left=node4;
    node2->right=node5;
  /*  node3->left=node6;
    node3->right=node7;*/
   // Solution solution;
    //solution.recoverTree(node1);
    //solution.recover(node1);
    Solution1 solution;
    cout<<solution.isbalance(node1);
}