剑指offer 按之字形顺序打印二叉树

题目描述

请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推。

思路:

1、有了之前层次遍历一行一行输出的经验,我们可以直接用一个变量记录行数,如果是奇数行,就将队列中的元素按顺序所有保存下来,如果是偶数行,就顺序保存到一个临时vector中,再逆序保存下来。

 1 /*
 2 struct TreeNode {
 3     int val;
 4     struct TreeNode *left;
 5     struct TreeNode *right;
 6     TreeNode(int x) :
 7             val(x), left(NULL), right(NULL) {
 8     }
 9 };
10 */
11 class Solution {
12 public:
13     vector<vector<int> > Print(TreeNode* pRoot) {
14         vector<vector<int> > res;
15         vector<int> temp;
16         int odd = 0; //0表示奇数行,1表示偶数行
17         queue<TreeNode*> q;
18         if (pRoot == NULL)
19             return res;
20         q.push(pRoot);
21         int current = 1, next = 0; //current记录当前打印行的元素数,next表示下一行的元素个数。
22         while (!q.empty()) {
23             temp.clear();
24             for (int i = 0; i < current; i++) {
25                 TreeNode* pNode = q.front();
26                 q.pop();
27                 temp.push_back(pNode->val);
28                 if (pNode->left != NULL) {
29                     q.push(pNode->left);
30                     next++;
31                 }
32                 if (pNode->right != NULL) {
33                     q.push(pNode->right);
34                     next++;
35                 }
36             }
37             //如果是奇数行,就要将保存下来的逆序保存
38             if (odd == 1) {
39                 for (int i = 0; i < (current >> 1); i++) {
40                     swap(temp[i], temp[current - 1 - i]);
41                 }
42             }
43             res.push_back(temp);
44             odd = 1 - odd;
45             current = next;
46             next = 0;
47         }
48         return res;
49     }
50 };

2、剑指offer思路

 1 /*
 2 struct TreeNode {
 3     int val;
 4     struct TreeNode *left;
 5     struct TreeNode *right;
 6     TreeNode(int x) :
 7             val(x), left(NULL), right(NULL) {
 8     }
 9 };
10 */
11 class Solution {
12 public:
13     vector<vector<int> > Print(TreeNode* pRoot) {
14         vector<vector<int> > res;
15         vector<int> temp;
16         stack<TreeNode*> level[2];
17         int current = 0, next = 1;
18         if (pRoot == NULL)
19             return res;
20         level[current].push(pRoot);
21         //如果pRoot == NULL, 那么压入栈之后,栈非空,而取元素的话,又会产生越界?
22         while (!level[current].empty() || !level[next].empty()) {
23             TreeNode* pNode = level[current].top();
24             level[current].pop();
25             temp.push_back(pNode->val);
26             //current == 0表示当前在保存偶数行的数,将下一行的数保存到栈时,先将节点的左孩子放入栈中
27             if (current == 0) {
28                 if (pNode->left != NULL)
29                     level[next].push(pNode->left);
30                 if (pNode->right != NULL)
31                     level[next].push(pNode->right);
32             } else { //当前在保存奇数行的数据,先将节点的右孩子放入栈中
33                 if (pNode->right != NULL)
34                     level[next].push(pNode->right);
35                 if (pNode->left != NULL)
36                     level[next].push(pNode->left);
37             }
38             if (level[current].empty()) {
39                 res.push_back(temp);
40                 temp.clear();
41                 current = 1 - current;
42                 next = 1 - next;
43             }
44         }
45         return res;
46     }
47 };

原文地址:https://www.cnblogs.com/qinduanyinghua/p/11336920.html

时间: 2024-09-30 09:27:27

剑指offer 按之字形顺序打印二叉树的相关文章

剑指Offer——按之字形顺序打印二叉树

题目描述: 请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推. 分析: 我们都知道二叉树的层次遍历用的是队列. 但是这个的子树的结点是先进后出的,所以我们使用栈更加方便. 而且为了方便,我用了两个栈,因为不是每一次都是先进左子树再进右子树的. 代码: 1 /* 2 struct TreeNode { 3 int val; 4 struct TreeNode *left; 5 struct TreeNod

剑指offer61 按之字形顺序打印二叉树

另一种自己写的解法 class Solution { public: vector<vector<int> > Print(TreeNode* pRoot) { vector<vector<int> > result; vector<int> res; if(pRoot == NULL) return result; stack<TreeNode* > sta1; stack<TreeNode* > sta2; int n

按之字形顺序打印二叉树-剑指Offer

按之字形顺序打印二叉树 题目描述 请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推. 思路 根据题意,每行的节点的访问顺序是相反的,我们可以用两个栈来隔行存储,一个栈中根据“左结点->右结点”的顺序访问另一个栈的栈顶元素,而另一个栈根据“右子树->左子树”的顺序访问另一个栈的栈顶元素,直到两个栈都为空 代码 import java.util.ArrayList; import java.util.St

《剑指offer》:[61]按之字形顺序打印二叉树

题目:请实现一个函数按照之字形顺序打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右到左的顺序打印,第三层再按照从左到右打印,其他行以此类推. 例如:按之字形顺序打印二叉树的结果如下图: 打印结果: 1 3,2 4,5,6,7 15,14,13,12,11,10,9,8 方案:利用两个栈.时间复杂度O(N)+辅助空间2*O(N). 具体方法:我们在打印某一结点时,把下一层的子结点保存到相应的栈里.如果当前打印的是奇数层(例如第一层,第三层...第2*n+1层),则先保存左子结点再保存右子

按之字形顺序打印二叉树(剑指offer+队栈的应用)

按之字形顺序打印二叉树 参与人数:703时间限制:1秒空间限制:32768K 通过比例:25.31% 最佳记录:0 ms|8552K(  ) 题目描述 请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推. 题意:看测试用例 测试用例: {8,6,10,5,7,9,11} 对应输出应该为: [[8],[10,6],[5,7,9,11]] 思路:用一个布尔量控制从左到右还是从右到左的顺序:先放入栈中,然后把他

剑指OFFER之调整数组顺序使奇数位于偶数前面找(九度OJ1516)

题目描述: 输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变. 输入: 每个输入文件包含一组测试案例.对于每个测试案例,第一行输入一个n,代表该数组中数字的个数.接下来的一行输入n个整数.代表数组中的n个数. 输出: 对应每个测试案例,输入一行n个数字,代表调整后的数组.注意,数字和数字之间用一个空格隔开,最后一个数字后面没有空格. 样例输入: 5 1 2 3 4 5 样例输

【剑指offer】调整数组顺序

转载请注明出处:http://blog.csdn.net/ns_code/article/details/25829395 剑指offer上的第14题,九度OJ为了确保输出的结果的唯一性,在输出上做了修改,因此采用的方法自然与书本上不同,这里没有限制,思来想去还是用最简单的方法来做了,非常简单的方法,直接上代码. 题目描述: 输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变.

按之字形顺序打印二叉树

题目描述 请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; */ class Solution { public: vector<vect

【剑指offer】翻转单词顺序

转载请注明出处:http://blog.csdn.net/ns_code/article/details/27372033 题目描写叙述: JOBDU近期来了一个新员工Fish,每天早晨总是会拿着一本英文杂志,写些句子在本子上.同事Cat对Fish写的内容颇感兴趣,有一天他向Fish借来翻看.但却读不懂它的意思.比如,"student. a am I".后来才意识到.这家伙原来把句子单词的顺序翻转了,正确的句子应该是"I am a student.". Cat对一一