TEST(case1, test1) {
Solution sol;
TreeNode* y;
y = new TreeNode(1);
y->left = new TreeNode(2);
EXPECT_EQ(false, sol.isSymmetric(y));
y = new TreeNode(1);
y->left = new TreeNode(2);
y->right = new TreeNode(2);
y->left->left = new TreeNode(3);
y->left->right = new TreeNode(4);
y->right->left = new TreeNode(4);
y->right->right = new TreeNode(3);
EXPECT_EQ(true, sol.isSymmetric(y));
}
int main()
{
TreeNode *root = new TreeNode(0);
Solution solution;
cout << solution.isSymmetric(root) << endl;
return 0;
}
void test_case_4() {
Solution solution;
TreeNode n1(1);
TreeNode n2(2);
n1.left = &n2;
cout << solution.isSymmetric(&n1) << endl;
};
int main(int argc, char** argv)
{
TreeNode a(1), b(2), c(2), d(3), e(4), f(4), g(3);
a.left = &b; a.right = &c;
b.left = &d; b.right = &e;
c.left = &f; c.right = &g;
Solution sol;
cout << sol.isSymmetric(&b);
return 0;
}
int main()
{
int a[] = {-1, 1, 2, 2, -1, 3, 3, -1};
int b[] = {-1, 1, -1, 2, -1, -1, 2};
TreeNode *t1 = makeTree(a, 7, 1);
TreeNode *t2 = makeTree(b, 6, 1);
Solution s;
cout << s.isSymmetric(t1) << endl;
return 0;
}
int main()
{
Solution c;
TreeNode *root;
int A[] = {0,1,1,1,2,2,2,2};
root = c.trans(A,1,sizeof(A)/4);
c.printTree(root);
printf("\n");
cout << (c.isSymmetric(root)? "true" : "false") << endl;
while(1);
return 1;
}
int main() {
Solution test;
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(2);
root->left->left = new TreeNode(3);
root->left->right = new TreeNode(4);
root->right->left = new TreeNode(4);
root->right->right = new TreeNode(3);
cout << test.isSymmetric(root) << endl;
return 0;
}
int main()
{
Node *root = new Node(5);
root->left = new Node(4); root->right = new Node(1);
root->left->right = new Node(1); root->right->right = new Node(4);
root->left->right->left = new Node(2); root->right->right->left = new Node(2);
if(g.isSymmetric(root))
printf("valid\n");
else
printf("invalid\n");
system("pause");
}
int main(int argc, char const *argv[])
{
int value1[] = {1};
TreeNode* root1 = arr2tree(value1,sizeof(value1)/sizeof(int));
Solution s;
bool result = s.isSymmetric(root1);
printf("%s\n",result?"true":"false" );
/* code */
return 0;
}
int main() {
freopen("test.txt", "r", stdin);
TreeNode* root = new TreeNode(-1);
TreeNode* node = new TreeNode(-2);
node->left = new TreeNode(-9);
TreeNode* node2 = new TreeNode(-2);
node2->right = new TreeNode(-9);
root->left = node;
root->right = node2;
Solution s;
cout << s.isSymmetric(root) << endl;
return 0;
}
int main(int argc, char const *argv[])
{
TreeNode *p = new TreeNode(1);
p->left = new TreeNode(2);
p->right = new TreeNode(3);
p->left->left = new TreeNode(3);
p->left->right = new TreeNode(4);
p->right->left = new TreeNode(2);
p->right->right = new TreeNode(3);
Solution sol;
cout<<sol.isSymmetric(p)<<endl;
return 0;
}
int main()
{
//int data1[] = {5,3,2,1,4,8,7,6,9,10};
//int data2[] = {1,2,3,4,5,6,7,8,9,10};
int data1[] = {1,2,3,4,2,4,3};
int data2[] = {3,2,4,1,4,2,3};
int n1 = sizeof(data1)/sizeof(data1[0]);
int n2 = sizeof(data2)/sizeof(data2[0]);
vector<int> preorder(data1,data1+n1);
vector<int> inorder(data2, data2+n2);
TreeNode* root = buildTree(preorder,inorder);
Solution test;
cout<<test.isSymmetric(root)<<endl;
}
int main(void){
Solution answer;
TreeNode *root = new TreeNode(1);
TreeNode *node = new TreeNode(3);
root->left = node;
TreeNode *node1 = new TreeNode(3);
root->right = node1;
TreeNode *node2 = new TreeNode(2);
node->left = node2;
TreeNode *node3 = new TreeNode(3);
node1->right = node3;
cout << answer.isSymmetric(root) << endl;
system("Pause");
return 0;
}
int main()
{
TreeNode* root = NULL;
root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(2);
root->left->right = new TreeNode(3);
root->right->left = new TreeNode(3);
Solution solution;
cout << solution.isSymmetric(root);
system("pause");
return 0;
}
int main() {
Solution s;
TreeNode *tn = new TreeNode(1);
// TreeNode *tl = new TreeNode(2);
// tn->left = tl;
// TreeNode *tr = new TreeNode(20);
// tn->right = tr;
// TreeNode *ttt = new TreeNode(15);
// tr->left = ttt;
// TreeNode *www = new TreeNode(7);
// ttt->right = www;
cout << s.isSymmetric(tn) << endl;
return 0;
}
int main()
{
TreeNode * a = new TreeNode(1);
TreeNode * b = new TreeNode(2);
TreeNode * c = new TreeNode(3);
TreeNode * d = new TreeNode(4);
TreeNode * e = new TreeNode(5);
b->left = c;
b->right = d;
a->left = b;
a->right = e;
Solution s;
cout << s.isSymmetric(a) << endl;
return 0;
}
void test(){
TreeNode* p[10];//array with pointer element
for(int i=1;i<7;++i)
{
p[i] = new TreeNode(i);
}
p[1]->left = p[2];
p[1]->right = p[5];
//p[2] ->left = p[3];
p[2]->val = 2;
p[5]->val = 2;
p[2] ->right = new TreeNode(3);
p[5]->right = new TreeNode(3);
Solution sol;
cout<<(sol.isSymmetric(p[1])? "Yes":"No")<<endl;;
}
int main(int argc, char const *argv[])
{
vector<string> trees = {
"1 2 3 # # 4 # # 2 4 # # 3 # #",
"1 2 # 3 # # 2 # 3 # #",
"2 3 4 # # 5 8 # # 9 # # 3 5 9 # # 8 # # 4 # #",
};
for (auto tree : trees) {
TreeNode *root = deserialize_tree(tree);
Solution sol;
SolutionIterative soli;
cout << sol.isSymmetric(root) << '\n';
cout << soli.isSymmetric(root) << '\n';
}
// level_order_cout(root);
return 0;
}
void main(){
Solution s;
TreeNode a(1);
TreeNode b(2);
TreeNode c(2);
TreeNode d(3);
TreeNode e(3);
a.left = &b;
b.right = &d;
a.right = &c;
c.right = &e;
cout << s.isSymmetric(&a);
system("pause");
}
void test_case_2() {
Solution solution;
TreeNode n1(1);
TreeNode n2(2);
TreeNode n3(2);
n1.left = &n2;
n1.right = &n3;
TreeNode n4(3);
n2.right = &n4;
TreeNode n6(3);
n3.right = &n6;
cout << solution.isSymmetric(&n1) << endl;
};
void let_101(){
TreeNode* root=(TreeNode*)new TreeNode(1);
TreeNode* node1=(TreeNode*)new TreeNode(2);
TreeNode* node2=(TreeNode*)new TreeNode(2);
TreeNode* node3=(TreeNode*)new TreeNode(3);
TreeNode* node4=(TreeNode*)new TreeNode(4);
TreeNode* node5=(TreeNode*)new TreeNode(4);
TreeNode* node6=(TreeNode*)new TreeNode(3);
root->left=node1;
root->right=node2;
node1->left=node3;
node1->right=node4;
node2->left=node5;
//node2->right=node6;
Solution sol;
cout<<sol.isSymmetric(root)<<endl;
node2->right=node6;
}
int main()
{
TreeNode r1(1);
TreeNode r2(2);
TreeNode r3(2);
TreeNode r4(3);
TreeNode r5(3);
TreeNode r6(4);
TreeNode r7(4);
r1.left=&r2;
r1.right=&r3;
r2.left=&r6;
r2.right=&r4;
r3.left=&r5;
r3.right=&r7;
Solution sol;
cout<<sol.isSymmetric(&r1)<<endl;
return 0;
}
int main() {
Solution s;
TreeNode *r = new TreeNode(1);
TreeNode *r1 = new TreeNode(2);
TreeNode *r2 = new TreeNode(2);
TreeNode *r3 = new TreeNode(3);
TreeNode *r4 = new TreeNode(3);
r1->left = r3;
r2->left = r4;
r->left = r1;
r->right = r2;
PrintMedOrder(r);
cout << endl;
cout << s.isSymmetric(r) << endl;
return 0;
}
int main()
{
Solution sol;
TreeNode root(2);
TreeNode n1(3);
TreeNode n2(3);
TreeNode n3(4);
TreeNode n4(4);
TreeNode n5(5);
root.left = &n1;
root.right = &n2;
n1.left = &n3;
n2.right = &n4;
/* n2.right = &n4; */
cout << sol.isSymmetric(&root) << endl;
return 0;
}
int main()
{
TreeNode a1(1);
TreeNode a2_l(2);
TreeNode a2_r(2);
TreeNode a3_l(3);
TreeNode a3_r(3);
TreeNode a4(4);
a1.left = &a2_l;
a2_l.right = &a3_l;
a1.right = &a2_r;
a2_r.right = &a3_r;
Solution s;
s.isSymmetric(&a1);
return 0;
}
void test_case_3() {
Solution solution;
TreeNode n1(1);
TreeNode n2(-42);
TreeNode n3(-42);
TreeNode n4(76);
TreeNode n5(76);
TreeNode n6(13);
TreeNode n7(13);
n1.left = &n2;
n1.right = &n3;
n2.right = &n4;
n3.left = &n5;
n4.right = &n6;
n5.right = &n7;
cout << solution.isSymmetric(&n1) << endl;
};
int main()
{
TreeNode a(1);
TreeNode b(2);
TreeNode c(2);
TreeNode d(3);
TreeNode e(4);
TreeNode f(3);
TreeNode g(4);
TreeNode h(3);
a.left = &b;
a.right = &c;
b.left = &d;
b.right = &e;
c.left = &g;
c.right = &f;
f.right = &h;
Solution s;
cout << s.isSymmetric(&a) << endl;
return 0;
}
int main()
{
Solution s;
bool ret;
TreeNode n1(1);
TreeNode n2(2);
TreeNode n3(2);
TreeNode n4(3);
TreeNode n5(4);
TreeNode n6(4);
TreeNode n7(3);
n1.left = &n2;
n1.right = &n3;
n2.left = &n4;
n2.right = &n5;
n3.left = &n6;
n3.right = &n7;
ret = s.isSymmetric(&n7);
cout << ret << endl;
}
