剑指offer——Day06搜索与回溯算法（简单）

Day6 2022.11.12 搜索与回溯算法（简单）

32.Ⅰ.从上到下打印二叉树

自己实现

用队列来实现。将当前节点的值打印后向queue中push它的左右非NULL儿子节点，并将该节点pop出去

代码如下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> levelOrder(TreeNode* root) {
        vector<int> vec;
        if(root==NULL)return vec;
        queue<TreeNode*> list;
        TreeNode* now=root;
        list.push(root);
        while(list.size()!=0)
        {
            now=list.front();
            vec.push_back(now->val);
            if(now->left!=NULL)list.push(now->left);
            if(now->right!=NULL)list.push(now->right);
            list.pop();
        }
        return vec;
    }
};

代码表现

题解

与自己实现思路一致，不赘述

hint：

• 仍然是最开始先判断一下树是否为空，并且在后面队列push的时候检查要push进去的节点是否为空再进行

32.Ⅱ.从上到下打印二叉树 Ⅱ

自己实现

和上一题大致一样，主要还是用队列来遍历。不同的主要就是要把每一层分开打印。主要就是这个判断是第几层的判断条件，是通过看题解理解的。如下列代码，在

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *       int val;
 *       TreeNode *left;
 *       TreeNode *right;
 *       TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
        vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> queue;
        vector<vector<int>> res;
        if(root != NULL) queue.push(root);
        while(queue.size()) {
                vector<int> tmp;
                for(int i = queue.size(); i > 0; i--) {       //控制切换层的关键条件
                    TreeNode* node = queue.front();
                    queue.pop();
                    tmp.push_back(node->val);
                    if(node->left != NULL) queue.push(node->left);
                    if(node->right != NULL) queue.push(node->right);
                }
                res.push_back(tmp);
        }
        return res;
    }
};

代码表现

完美咯

hint：

• 判断树的不同层用代码中Line19行的for循环内判断来做，很不错。

32.Ⅲ.从上到下打印二叉树Ⅲ

自己实现

在Ⅱ的要求之上+之字形输出。用了两个vector：ltor, rtol来实现，交互存储

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<TreeNode*> ltor;
        vector<TreeNode*> rtol;
        vector<vector<int>> vec;
        if(root != NULL) ltor.push_back(root);
        int flag=0;     //1 for in rtol now, 0 for in ltor now
        while(ltor.size() || rtol.size())
        {
            vector<int> level;
            if(flag)
            {
                flag=0;
                for(int i=rtol.size();i>0;i--)
                {
                    TreeNode* node=rtol[rtol.size()-1];
                    rtol.pop_back();
                    level.push_back(node->val);
                    if(node->right!=NULL)ltor.push_back(node->right);
                    if(node->left!=NULL)ltor.push_back(node->left);
                }
            }
            else
            {
                flag=1;
                for(int i=ltor.size();i>0;i--)
                {
                    TreeNode* node=ltor[ltor.size()-1];
                    ltor.pop_back();
                    level.push_back(node->val);
                    if(node->left!=NULL)rtol.push_back(node->left);
                    if(node->right!=NULL)rtol.push_back(node->right);
                }
            }
            vec.push_back(level);
        }
        return vec;
    }
};

代码表现

题解

这个题很不错！双端队列啥的，有时间一定看一下这里

hint：

• 自己实现的时候还是通过vector来实现了类似队列的功能，可以再多看看队列，对于树的遍历挺好用的