Print the binary tree in the order of the zigzag. Print binary tree in the order of zigzag

question:

Implement a function that prints a binary tree in the shape of the first row in Left-to-right order, the second layer in Right-to-left order, and the third line in Left-to-right order, and so on. For example:

Analysis:

Always traverse the binary tree according to the breadth precedence, but it needs to be printed according to the glyph:

Odd rows from left to right, the same as the BFS traversal order, while even rows from right to left, and BFS traversal order.

So it can be realized by two stacks, one realizes FIFO first, that is the right sub node and Zoozi node in the stack order, and one realizes LIFO, that is the Zoozi node and right child node in the stack order.

The detailed implementation code is as follows:

Return the tree-printed glyph void print (binarytreenode* proot) {if (Proot = NULL).
    Std::stack<binarytreenode*> levels[2];
    int current = 0;

    int next = 1;
    Levels[current].push (Proot);
        while (!levels[0].empty () | | |!levels[1].empty ()) {binarytreenode* Pnode = Levels[current].top ();

        Levels[current].pop ();

        printf ("%d", pnode->m_nvalue); 
            if (current = = 0) {if (pnode->m_pleft!= NULL) Levels[next].push (pnode->m_pleft);
        if (pnode->m_pright!= NULL) Levels[next].push (pnode->m_pright); 
            else {if (pnode->m_pright!= NULL) Levels[next].push (pnode->m_pright);
        if (pnode->m_pleft!= NULL) Levels[next].push (pnode->m_pleft);
            } if (Levels[current].empty ()) {printf ("\ n");
            current = 1-current;
 Next = 1-next;       }//8/6/5 7 9 Test1 () {binarytreenode* PNode8 = Cr
    Eatebinarytreenode (8);
    binarytreenode* PNode6 = Createbinarytreenode (6);
    binarytreenode* PNode10 = Createbinarytreenode (10);
    binarytreenode* PNODE5 = Createbinarytreenode (5);
    binarytreenode* PNode7 = Createbinarytreenode (7);
    binarytreenode* PNode9 = Createbinarytreenode (9);

    binarytreenode* pNode11 = Createbinarytreenode (11);
    Connecttreenodes (PNode8, PNode6, PNode10);
    Connecttreenodes (PNode6, PNODE5, PNode7);

    Connecttreenodes (PNode10, PNode9, PNODE11);
    printf ("====test1 begins: ====\n");
    printf ("Expected result is:\n");
    printf ("8 \ n");
    printf ("6 \ n");

    printf ("5 7 9 one \ n");
    printf ("Actual result is: \ n");
    Print (PNODE8);

    printf ("\ n");
Destroytree (PNODE8); }//5/4//3//2 void Test2 () {binarytreenode* PNODE5 = Createbinarytreenode (5)
    ; Binarytreenode* pNode4 = Createbinarytreenode (4);
    binarytreenode* pNode3 = Createbinarytreenode (3);

    binarytreenode* PNode2 = Createbinarytreenode (2);
    Connecttreenodes (PNODE5, PNode4, NULL);
    Connecttreenodes (PNode4, PNode3, NULL);

    Connecttreenodes (PNode3, PNode2, NULL);
    printf ("====test2 begins: ====\n");
    printf ("Expected result is:\n");
    printf ("5 \ n");
    printf ("4 \ n");
    printf ("3 \ n");

    printf ("2 \ n");
    printf ("Actual result is: \ n");
    Print (PNODE5);

    printf ("\ n");
Destroytree (PNODE5); }//5//4//3//2 void Test3 () {binarytreenode* PNODE5 = Createbinarytreenode (
    5);
    binarytreenode* pNode4 = Createbinarytreenode (4);
    binarytreenode* pNode3 = Createbinarytreenode (3);

    binarytreenode* PNode2 = Createbinarytreenode (2);
    Connecttreenodes (PNODE5, NULL, PNODE4);
    Connecttreenodes (PNode4, NULL, pNode3);

    Connecttreenodes (PNode3, NULL, PNode2); printf ("====test3 begins: = =\ n ");
    printf ("Expected result is:\n");
    printf ("5 \ n");
    printf ("4 \ n");
    printf ("3 \ n");

    printf ("2 \ n");
    printf ("Actual result is: \ n");
    Print (PNODE5);

    printf ("\ n");
Destroytree (PNODE5);

    } void Test4 () {binarytreenode* PNODE5 = Createbinarytreenode (5);
    printf ("====test4 begins: ====\n");
    printf ("Expected result is:\n");

    printf ("5 \ n");
    printf ("Actual result is: \ n");
    Print (PNODE5);

    printf ("\ n");
Destroytree (PNODE5);
    } void Test5 () {printf ("====TEST5 begins: ====\n");

    printf ("Expected result is:\n");
    printf ("Actual result is: \ n");
    Print (NULL);
printf ("\ n"); }///////////////////////Test6 () {binarytreenode* pNode100 = Crea
    Tebinarytreenode (100);
    binarytreenode* PNode50 = Createbinarytreenode (50);

    binarytreenode* pNode150 = Createbinarytreenode (150);
    Connecttreenodes (pNode100, PNode50, NULL); Connecttreenodes (PNode50, NULL, pNode150);
    printf ("====test6 begins: ====\n");
    printf ("Expected result is:\n");
    printf ("\ n");
    printf ("\ n");

    printf ("F \ n");
    printf ("Actual result is: \ n");
    Print (pNode100);
printf ("\ n"); //8/4/2 6//1 3 5 7 9 m void
    Test7 () {binarytreenode* pNode8 = Createbinarytreenode (8);
    binarytreenode* pNode4 = Createbinarytreenode (4);
    binarytreenode* pNode12 = Createbinarytreenode (12);
    binarytreenode* PNode2 = Createbinarytreenode (2);
    binarytreenode* PNode6 = Createbinarytreenode (6);
    binarytreenode* PNode10 = Createbinarytreenode (10);
    binarytreenode* pNode14 = Createbinarytreenode (14);
    binarytreenode* pNode1 = Createbinarytreenode (1);
    binarytreenode* pNode3 = Createbinarytreenode (3);
    binarytreenode* PNODE5 = Createbinarytreenode (5);
    binarytreenode* PNode7 = Createbinarytreenode (7); binarytreenode* PNode9 =Createbinarytreenode (9);
    binarytreenode* pNode11 = Createbinarytreenode (11);
    binarytreenode* pNode13 = Createbinarytreenode (13);

    binarytreenode* pNode15 = Createbinarytreenode (15);
    Connecttreenodes (PNode8, PNode4, pNode12);
    Connecttreenodes (PNode4, PNode2, pNode6);
    Connecttreenodes (PNode12, PNode10, PNODE14);
    Connecttreenodes (PNode2, PNode1, pNode3);
    Connecttreenodes (PNode6, PNODE5, PNode7);
    Connecttreenodes (PNode10, PNode9, PNODE11);

    Connecttreenodes (PNode14, PNode13, PNODE15);
    printf ("====test7 begins: ====\n");
    printf ("Expected result is:\n");
    printf ("8 \ n");
    printf ("4 \ n");
    printf ("2 6 \ n");

    printf ("9 7 5 3 1 \ n");
    printf ("Actual result is: \ n");
    Print (PNODE8);

    printf ("\ n");
Destroytree (PNODE8);
    int main (int argc, char* argv[]) {Test1 ();
    Test2 ();
    Test3 ();
    Test4 ();
    Test5 ();
    Test6 ();

	Test7 ();
return 0;

 }