C++ (Cpp) Solution::flatten Examples

Example #1

File: FlattenBinaryTreeToLinkedList.cpp Project: GQHero/LeetCode

int main()
{
	Solution sln;
	TreeNode *root, *cur;
	//vector<int> result;
	root = cur = new TreeNode(1);
	cur->left = new TreeNode(2);
	cur->right = new TreeNode(7);
	cur = cur->left;
	cur->left = new TreeNode(3);
	cur->right = new TreeNode(6);
	cur = cur->left;
	cur->left = new TreeNode(4);
	cur->right = new TreeNode(5);
	sln.flatten(root);
	for (cur = root; cur; cur = cur->right)
	{
		cout << cur->val << endl;
	}
	cout << "=====================" << endl;
	root = cur = new TreeNode(1);
	cur->right = new TreeNode(2);
	sln.flatten(root);
	for (cur = root; cur; cur = cur->right)
	{
		cout << cur->val << endl;
	}
	return 0;
}

Example #2

File: flatten2.cpp Project: baotiao/Asenal

int main()
{
    #ifdef DEBUG
    freopen("a", "r", stdin);
    #endif
    int T;
    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 *head = r1;
    r1->left = r2;
    //r1->right = r5;
    r2->left = r3;
    //r2->right = r4;
    //r5->right = r6;

    s->flatten(r1);

    //sleep(100);
    //r1 = head;
    while (r1 != NULL) {
        debug(r1->val);
        r1 = r1->right;
    }
    return 0;
}

Example #3

File: Source.cpp Project: Qualia-Li/LeetCode-C-

void main() {

	TreeNode a(5);
	TreeNode b1(4);
	TreeNode b2(8);
	TreeNode c1(11);
	TreeNode c2(13);
	TreeNode c3(4);
	TreeNode d1(7);
	TreeNode d2(2);
	TreeNode d3(5);
	TreeNode d4(1);

	a.left = &b1;
	a.right = &b2;
	b1.left = &c1;
	b2.left = &c2;
	b2.right = &c3;
	c1.left = &d1;
	c1.right = &d2;
	c3.left = &d3;
	c3.right = &d4;

	Solution s;
	s.flatten(&d4);

	system("pause");
}

Example #4

File: flattenTree.cpp Project: HongbiaoYang/leetcode_cpp

int main(int argc, char** argv)
{
	cout<<"flatten tree"<<"\n";

	TreeNode* root;
	root = new TreeNode(1);
	TreeNode *n2, *n3, *n4, *n5, *n6;
	n2 = new TreeNode(2);

	/*
	n3 = new TreeNode(3);
	n4 = new TreeNode(4);
	n5 = new TreeNode(5);
	n6 = new TreeNode(6);

	root->left = n2;
	root->right = n5;
	n2->left = n3;
	n2->right = n4;
	n5->right = n6;
	*/

	root->right = n2;

	Solution sln;

	sln.flatten(root);	

	
	return 0;
	
}

Example #5

File: flatten_binary_tree_to_linked_list.cpp Project: kaushikacharya/cpp_practise

int main(int argc, char* argv[])
{
    TreeNode* root = create_binary_tree();
    Solution sln;
    sln.flatten(root);
    return 0;
}

Example #6

File: Flatten Binary Tree to Linked List.cpp Project: printfchan/Leetcode

int main()
{
	TreeNode *root = NULL;
	root = new TreeNode(1);
	/*root->left = new TreeNode(2);
	root->right = new TreeNode(7);
	root->left->left = new TreeNode(3);
	root->left->right = new TreeNode(4);
	root->left->right->left = new TreeNode(5);
	root->left->right->right = new TreeNode(6);
	root->right->left = new TreeNode(8);
	root->right->right = new TreeNode(9);
	root->right->right = new TreeNode(10);*/

	root->left = new TreeNode(2);
	root->left->left = new TreeNode(3);
	root->left->right = new TreeNode(4);
	root->left->left->left = new TreeNode(5);

	Solution solution;
	solution.flatten(root);


	system("pause");
	return 0;
}

Example #7

File: 114_FlattenBinaryTree.cpp Project: P-Chao/leetcode

int main(int argc, char *argv[]){
	Solution s;
	auto t = BuildTree(vector<int>{1, 2, 3, 4});
	s.flatten(t);
	PrintTree(t);
	system("pause");
	return 0;
}

Example #8

File: FlattenBinaryTree2LinkedList.c Project: charnugagoo/LeetCode

int main() {
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    Solution p;
    p.flatten(root);
    see(root->val);
    see(root->right->val);
}

Example #9

File: main.cpp Project: hzy001/leetcode-round1

int main(int argc, const char * argv[]) {
    // insert code here...
    Solution so;
    TreeNode* root;
    root = new TreeNode(1);
    root->right = new TreeNode(2);
    so.flatten(root);
    return 0;
}

Example #10

int main()
{
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2); root->right = new TreeNode(3);
    root->left->left = new TreeNode(5); root->left->right = new TreeNode(4);
    root->right->left = new TreeNode(9); root->right->right = new TreeNode(7);
    Solution sol; sol.flatten(root);
    return 0;
}

Example #11

File: flatten_binary_tree_to_linked_list.cpp Project: zsmountain/leetcode

int main() {
    Solution s;
    vector<int> preorder({1, 2, 3, 4, 5, 6}), inorder({3, 2, 4, 1, 5, 6});
    TreeNode *root = buildTree(preorder, inorder);
    root->print();
    s.flatten(root);
    root->print();
    return 0;
}

Example #12

File: 114 LL.cpp Project: CaptainCan/Leetcode

/*
idea: first-order recursive and flatten
complexity: O(N)
*/
int main(void)
{
	TreeNode *root;
	root = new TreeNode(1);
	root->left = new TreeNode(2);
	root->right = new TreeNode(3);
	Solution engine;
	engine.flatten(root);
	return 0;
}

Example #13

File: Flatten_Binary_Tree_to_Linked_List.cpp Project: jintaoguan/leetcode_CPP

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
	int len = sizeof(arr) / sizeof(arr[0]);
	TreeNode* root = CreateBT( arr, 0, len - 1 );
	Solution so;
	cout << "!!!!!" << endl;
	so.flatten( root );
	levelorder( root );
	return 0;
}

Example #14

File: FlattenBinaryTreetoLinkedList.cpp Project: hiberabyss/octopress-blog

int main(int argc, char *argv[]) {
    Solution sol;
    {
        string tree = "1,2,5,3,4,#,6";
        auto root = deserialBTree(tree);
        printPretty(root, 1, 1, cout);
        sol.flatten(root);
        printPretty(root, 1, 1, cout);
    }
    return 0;
}

Example #15

File: flattenBT2LL_unittest.cpp Project: chaishi/problems

TEST(flattenBT2LL_Test, Positive01){
    Solution s;

    TreeNode *root = constructBT();
    TreeNode *expected = constructFlattenLL();
    s.flatten(root);

    EXPECT_TRUE(assertLL(expected, root));

    deleteLL(expected);
    deleteLL(root);
}

Example #16

File: Flatten_Binary_Tree_to_Linked_List.cpp Project: jacky-huiyao/LeetCode

int main()
{
    TreeNode *p = new TreeNode(1);
    p->left = new TreeNode(2);
    p->right = new TreeNode(5);
    p->left->left = new TreeNode(3);
    p->left->right = new TreeNode(4);
    p->right->right = new TreeNode(6);

    Solution sol;
    sol.flatten(p);
    dfs(p);
    return 0;
}

Example #17

File: FlattenBinaryTreetoLinkedList.cpp Project: kamalcoder/leetcode-1

int main() {
    Solution sol;
    TreeNode * p0;

    {
        p0 = new TreeNode(1);
        p0->left = new TreeNode(2);
        p0->right = new TreeNode(5);
        p0->left->left = new TreeNode(3);
        p0->left->right = new TreeNode(4);
        p0->right->right = new TreeNode(6);
        sol.flatten(p0);
        cout << toString(p0) << endl;
    }
}

Example #18

File: flatten_binary_tree_to_linked_list.cpp Project: liangf/lc150

int main()
{
	TreeNode *root = new TreeNode(1);
	root->left = new TreeNode(2);
	root->right = new TreeNode(5);
	root->left->left = new TreeNode(3);
	root->left->right = new TreeNode(4);

	Solution s;
	s.flatten(root);
	while (root) {
		cout << root->val << endl;
		root = root->right;
	}
}

Example #19

File: Flatten Binary Tree to Linked List__dfs__没搞定__含other.cpp Project: wangzhe330/leetcode

void main()
{
	TreeNode Root(0);
	TreeNode temp0(7);
	TreeNode temp1(3);
	TreeNode temp2(1);
	TreeNode temp3(3);
	TreeNode temp4(-2);
	TreeNode temp5(7);
	TreeNode temp6(-1);
	TreeNode temp7(1);

	TreeNode Root2(1);
	TreeNode temp8(2);
	TreeNode temp9(2);

	//Root2.left = &temp8;
	Root2.right = &temp9;

	//Root.left = &temp0;
	//Root.right = &temp1;
	//Root.left->left = &temp2;
	//Root.left->right = &temp3;
	//Root.right->left = &temp4;
	//Root.left->left->left = &temp6;
	//Root.left->left->right = &temp6;
	//Root.right->right->right = &temp7;

	Solution mySolu;
	
	//cout << mySolu.isSameTree(&Root,&Root2) << endl;
	/*
	if (mySolu.isSameTree(&Root, &Root2))
		cout << "yse " << endl;
	else
		cout << "no " << endl;
		*/
	TreeLinkNode Root3(1);
	TreeLinkNode Root3_1(2);
	TreeLinkNode Root3_2(2);
	Root3.left = &Root3_1;
	//Root3.right = &Root3_2;


	mySolu.flatten(&Root2);
	cout << "ok" << endl;
}

Example #20

File: flatten_binary_tree_to_linked_list_114.cpp Project: dandanJing/leetcode

void let_114(){
	TreeNode* root=(TreeNode*)new TreeNode(1);
	TreeNode* node1=(TreeNode*)new TreeNode(2);
	TreeNode* node2=(TreeNode*)new TreeNode(5);
	TreeNode* node3=(TreeNode*)new TreeNode(3);
	TreeNode* node4=(TreeNode*)new TreeNode(4);
	TreeNode* node5=(TreeNode*)new TreeNode(6);
	root->left=node1;
	root->right=node2;
	node1->left=node3;
	node1->right=node4;
	node2->right=node5;
	Solution sol;
	sol.flatten(root);
	while(root) {cout<<root->val<<"->";root=root->right;}
	cout<<endl;
}

Example #21

File: main.cpp Project: SynoNeilHuang/LeetCode

int main(void) {
    TreeNode *first = new TreeNode(1);
    TreeNode *second = new TreeNode(2);
    TreeNode *three = new TreeNode(3);
    TreeNode *four = new TreeNode(4);
    TreeNode *five = new TreeNode(5);
    TreeNode *six = new TreeNode(6);
    first->left = second;
    first->right = five;
    second->left = three;
    second->right = four;
    five->right = six;
    Solution* test = new Solution();
    test->flatten(first);

    return 0;
}

Example #22

File: flatten-binary-tree-to-linked-list.cpp Project: yuanhui-yang/LeetCode-Online-Judge

int main(void) {
	Solution solution;
	TreeNode *root = new TreeNode(1);
	root->left = new TreeNode(2);
	root->right = new TreeNode(5);
	root->left->left = new TreeNode(3);
	root->left->right = new TreeNode(4);
	root->right->right = new TreeNode(6);
	solution.flatten(root);
	TreeNode *current = root;
	while (current) {
		cout << current->val << '\t';
		current = current->right;
	}
	cout << "\nPassed\n";
	cout << "\nPassed All\n";
	return 0;
}

Example #23

File: Flatten.cpp Project: hustwcw/ACM

int main(void)
{
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->left->left = new TreeNode(3);
    root->left->right = new TreeNode(4);
    root->right = new TreeNode(5);
    root->right->right = new TreeNode(6);
	Solution s;
	s.flatten(root);
    while(root != NULL)
    {
        cout << root->val << endl;
        root = root->right;
    }

	return 0;
}

Example #24

File: flatten-binary-tree-to-linked-list.cpp Project: AndreMouche/algorithm-solution

int main(){
	Solution sol ; 
	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);

	a->left = b ; 
	b->left = c ; 
	b->right = d ; 
	c->left = e ; 

	sol.flatten(a);
	for(TreeNode *p = a ; p!=NULL; p = p->right){
		cout << "#### :" << p->val << endl ;
	}
	return 0 ;
}

Example #25

File: flatten-binary-tree-to-linked-list-114.cpp Project: qianlv/learning

int main(void)
{
    TreeNode* tmp = NULL;
    TreeNode* root = new TreeNode(1);
    tmp = root;

    tmp->left = new TreeNode(2);
    tmp = tmp->left;

    tmp->left= new TreeNode(3);
    tmp->right = new TreeNode(4);
    tmp = tmp->left;

    tmp->left = new TreeNode(5);
    //output(root);
    Solution sol;
    sol.flatten(root);
    output(root);
    return 0;
}

Example #26

File: [LeetCode]Flatten Binary Tree to Linked List.cpp Project: Callmedoby/ACM_LeetCode

int main(void){
	Solution answer;
	TreeNode *root = new TreeNode(1);
	TreeNode *node = new TreeNode(2);
	root->left = node;
	TreeNode *node1 = new TreeNode(3);
	root->right = node1;
	TreeNode *node2 = new TreeNode(4);
	node->left = node2;
	TreeNode *node3 = new TreeNode(5);
	node2->right = node3;
	answer.flatten(root);
	while (root != NULL){
		cout << root->val;
		if (root->left == NULL)
			cout << endl;
		root = root->right;
	}
	system("Pause");
	return 0;
}

Example #27

File: Flatten_Binary_Tree.cpp Project: litaoshao/algorithm

int main(){
    
    TreeNode t1(1);
    TreeNode t2(2);
    TreeNode t3(3);
    TreeNode t4(4);
    TreeNode t5(5);
    TreeNode t6(6);

    t1.left = &t2;
    t1.right = &t5;
    //t2.left = &t3;
    //t2.right = &t4;
    //t5.left = &t6;

    Solution s;
    s.flatten(&t1);

    TreeNode * root = &t1;
    while(root != NULL){
        cout << root->val << endl;
        root = root->right;
    }
}