从上往下打印二叉树

题目：从上往下打印出二叉树的每个结点，同一层的结点按照从左到右的顺序打印。

思路:每一次打印一个结点的时候，如果该结点有子结点，则把该结点的子结点放到一个队列的末尾。接下来到队列的头部取出最早进入队列的结点，重复前面的打印操作，直至队列中所有的结点都被打印出来为止。

#include "stdafx.h"
#include<stdio.h>
#include<deque>
#include<tchar.h>

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

BinaryTreeNode* CreateBinaryTreeNode(int value)
{
    BinaryTreeNode* pNode = new BinaryTreeNode();
    pNode->m_nValue = value;
    pNode->m_pLeft = NULL;
    pNode->m_pRight = NULL;
}

void ConnectTreeNodes(BinaryTreeNode* pParent, BinaryTreeNode* pLeft, 
                    BinaryTreeNode* pRight)
{
    if(pParent != NULL)
    {
        pParent->m_pLeft = pLeft;
        pParent->m_pRight = pRight;
    }
}

void PrintTreeNode(BinaryTreeNode* pNode)
{
    if(pNode != NULL)
    {
        printf("value of this node is: %d
", pNode->m_nValue);
        
        if(pNode->m_pLeft != NULL)
            printf("value of its left child is: %d.
", pNode->m_pLeft->m_nValue);
        else
            printf("left child is null.
");
        
        if(pNode->m_pRight != NULL)
            printf("value of its right child is: %d.
",pNode->m_pRight->m_nValue);
        else
            printf("right child is null.
");
    }
    else
    {
        printf("this node is null.
");
    }
    printf("
");
}

void PrintTree(BinaryTreeNode* pRoot)
{
    PrintTreeNode(pRoot);
    
    if(pRoot != NULL)
    {
        if(pRoot->m_pLeft != NULL)
            PrintTree(pRoot->m_pLeft);
        
        if(pRoot->m_pRight != NULL) 
            PrintTree(pRoot->m_pRight);
    }
}

void DestroyTree(BinaryTreeNode* pRoot)
{
    if(pRoot != NULL)
    {
        BinaryTreeNode* pLeft = pRoot->m_pLeft;
        BinaryTreeNode* pRight = pRoot->m_pRight;
        
        delete pRoot;
        pRoot = NULL;
        
        DestroyTree(pLeft);
        DestroyTree(pRight);
    }
}


void PrintFromTopToBottom(BinaryTreeNode* pRoot)
{
    if(pRoot == NULL)
        return;
        
    std::deque<BinaryTreeNode *> dequeTreeNode;
    
    dequeTreeNode.push_back(pRoot);
    
    while(dequeTreeNode.size())
    {
        BinaryTreeNode *pNode = dequeTreeNode.front();
        dequeTreeNode.pop_front();
        
        printf("%d ", pNode->m_nValue);
        
        if(pNode->m_pLeft)
            dequeTreeNode.push_back(pNode->m_pLeft);
        
        if(pNode->m_pRight)
            dequeTreeNode.push_back(pNode->m_pRight);
    }
}

//            10
//         /      
//        6        14
//       /        /
//      4  8     12  16

int main()
{
    BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10);
    BinaryTreeNode* pNode6  = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode14 = CreateBinaryTreeNode(14);
    BinaryTreeNode* pNode4  = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode8  = CreateBinaryTreeNode(8);
    BinaryTreeNode* pNode12 = CreateBinaryTreeNode(12);
    BinaryTreeNode* pNode16 = CreateBinaryTreeNode(16);
    
    ConnectTreeNodes(pNode10, pNode6, pNode14);
    ConnectTreeNodes(pNode6, pNode4, pNode8);
    ConnectTreeNodes(pNode14, pNode12, pNode16);
    
    PrintTree(pNode10);
    
    printf("The nodes from top to bottom, from left to right are: 
");
    PrintFromTopToBottom(pNode10);
    
    printf("

");
}