剑指offer-二叉树的层次遍历实现

 

BinaryTree.h

/*******************************************************************
Copyright(c) 2016, Tyrone Li
All rights reserved.
*******************************************************************/
// 作者:TyroneLi
//

typedef int ElemType;

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

BinaryTreeNode*createBinaryTreeNode(ElemType value);
void connectTreeNodes(BinaryTreeNode*pParent, BinaryTreeNode*pLeft, BinaryTreeNode*pRight);
void printTreeNode(const BinaryTreeNode*pNode);
void printNode(const BinaryTreeNode*pNode);
void printTree(const BinaryTreeNode*pRoot);
void printTreePreOrder(const BinaryTreeNode*pRoot);
void printTreeInOrder(const BinaryTreeNode*pRoot);
void printTreePostOrder(const BinaryTreeNode*pRoot);
void printTreeLevelOrder(BinaryTreeNode*pRoot);
void destroyTree(BinaryTreeNode*pRoot);

BinaryTree.cpp

/*******************************************************************
Copyright(c) 2016, Tyrone Li
All rights reserved.
*******************************************************************/
// 作者:TyroneLi
//

#include "BinaryTree.h"
#include <iostream>
#include <deque>
#include <cstdio>
#include <cstdlib>

typedef int ElemType;

BinaryTreeNode*createBinaryTreeNode(ElemType value)
{
    BinaryTreeNode*pNode = new BinaryTreeNode();
    pNode->m_nValue = value;
    pNode->m_pLeft = nullptr;
    pNode->m_pRight = nullptr;
    return pNode;
}

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

void printTreeNode(const BinaryTreeNode*pNode)
{
    if(pNode != nullptr)
    {
        std::cout << "Value of this node is " << pNode->m_nValue << std::endl;

        if(pNode->m_pLeft != nullptr)
        {
            std::cout << "Value of its left child is " << pNode->m_pLeft->m_nValue << std::endl;
        }else{
            std::cout << "left child is nullptr." << std::endl;
        }

        if(pNode->m_pRight != nullptr)
        {
            std::cout << "Value of its right child is " << pNode->m_pRight->m_nValue << std::endl;
        }else{
            std::cout << "right child is nullptr." << std::endl;
        }
    }else{
        std::cout << "this node is nullptr." << std::endl;
    }
}

void printTree(const BinaryTreeNode*pRoot)
{
    printTreeNode(pRoot);

    if(pRoot != nullptr)
    {
        if(pRoot->m_pLeft != nullptr)
            printTree(pRoot->m_pLeft);
        
        if(pRoot->m_pRight != nullptr)
            printTree(pRoot->m_pRight);
    }
}

void printNode(const BinaryTreeNode*pNode)
{
    if(pNode != nullptr)
        std::cout << pNode->m_nValue << " ";
}

void printTreePreOrder(const BinaryTreeNode*pRoot)
{
    printNode(pRoot);

    if(pRoot != nullptr)
    {
        if(pRoot->m_pLeft != nullptr)
            printTreePreOrder(pRoot->m_pLeft);
        
        if(pRoot->m_pRight != nullptr)
            printTreePreOrder(pRoot->m_pRight);
    }
}

void printTreeInOrder(const BinaryTreeNode*pRoot)
{
    if(pRoot != nullptr)
    {
        if(pRoot->m_pLeft != nullptr)
            printTreeInOrder(pRoot->m_pLeft);
    }

    printNode(pRoot);

    if(pRoot != nullptr)
    {
        if(pRoot->m_pRight != nullptr)
            printTreeInOrder(pRoot->m_pRight);
    }
}

void printTreePostOrder(const BinaryTreeNode*pRoot)
{
    if(pRoot != nullptr)
    {
        if(pRoot->m_pLeft != nullptr)
            printTreePostOrder(pRoot->m_pLeft);

        if(pRoot->m_pRight != nullptr)
            printTreePostOrder(pRoot->m_pRight);
    }

    printNode(pRoot);
}

void printTreeLevelOrder(BinaryTreeNode*pRoot)
{
    if(pRoot != nullptr)
    {
        BinaryTreeNode*pNode = pRoot;
        std::deque<BinaryTreeNode*> treeDeque;
        treeDeque.push_back(pRoot);
        while(treeDeque.size() > 0)
        {
            pNode = treeDeque.front();
            std::cout << pNode->m_nValue << " ";
            treeDeque.pop_front();
            if(pNode->m_pLeft)
                treeDeque.push_back(pNode->m_pLeft);
            if(pNode->m_pRight)
                treeDeque.push_back(pNode->m_pRight);
        }
    }
}

void destroyTree(BinaryTreeNode*pRoot)
{
    if(pRoot != nullptr)
    {
        BinaryTreeNode*pLeft = pRoot->m_pLeft;
        BinaryTreeNode*pRight = pRoot->m_pRight;

        delete pRoot;
        pRoot = nullptr;

        destroyTree(pLeft);
        destroyTree(pRight);

    }
}

test.cpp

/*******************************************************************
Copyright(c) 2016, Tyrone Li
All rights reserved.
*******************************************************************/
// 作者:TyroneLi
//

/*
Q:
    实二叉树的层次遍历算法。
S:
    使用一个辅助队列，当访问到根节点的时候，如果该根节点存在左右子树，则依次
    将他们压入队列尾部，然后再从队列头部弹出一个结点，访问其值。
    
*/

#include "../utils/BinaryTree.h"
#include <iostream>
#include <cstdio>
#include <cstdlib>

void test_1()
{
    std::cout << "multi nodes ad multi child branches" << std::endl;
    std::cout << "Print tree nodes in pre order" << std::endl;
    BinaryTreeNode*pRoot_1 = createBinaryTreeNode(1);
    BinaryTreeNode*pRoot_2 = createBinaryTreeNode(2);
    BinaryTreeNode*pRoot_3 = createBinaryTreeNode(3);
    BinaryTreeNode*pRoot_4 = createBinaryTreeNode(4);
    BinaryTreeNode*pRoot_5 = createBinaryTreeNode(5);
    BinaryTreeNode*pRoot_6 = createBinaryTreeNode(6);
    BinaryTreeNode*pRoot_7 = createBinaryTreeNode(7);
    BinaryTreeNode*pRoot_8 = createBinaryTreeNode(8);
    BinaryTreeNode*pRoot_9 = createBinaryTreeNode(9);
    BinaryTreeNode*pRoot_10 = createBinaryTreeNode(10);
    BinaryTreeNode*pRoot_11 = createBinaryTreeNode(11);
    BinaryTreeNode*pRoot_12 = createBinaryTreeNode(12);
    BinaryTreeNode*pRoot_13 = createBinaryTreeNode(13);
    BinaryTreeNode*pRoot_14 = createBinaryTreeNode(14);
    BinaryTreeNode*pRoot_15 = createBinaryTreeNode(15);
    connectTreeNodes(pRoot_1, pRoot_2, pRoot_3);
    connectTreeNodes(pRoot_2, pRoot_4, pRoot_5);
    connectTreeNodes(pRoot_3, pRoot_6, pRoot_7);
    connectTreeNodes(pRoot_4, pRoot_8, pRoot_9);
    connectTreeNodes(pRoot_5, pRoot_10, pRoot_11);
    connectTreeNodes(pRoot_6, pRoot_12, pRoot_13);
    connectTreeNodes(pRoot_7, pRoot_14, pRoot_15);

    printTreePreOrder(pRoot_1);
    std::cout << std::endl;

    std::cout << "Print tree nodes in level order" << std::endl;
    printTreeLevelOrder(pRoot_1);
    std::cout << std::endl;
}

void test_2()
{
    std::cout << "only left child binary tree" << std::endl;
    std::cout << "Print tree nodes in pre order" << std::endl;
    BinaryTreeNode*pRoot_1 = createBinaryTreeNode(1);
    BinaryTreeNode*pRoot_2 = createBinaryTreeNode(2);
    BinaryTreeNode*pRoot_3 = createBinaryTreeNode(4);
    BinaryTreeNode*pRoot_4 = createBinaryTreeNode(8);

    connectTreeNodes(pRoot_1, pRoot_2, nullptr);
    connectTreeNodes(pRoot_2, pRoot_3, nullptr);
    connectTreeNodes(pRoot_3, pRoot_4, nullptr);

    printTreePreOrder(pRoot_1);
    std::cout << std::endl;

    std::cout << "Print tree nodes in level order" << std::endl;
    printTreeLevelOrder(pRoot_1);
    std::cout << std::endl;
}

void test_3()
{
    std::cout << "only right child binary tree" << std::endl;
    std::cout << "Print tree nodes in pre order" << std::endl;
    BinaryTreeNode*pRoot_1 = createBinaryTreeNode(1);
    BinaryTreeNode*pRoot_2 = createBinaryTreeNode(2);
    BinaryTreeNode*pRoot_3 = createBinaryTreeNode(4);
    BinaryTreeNode*pRoot_4 = createBinaryTreeNode(8);

    connectTreeNodes(pRoot_1, nullptr, pRoot_2);
    connectTreeNodes(pRoot_2, nullptr, pRoot_3);
    connectTreeNodes(pRoot_3, nullptr, pRoot_4);

    printTreePreOrder(pRoot_1);
    std::cout << std::endl;

    std::cout << "Print tree nodes in level order" << std::endl;
    printTreeLevelOrder(pRoot_1);
    std::cout << std::endl;
}

void test_4()
{
    std::cout << "only node binary tree" << std::endl;
    std::cout << "Print tree nodes in pre order" << std::endl;
    BinaryTreeNode*pRoot_1 = createBinaryTreeNode(1);

    printTreePreOrder(pRoot_1);
    std::cout << std::endl;

    std::cout << "Print tree nodes in level order" << std::endl;
    printTreeLevelOrder(pRoot_1);
    std::cout << std::endl;
}

void test_5()
{
    std::cout << "nullptr tree" << std::endl;
    std::cout << "Print tree nodes in pre order" << std::endl;
    BinaryTreeNode*pRoot_1 = nullptr;

    printTreePreOrder(pRoot_1);
    std::cout << std::endl;

    std::cout << "Print tree nodes in level order" << std::endl;
    printTreeLevelOrder(pRoot_1);
    std::cout << std::endl;
}

void test_printBinaryTreeLevelOrder()
{
    test_1();
    test_2();
    test_3();
    test_4();
    test_5();
}

int main(int argc, char**argv)
{

    test_printBinaryTreeLevelOrder();

    return 0;
}