int main() { Solution solution; //Test cases { // true TreeNode n1(1), n2(2), n3(3), n4(4), n5(5); n1.left = &n2; n1.right = &n3; n2.left = &n4; n2.right = &n5; cout << solution.isBalanced(&n1) << endl; } { // false TreeNode n1(1), n2(2), n3(3), n4(4), n5(5); n1.left = &n2; n1.right = &n3; n2.left = &n4; n4.right = &n5; cout << solution.isBalanced(&n1) << endl; } //Error test cases from leetcode.com return 0; }
TEST(leetcode_110_balanced_binary_tree, Basic) { Solution *solution = new Solution(); EXPECT_TRUE(solution->isBalanced(tree_init({"1"}))); EXPECT_TRUE(solution->isBalanced(tree_init({"1", "2", "3"}))); // 1 // / \ // 2 3 // \ // 4 EXPECT_TRUE(solution->isBalanced(tree_init({"1", "2", "3", "#", "#", "#", "4"}))); // 1 // / \ // 2 3 // / \ // 4 5 // / // 6 EXPECT_FALSE(solution->isBalanced(tree_init({"1", "2", "3", "#", "#", "4", "5", "6"}))); // 1 // / \ // 2 3 // \ // 4 // \ // 5 EXPECT_FALSE(solution->isBalanced(tree_init({"1", "2", "3", "#", "#", "#", "4", "#", "5"}))); }
int main(int argc, char const *argv[]) { int array[] = {7, 3, 8}; Tree T; int i, Len, balanced; Solution s; Len = sizeof(array) / sizeof(array[0]); T = NULL; for (i = 0; i < Len; ++i) T = Insert(array[i], T); PreOrderTraverse(T); cout << endl; InOrderTraverse(T); cout << endl; PostOrderTraverse(T); cout << endl; balanced = s.isBalanced(T); cout << balanced << endl; return 0; }
int main() { TreeNode *r = new TreeNode(1); r->right = new TreeNode(2); Solution s; cout<<s.isBalanced(r); return 0; }
int main() { TreeNode *root = new TreeNode(1); Solution sol; cout<<sol.isBalanced(root)<<endl; }
void main() { Solution s; TreeNode n1(1), n2(2), n3(3); n1.right = &n2; n2.right = &n3; printf("%d\n", s.isBalanced(&n1)); }
int main() { TreeNode n1(0), n2(0), n3(0), n4(0); // n1.left = &n2; // n1.right = &n3; // n2.left = &n4; Solution sol; cout << sol.isBalanced(NULL); }
int main() { Solution sol; std::vector<int> tests = {1,2,2,3,4,5,6,7,8,9}; auto root = constructTreeByLevel(tests); printFullTree(root); std::cout << sol.isBalanced(root) << std::endl; return 0; }
int main(int argc, char* argv[]) { TreeNode* root = new TreeNode(1); root -> right = new TreeNode(2); root -> right -> right = new TreeNode(3); Solution s; cout << "Result: " << s.isBalanced(root) << endl; return 0; }
int main() { Solution sol; TreeNode* root = new TreeNode(1); root->right = new TreeNode(2); root->right->left = new TreeNode(3); if (!sol.isBalanced(root)) cout << "pass test 1"; cout << endl; }
void test(){ srand(time(NULL)); Solution work; TreeNode list[100]; int ans; vector<Node> data; data = { {0, 0, -1, -1}, {1, 1, 0, 0}, {2, 2, 0, 1}, }; memset(list, 0, sizeof(list)); born(data, list); output(list); ans = work.isBalanced(list); printf("ans=%d\n", ans); data = { {0, 0, -1, -1}, {1, 1, 0, 0}, {2, 2, 0, 1}, {3, 3, 2, 0}, }; memset(list, 0, sizeof(list)); born(data, list); output(list); ans = work.isBalanced(list); printf("ans=%d\n", ans); data = { {0, 0, -1, -1}, {1, 1, 0, 0}, {2, 2, 0, 1}, {3, 3, 2, 0}, {4, 4, 3, 1}, }; memset(list, 0, sizeof(list)); born(data, list); output(list); ans = work.isBalanced(list); printf("ans=%d\n", ans); }
int main(){ TreeNode* root = initialize(); Solution solution; bool res = solution.isBalanced(root); cout << res << endl; return 0; }
int main() { Solution s; vector<int> test = { 1, 2, 3, -1, -1, 4, 5 };//, -1, -1, 6, -1 auto root = lc_deserializetree(test, -1); cout << s.isBalanced(root) << endl; lc_destroytree(root); system("pause"); return 0; }
int main(int argc, char *argv[]) { TreeNode a(1),b(2),c(2),d(3),e(3),f(4),g(4); a.left=&b;a.right=&c; b.left=&d;d.left=&f; c.right=&e;e.right=&g; Solution s; cout<<s.isBalanced(&a); system("pause"); return 0; }
int main() { Solution sol; TreeNode t0(0),t1(1),t2(2),t3(3),t4(4),t5(5),t6(6),t7(7),t8(8),t9(9); t0.left=&t1,t0.right=&t2; //t1.left=&t3,t2.right=&t4; //t3.right=&t5,t4.left=&t6; bool ans = sol.isBalanced(&t0); cout<<ans<<endl; return 0; }
int main() { TreeNode *head = new TreeNode(1); head->left = new TreeNode(2); head->right = new TreeNode(3); head->left->left = new TreeNode(4); head->right->right = new TreeNode(5); Solution sol; cout<<sol.isBalanced(head)<<endl; }
int main() { Solution *sol = new Solution(); TreeNode *root1 = new TreeNode(21); TreeNode *n1 = new TreeNode(21); TreeNode *n2 = new TreeNode(21); root1->left = n1; root1->right = n2; bool num = sol->isBalanced(root1); std::cout << num << std::endl; }
int main() { Solution solution; TreeNode *p; p = new TreeNode(1); p->left = new TreeNode(2); p->right = new TreeNode(2); p->left->left = new TreeNode(3); p->left->left->left = new TreeNode(4); cout<<solution.isBalanced(p)<<endl; return 0; }
int main() { Solution s; TreeNode *a, *b; TreeNode root(1); a = new TreeNode(2); a->right = new TreeNode(3); root.left = a; cout<< s.isBalanced(&root)<<endl; return -1; }
int main() { //int arr[] = {1,2,4,-1,-1,5,-1,-1,3,6,-1,-1,7,-1,-1}; //int arr[] = {1,2,4,-1,-1,5,-1,-1,2,5,-1,-1,4,-1,-1}; int arr[] = {1,2,3,-1,-1,-1,-1}; TreeNode* root = 0; int index = 0; CreateBinaryTree(root, arr, index); PreOderTraverse(root); cout<<endl; Solution s; cout<<s.isBalanced(root); return 0; }
int main() { TreeNode* root = NULL; root = new TreeNode(1); root->left = new TreeNode(2); root->right = new TreeNode(3); root->right->left = new TreeNode(4); root->right->right = new TreeNode(5); //root->right->right->left = new TreeNode(6); Solution solution; cout << solution.isBalanced(root); system("pause"); return 0; }
int main(int argc, char **argv) { Solution *sol = new Solution(); TreeNode n0(0), n1(1), n2(2), n3(3), n4(4), n5(5), n6(6), n7(7), n8(8); n0.left = &n1; n0.right = &n2; n1.left = &n3; n1.right = &n4; n3.left = &n5; n3.right = &n6; // n7.left = &n8; printf("ret %d\n", sol->isBalanced(&n0)); }
int main(int argc, char const *argv[]) { TreeNode *root = new TreeNode(3); TreeNode *node1 = new TreeNode(9); TreeNode *node2 = new TreeNode(20); TreeNode *node3 = new TreeNode(15); TreeNode *node4 = new TreeNode(17); node2->left = node3; node2->right = node4; root->left = node1; root->right = node2; Solution *s = new Solution(); cout<<s->isBalanced(root)<<endl; return 0; }
int main() { Node* root = new Node(5, new Node(2, new Node(1), new Node(8, NULL, new Node(4))), new Node(7, new Node(6), new Node(9, new Node(3), NULL))); PrettyPrint(root); Solution solution; std::cout << solution.isBalanced(root) << std::endl; return 0; }
int main() { TreeNode *one = new TreeNode(1); TreeNode *two = new TreeNode(2); TreeNode *three = new TreeNode(3); one->right = two; one->left = NULL; two->right = three; two->left = NULL; three->left = three->right = NULL; Solution slt; cout << slt.calHeight(one)<<endl; cout << slt.calHeight(two) << endl; cout << slt.calHeight(three) << endl; if (slt.isBalanced(one)) cout << "true"; else cout << "false"; return 0; }
int main() { TreeNode t1(1), t2(2), t3(3), t4(4), t5(5), t6(6), t7(7), t8(8), t9(9); t4.left = &t2; t4.right = &t5; t2.left = &t1; t2.right = &t3; t5.right = &t9; t9.left = &t7; t7.left = &t6; t7.right = &t8; Solution s; bool ret = s.isBalanced(&t4); printf("Return value is %s\n", ret ? "true":"false"); return 0; }
int main() { #ifdef DEBUG freopen("a", "r", stdin); #endif Solution *s = new Solution(); TreeNode *r1 = new TreeNode(1); TreeNode *r2 = new TreeNode(2); TreeNode *r3 = new TreeNode(3); TreeNode *r4 = new TreeNode(4); TreeNode *r5 = new TreeNode(5); TreeNode *r6 = new TreeNode(6); TreeNode *r7 = new TreeNode(5); TreeNode *r8 = new TreeNode(6); r1->left = r2; r1->right = r3; r3->left = r4; r3->right = r5; bool ans = s->isBalanced(r1); debug(ans); return 0; }
int main() { Solution s; s.isBalanced(nullptr); return 0; }