Example #1
0
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;
}
Example #9
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;
}
Example #10
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);
}
Example #12
0
int main(){
    TreeNode* root = initialize();

    Solution solution;
    bool res = solution.isBalanced(root);

    cout << res << endl;
    return 0;
}
Example #13
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;
}
Example #14
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;
}
Example #17
0
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;
}
Example #20
0
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));

}
Example #23
0
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;
}
Example #24
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;
}
Example #25
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;
}
Example #27
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;
}