【剑指offer】面试题23：从上往下打印二叉树

题目：从上往下打印出二叉树的每个结点，同一层的结点按照从左到右的顺序打印。例如输入图 4.5 中的二叉树，则依次打印出 8、6、10、5、7、9、11。
二叉树结点的定义如下：
typedef struct Node
{
   int m_nValue;
   Node *m_pLeft;
   Node *m_pRight;
}BTreeNode, *pBTreeNode;

 该题目相当于二叉树的层次遍历，需要队列为我们的辅助容器，用作保存结点。

因为按层打印的顺序决定了先打印根结点。所以先从树的根结点开始分析。

1、为了能够打印值为 8 的结点的两个子结点，我们应该在遍历到该结点时把值为 6 和 10 的两个结点保存到一个容器（队列）中。

2、按照从左往右的顺序，我们先取出值为 6 的结点，打印出值 6 之后，把它的左右孩子结点 5 和 7 放入数据容器中。

3、以此类推，直到把容器中的结点打印完。

具体过程的代码为：

// print nodes from top to buttom, from left to right
void PrintFromTopToButtom(BinaryTreeNode *pRoot)
{
    if(pRoot == NULL)
    {
        printf("This tree is NULL
");
        return;
    }  

    std::queue<BinaryTreeNode*> queueTreeNode;
    queueTreeNode.push(pRoot);

    while(!queueTreeNode.empty())
    {
        BinaryTreeNode *node = queueTreeNode.front();
        printf("%d ", node->m_nValue);
        queueTreeNode.pop();

        if(node->m_pLeft)
            queueTreeNode.push(node->m_pLeft);

        if(node->m_pRight)
            queueTreeNode.push(node->m_pRight);
    }
}

完整代码如下：

// PrintFromTopToButtom.cpp
#include "stdio.h"
#include <queue>

using namespace std;

typedef struct Node
{
   int m_nValue;
   struct Node *m_pLeft;
   struct Node *m_pRight;
}BinaryTreeNode;

BinaryTreeNode *CreateBinaryTreeNode(int val);
void ConnectTreeNodes(BinaryTreeNode *pRoot, BinaryTreeNode *pLeftNode, BinaryTreeNode *pRightNode);
void PreOrderBinaryTree(BinaryTreeNode *pRoot);
void DestroyTree(BinaryTreeNode *pRoot);
void PrintFromTopToButtom(BinaryTreeNode *pRoot);


BinaryTreeNode *CreateBinaryTreeNode(int val)
{
    BinaryTreeNode *pNewNode = new BinaryTreeNode;
    pNewNode->m_nValue = val;
    pNewNode->m_pLeft = NULL;
    pNewNode->m_pRight = NULL;

    return pNewNode;
}

void ConnectTreeNodes(BinaryTreeNode *pRoot, BinaryTreeNode *pLeftNode, BinaryTreeNode *pRightNode)
{
    pRoot->m_pLeft = pLeftNode;
    pRoot->m_pRight = pRightNode;
}

void PreOrderBinaryTree(BinaryTreeNode *pRoot)
{
    if(pRoot)
    {
        printf("%d ", pRoot->m_nValue);
        if(pRoot->m_pLeft)
            PreOrderBinaryTree(pRoot->m_pLeft);

        if(pRoot->m_pRight)
            PreOrderBinaryTree(pRoot->m_pRight);
    }
}

void DestroyTree(BinaryTreeNode *pRoot)
{
    if(pRoot)
    {
        if(pRoot->m_pLeft)
            DestroyTree(pRoot->m_pLeft);
        if(pRoot->m_pRight)
            DestroyTree(pRoot->m_pRight);

        delete pRoot;
        pRoot = NULL;
    }
}

// print nodes from top to buttom, from left to right
void PrintFromTopToButtom(BinaryTreeNode *pRoot)
{
    if(pRoot == NULL)
    {
        printf("This tree is NULL
");
        return;
    }
       

    std::queue<BinaryTreeNode*> queueTreeNode;
    queueTreeNode.push(pRoot);

    while(!queueTreeNode.empty())
    {
        BinaryTreeNode *node = queueTreeNode.front();
        printf("%d ", node->m_nValue);
        queueTreeNode.pop();

        if(node->m_pLeft)
            queueTreeNode.push(node->m_pLeft);

        if(node->m_pRight)
            queueTreeNode.push(node->m_pRight);
    }
}

// ====================测试代码====================
void Test(char *testName, BinaryTreeNode *pRoot)
{
    if(testName)
        printf("%s begins: 
", testName);

    printf("PreOrderBinaryTree: ");
    PreOrderBinaryTree(pRoot);
    printf("
");

    printf("The nodes from top to buttom, from left to right are:
");
    PrintFromTopToButtom(pRoot);
    printf("
");
}

//       8
//    /     
//   6      10
//  /     /   
// 5   7  9    11
void test1()
{
    BinaryTreeNode *pNode8 = CreateBinaryTreeNode(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);

    char str1[] = "test1";
    Test(str1, pNode8);
    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);

    char str2[] = "test2";
    Test(str2, pNode5);
    DestroyTree(pNode5);    
}


//      1
//       
//        2     
//         
//          3
//           
//            4
void test3()
{
    BinaryTreeNode *pNode1 = CreateBinaryTreeNode(1);
    BinaryTreeNode *pNode2 = CreateBinaryTreeNode(2);
    BinaryTreeNode *pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode *pNode4 = CreateBinaryTreeNode(4);

    ConnectTreeNodes(pNode1, NULL, pNode2);
    ConnectTreeNodes(pNode2, NULL, pNode3);
    ConnectTreeNodes(pNode3, NULL, pNode4);

    char str3[] = "test3";
    Test(str3, pNode1);
    DestroyTree(pNode1);    
}

// NULL
void test4()
{
    char str4[] = "test4";
    Test(str4, NULL);
}

int main(int argc, char const *argv[])
{
    test1();
    test2();
    test3();
    test4();

    return 0;
}

本文完。