剑指offer - 面试题32扩展: 之字形打印二叉树 - C++

最新推荐文章于 2024-08-22 10:44:26 发布
最新推荐文章于 2024-08-22 10:44:26 发布
阅读量340 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_bic/article/details/86590451
版权 
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int> > result;
        if(pRoot == nullptr) return result; 
        
        stack<TreeNode*> levels[2];
        int current = 0, next = 1;
        levels[current].push(pRoot);
        TreeNode* pNode;
        int depth = 1;
        vector<int> temp;
        result.push_back(temp);
        result[0].push_back(pRoot->val);
        
        while(!levels[current].empty()) {
            
            pNode = levels[current].top();
            levels[current].pop();
            
            if(result.size() < depth+1) {
                vector<int> temp;
                result.push_back(temp);
            }

            if((depth & 0x1) == 1) {
                if(pNode->right != nullptr) {
                    result[depth].push_back(pNode->right->val);
                    levels[next].push(pNode->right);
                }
                if(pNode->left != nullptr) {
                    result[depth].push_back(pNode->left->val);
                    levels[next].push(pNode->left);
                }
            } else {
                if(pNode->left != nullptr) {
                    result[depth].push_back(pNode->left->val);
                    levels[next].push(pNode->left);
                }
                if(pNode->right != nullptr) {
                    result[depth].push_back(pNode->right->val);
                    levels[next].push(pNode->right);
                }
            }
            if(levels[current].empty()) {  // 避免两层循环
                if(result[depth].empty()) {
                    result.pop_back();
                    return result;
                } else {
                    current = 1-current;
                    next = 1-next;
                    depth++;
                }
            }
        }
        return result;
    }
};

这道题确实复杂。

两个重犯小错误：&的优先级小于==，下次判断奇偶要小心；最后忘记return。

这是我借鉴书上的思维写出来的基于循环，吸收了它用一个栈数组来定义两个栈、定义下标为0和1，巧妙交换两个栈的妙用。由于书上是直接打印，所以代码要比书上复杂一些。尤其是最后判断result[depth]是否是空这里，我觉得有点不简洁，但暂时没有其它想法。

以下是我自己琢磨的基于递归写的。

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> result;
        if (pRoot == nullptr) return result;
             
        vector<int> newLayerVec;
        result.push_back(newLayerVec);
         
        stack<TreeNode*> toolStack;
        result[0].push_back(pRoot->val);
        toolStack.push(pRoot);
         
        handleTheLayer(toolStack, 1, result);  // 按层处理
        return result;
    }
     
    void handleTheLayer(stack<TreeNode*> toolStack, int depth, vector<vector<int>>& result) {
        if(toolStack.empty()) return;
         
        stack<TreeNode*> nextLayerStack;
        vector<int> newLayerVec;
        result.push_back(newLayerVec);
        TreeNode* pNode;
        while(!toolStack.empty()) {
            pNode = toolStack.top();
            toolStack.pop();
            if(depth & 0x1 == 1) {
                if(pNode->right != nullptr) {
                    result[depth].push_back(pNode->right->val);
                    nextLayerStack.push(pNode->right);
                }
                if(pNode->left != nullptr) {
                    result[depth].push_back(pNode->left->val);
                    nextLayerStack.push(pNode->left);
                }
                 
            } else {
               if(pNode->left != nullptr) {
                    result[depth].push_back(pNode->left->val);
                    nextLayerStack.push(pNode->left);
                }
                 if(pNode->right != nullptr) {
                    result[depth].push_back(pNode->right->val);
                    nextLayerStack.push(pNode->right);
                }
            }
        }
        if(!result[depth].size()) {
            result.pop_back();
            return;
        }
         
        handleTheLayer(nextLayerStack, depth+1, result);
    }
};

二刷

感觉这道题挺难的，如果掌握了这道题，那二叉树的各种酷炫魔幻遍历就没有什么问题了，所以回来二刷。

思考的时候，不知道怎样辨别换行，于是看了一下书上，逐行打印的题告诉我说用两个变量记录当前行还剩节点数和下一行节点数，于是翻回去把逐行打印的题做了一下，还算顺利。

然后再回来做之字形打印，把栈改成了队列。做半天调通了发现打印顺序清奇，到书上一看发现做出一个标准错误答案，一个栈是不行的。

于是改成有两个元素的栈数组。做完之后倒是通过编译，但是少打了一行，手动运行代码后知道是判断条件出了问题，修改之后终于通过，代码如下：

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>>  result;
        if(pRoot == nullptr) return result;
  
        stack<TreeNode*> nodes[2];
        int thisLevel = 0;
        int nextLevel = 1 - thisLevel;
          
        bool leftFirst = true;
        nodes[thisLevel].push(pRoot);
        vector<int> currentLevel;
        TreeNode* pNode;
        while(!nodes[thisLevel].empty()) {
            pNode = nodes[thisLevel].top();
            nodes[thisLevel].pop();
            currentLevel.push_back(pNode->val);
            if(leftFirst) {
                if(pNode->left != nullptr) {
                    nodes[nextLevel].push(pNode->left);
                }
                if(pNode->right != nullptr) {
                    nodes[nextLevel].push(pNode->right);
                }
            } else {
                if(pNode->right != nullptr) {
                    nodes[nextLevel].push(pNode->right);
                }
                if(pNode->left != nullptr) {
                    nodes[nextLevel].push(pNode->left);
                }
            }
            if(nodes[thisLevel].empty()) {
                result.push_back(currentLevel);
                currentLevel.clear();
                thisLevel = 1 - thisLevel;
                nextLevel = 1 - thisLevel;
                leftFirst = !leftFirst;
            }
        }
        return result;
    }
};

虽然过程曲折，最后写出的这个代码还是比较满意的。

这道题的关键在于，用栈，且用两个。

表扬一下自己之前写的递归，惊呆，真棒，仿佛不是自己写的

小技巧：两个东西需要交换，用一个有两个元素的数组，交换下标，这样性能好，类似于STL中的swap函数

逐行打印的题也可以用两个队列，但是没必要。它可以用一个队列，用两个变量记录行节点个数就行。

万变不离其宗，其实这道题也借鉴了很多二叉树的前中后序遍历的写法。基础是王道，重复是王道。

关于一刷循环写法的小疑惑在此解决：岀栈时打印，而非入栈打印，避免了先要准备一个空的vector<int>，最后还要删去的情况。其实书上就是这样，当时写完有疑惑之后也没回去看看书，情有可原，写题很累的。编程就是这样，要不断吸收各方的优点，改进代码。

最近有些不顺，腾讯两面两挂，农行简历挂，给自己打个气，坚持走下去！

 

天呐，简洁！我是个天才！

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> result;
        handleByDepth(pRoot, 1, result);
        return result;
    }
    
    void handleByDepth(TreeNode* pNode,
                           int depth,
                           vector<vector<int>>& result) {
            if (pNode == nullptr) return;
            if(result.size() < depth) {
                vector<int> temp;
                result.push_back(temp);
            }
             if((depth & 0x1) == 1) {
                result[depth-1].push_back(pNode->val);
                
            } else {
                result[depth-1].insert(result[depth-1].begin(), pNode->val);            
            }
            handleByDepth(pNode->left, depth+1, result);
            handleByDepth(pNode->right, depth+1, result);
    }
};

 

L_bic
关注
《剑指Offer》二叉树系列15道算法面试题解析（C++）
ZY-JIMMY
06-07 2089
重建二叉树 、树的子结构 、二叉树的镜像 、从上往下打印二叉树 、二叉搜索树的后序遍历序列 、二叉树中和为某一值的路径 、二叉搜索树与双向链表 、二叉树的深度 、平衡二叉树 、二叉树的下一个结点 、对称的二叉树 、按之字形顺序打印二叉树 、把二叉树打印成多行 、序列化二叉树 、二叉搜索树的第k个结点
【LeetCode】之字形顺序打印二叉树（层序遍历 / 双端队列 / 双栈），清晰推演过程
CV前沿
03-27 1248
一、题目 请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层次遍历结果： [ [3], [20,9], [15,7] ] 二、思路分析 这个题目考察的是二叉树的层序遍历的问题。比起普通的层序遍历，它增加了新的要求：按照之子形的顺序来打印。下面我们分别介绍三
剑指offer（C++）——按之字形顺序打印二叉树
YF_Li123的博客
04-18 1485
题目描述 请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。 /* 思路：打印第一层结点的时候要把第二层结点保存到一个容器里，由于打印第二层结点的顺序是从右至左，容器为后进先出，故容器为栈 打印第一层时，依次把第一层的左子结点和右子结点保存到栈中；打印第二层结点时要把第三层结点保存
NC14 按之字形顺序打印二叉树
搓搓那年时光静好
07-21 268
描述 给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替） 例如： 给定的二叉树是{1,2,3,#,#,4,5} 该二叉树之字形层序遍历的结果是 [ [1], [3,2], [4,5] ] 示例1 输入： {1,2,3,#,#,4,5} 复制返回值： [[1],[3,2],[4,5]] import java.util.*; /* public class TreeNode { int val = 0; Tr
算法的学习笔记---按之字形顺序打印二叉树
最新发布
业精于勤，荒于嬉
08-22 1019
之字形顺序打印二叉树是一种层序遍历的变种，它要求我们在遍历每层节点时，按指定的方向打印。这种问题不仅考察我们对二叉树遍历的掌握，还需要我们灵活运用数据结构来管理遍历的顺序。通过上述代码，我们可以高效地实现这一功能，并在复杂的树结构中应用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
之字形打印二叉树
qq_45880043的博客
07-22 123
请实现一个函数按照之字形顺序从上向下打印二叉树。 即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。 样例 输入如下图所示二叉树[8, 12, 2, null, null, 6, 4, null, null, null, null] 8 / \ 12 2 / \ 6 4 输出：[[8], [2, 12], [6, 4]] 算法： 二叉树的层序遍历，用d来标记，如果是奇数行，先将ans翻转，再存入res；
之字形打印二叉树－C++
了解➔熟悉➔掌握➔精通
02-18 463
// 面试题32（三）：之字形打印二叉树 // 题目：请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺 // 序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印， // 其他行以此类推。 #include #include struct BinaryTreeNode { int m_nValue; BinaryTreeNode *m_pLeft; BinaryTreeNode *m_pRight; }; Bin
剑指offer 33. 之字形打印二叉树
zhaohaibo的博客
01-11 278
请实现一个函数按照之字形顺序从上向下打印二叉树。 即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。 样例 输入如下图所示二叉树[8, 12, 2, null, null, 6, 4, null, null, null, null] 8 / \ 12 2 / \ 6 4 输出：[[8], [2, ...
《剑指Offer》题目及代码.pdf
05-31
《剑指Offer》是一本广受欢迎的算法面试书籍，主要针对中国的IT面试市场。该书中包含了大量面试题以及针对这些题目的解题思路和代码实现。本书涵盖的知识点广泛，难度从基础到进阶不等，非常适合准备面试和提高编程...
剑指offer题目--Java实现
weixin_44116098的博客
07-18 330
1、剪绳子 描述：  给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1，m<=n），每段绳子的长度记为k[1],…,k[m]。请问k[1]x…xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。 输入描述：  输入一个数n，意义见题面。（2 <= n <= 60） 返回值描述：  输出答案 示例：  输入：8  返回值：18 public class Solution {
《剑指offer》算法总结
Zuoerfeng
11-09 4670
最近找工作，刷了下《剑指offer》这本书，上面有挺多经典的算法，对每一章做了一个总结，章节笔记见一下链接： http://note.youdao.com/noteshare?id=ad655fcf73eb4b63e7e0700daa01d02f 下面是对整本书的一个算法，从数据结构上进行分类，这样拿到算法题的时候知道从哪一个类别去思考相似的可能性。 一、线性表 1、数组 2、链表 二、字符串 三...
剑指offer 按之字形顺序打印二叉树（C++）
bwqiang的博客
03-28 285
题目描述 请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。 解题思路 本题目就是二叉树层序遍历的变形，在程序主题中可以定义一个queue队列数据结构来方便二叉树的遍历。 本题目返回一个动态二维数组即vector<<vector>int >类型，思路可以是定义一个一维数组v...
C++/数据结构——按之字型打印一颗二叉树
Wz_still_shuai的博客
07-25 672
按之字型打印一颗二叉树 问题描述： 将一颗二叉树按照之字型打印，结果存放在二维数组中 分析： 例： 如图二叉树，按照之字型打印的结果就是：6、9、8、3、2。 1.可以看出这是一种类层序遍历的思想； 2.与其说是之字型，我更愿意说是“S”型； 3.假定根是第一层，我们可以发现奇数层的节点是从左到右打印的；而偶数层的节点是从右到左打印的； 思路： 按照层序遍历的思想，不过现在就是把偶数层的顺序逆置一下。 附源码： /* struct TreeNode { in...
按之字形顺序打印二叉树（C++）
田螺姑娘的博客
03-16 781
按之字形顺序打印二叉树 描述   给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替） 数据范围：   要求：空间复杂度：O(n)O(n)，时间复杂度：O(n)O(n)   例如：   给定的二叉树是{1,2,3,#,#,4,5} 该二叉树之字形层序遍历的结果是 [ [1], [3,2], [4,5] ] 示例1 输入： {1,2,3,#,#,4,5} 返回值： [[1],[3,2],[4,5]] 说明： 如题面解释，第一层是根节点，从左到右打印结果，第二层从右
剑指offer——按之字形顺序打印二叉树C++
白小飞
01-06 203
按照层来，根为第一层，每一层将值加入vector中，如果当前层是2的倍数，就对该vector进行reverse，然后将该vec加入结果数组中，每一层都要讲vec清空 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; */ cla.
牛客网——按之字形顺序打印二叉树（C++）
qq_27060423的博客
01-18 296
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。 C++ /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : ...
剑指offer之字形打印二叉树 C++
qq_53174954的博客
05-23 182
题目要求： 原题是牛客网剑指offer数据结构树的第二题。 给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替） 数据范围：0 \le n \le 15000≤n≤1500,树上每个节点的val满足 |val| <= 1500∣val∣<=1500 要求：空间复杂度：O(n)O(n)，时间复杂度：O(n)O(n) 解题思路： 可以把二叉树的图形结构分为奇偶两种层数，从根节点开始为第一层为奇，接下来是第二层为偶以此类推。在代码中用一个int变量
#数据结构与算法学习笔记#剑指Offer57：按之字形顺序打印二叉树（Java、C/C++）
NJU_ChopinXBP的博客
02-26 445
2019.2.26 《剑指Offer》从零单刷个人笔记整理（66题全）目录传送门​​​​​​​ 之前做过层序遍历二叉树的题：#数据结构与算法学习笔记#剑指Offer21：从上往下打印二叉树/层次遍历二叉树（Java、C/C++）。这道题其实是层序遍历的升级版，但是思想是一样的：层序遍历利用栈，之字遍历利用双向链表Tree。 情况有点复杂，需要分奇数偶数行考虑， 当为奇数行时，Tree...
剑指offer - 60 -- 把二叉树打印成多行 - C++
小白_努力
01-08 161
题目描述 从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。 示例1 输入 {8,6,10,5,7,9,11} 返回值 [[8],[6,10],[5,7,9,11]] 题解 层序遍历，直接上代码 class Solution { public: vector<vector<int> > Print(TreeNode* pRoot) { vector<vector<int>> ret;
C-C++虚拟文件管理：树与二叉树算法实现
由于文档的扩展名是.cpp，因此实现将使用C或C++语言编写。 ### 描述知识点详细说明： #### 4. 树、二叉树数据结构 树是一种重要的非线性数据结构，广泛应用于文件系统的组织。它特别适合表示具有层次关系的数据。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值