zoukankan      html  css  js  c++  java
  • 《剑指offer》第三十二题I:不分行从上往下打印二叉树

    // 面试题32(一):不分行从上往下打印二叉树
    // 题目:从上往下打印出二叉树的每个结点,同一层的结点按照从左到右的顺序打印。
    
    #include <cstdio>
    #include "BinaryTree.h"
    #include <deque>
    
    void PrintFromTopToBottom(BinaryTreeNode* pRoot)
    {
        if (pRoot == nullptr)
            return;
    
        std::deque<BinaryTreeNode *> dequeTreeNode; //STL队列
    
        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);
        }
    }
    // ====================测试代码====================
    void Test(const char* testName, BinaryTreeNode* pRoot)
    {
        if (testName != nullptr)
            printf("%s begins: 
    ", testName);
    
        PrintTree(pRoot);
    
        printf("The nodes from top to bottom, from left to right are: 
    ");
        PrintFromTopToBottom(pRoot);
    
        printf("
    
    ");
    }
    
    //            10
    //         /      
    //        6        14
    //       /        /
    //      4  8     12  16
    void Test1()
    {
        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);
    
        Test("Test1", pNode10);
    
        DestroyTree(pNode10);
    }
    
    //               5
    //              /
    //             4
    //            /
    //           3
    //          /
    //         2
    //        /
    //       1
    void Test2()
    {
        BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
        BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
        BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
        BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
        BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
    
        ConnectTreeNodes(pNode5, pNode4, nullptr);
        ConnectTreeNodes(pNode4, pNode3, nullptr);
        ConnectTreeNodes(pNode3, pNode2, nullptr);
        ConnectTreeNodes(pNode2, pNode1, nullptr);
    
        Test("Test2", pNode5);
    
        DestroyTree(pNode5);
    }
    
    // 1
    //  
    //   2
    //    
    //     3
    //      
    //       4
    //        
    //         5
    void Test3()
    {
        BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
        BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
        BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
        BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
        BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    
        ConnectTreeNodes(pNode1, nullptr, pNode2);
        ConnectTreeNodes(pNode2, nullptr, pNode3);
        ConnectTreeNodes(pNode3, nullptr, pNode4);
        ConnectTreeNodes(pNode4, nullptr, pNode5);
    
        Test("Test3", pNode1);
    
        DestroyTree(pNode1);
    }
    
    // 树中只有1个结点
    void Test4()
    {
        BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);
        Test("Test4", pNode1);
    
        DestroyTree(pNode1);
    }
    
    // 树中没有结点
    void Test5()
    {
        Test("Test5", nullptr);
    }
    
    int main(int argc, char* argv[])
    {
        Test1();
        Test2();
        Test3();
        Test4();
        Test5();
    
        return 0;
    }
    测试代码

    分析:队列先进先出。

    /*
    struct TreeNode {
        int val;
        struct TreeNode *left;
        struct TreeNode *right;
        TreeNode(int x) :
                val(x), left(NULL), right(NULL) {
        }
    };*/
    class Solution {
    public:
        vector<int> PrintFromTopToBottom(TreeNode* root) {
            
            std::deque<TreeNode*> dequeTreeNode;
            std::vector<int> printTreeNode;
            
            if (root == nullptr)
                return printTreeNode;
            
            dequeTreeNode.push_back(root);
            
            while (dequeTreeNode.size())
            {
                TreeNode* pNode = dequeTreeNode.front();
                dequeTreeNode.pop_front();
                
                printTreeNode.push_back(pNode->val);
                
                if (pNode->left)
                    dequeTreeNode.push_back(pNode->left);
                if (pNode->right)
                    dequeTreeNode.push_back(pNode->right);
            }
            return printTreeNode;
        }
    };
    牛客网提交代码
  • 相关阅读:
    Hanoi塔
    采药
    进制转换(大数)
    Load Balancing with NGINX 负载均衡算法
    upstream模块实现反向代理的功能
    epoll
    在nginx启动后,如果我们要操作nginx,要怎么做呢 别增加无谓的上下文切换 异步非阻塞的方式来处理请求 worker的个数为cpu的核数 红黑树
    粘性会话 session affinity sticky session requests from the same client to be passed to the same server in a group of servers
    负载均衡 4层协议 7层协议
    A Secure Cookie Protocol 安全cookie协议 配置服务器Cookie
  • 原文地址:https://www.cnblogs.com/ZSY-blog/p/12601906.html
Copyright © 2011-2022 走看看