lass Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
if not root:
return []
queue = [root]
res = []
rev = False
while queue:
size = len(queue)
tmp = []
for i in range(size):
cur = queue.pop(0)
tmp.append(cur.val)
if cur.left:
queue.append(cur.left)
if cur.right:
queue.append(cur.right)
if rev:
res.append(tmp[::-1])
else:
res.append(tmp)
rev = not rev
return res
时间复杂度on，空间on
/*对于这行代码 nodeQueue[right++] = root; ，根节点入队的意思是将根节点 root 存储在队列 nodeQueue 中的特定位置。
nodeQueue 是一个存储节点的队列，通过数组来实现，right 是队列的右指针，表示队列的尾部位置。在这行代码中，nodeQueue[right++] 表达式的含义是先将根节点 root 存储在 nodeQueue 队列的 right 位置，然后将 right 的值增加1，指向下一个空闲的队列位置。
根节点的 next 指针通常用于指向二叉树中下一个要访问的节点。如果你想实现后续根节点的入队操作，可以使用类似的语句，将 next 指向的节点存储在队列中的下一个位置。
例如，假设你要将根节点的左子节点入队，可以使用以下代码：
nodeQueue[right++] = root->left; // 左子节点入队
这行代码将根节点的左子节点（如果存在）存储在队列 nodeQueue 的下一个位置，然后将 right 的值增加1，指向下一个空闲的队列位置。
通过这种方式，你可以依次将二叉树中的节点按层次顺序入队，以实现层次遍历等操作。*/
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
/**
* Return an array of arrays of size *returnSize.
* The sizes of the arrays are returned as *returnColumnSizes array.
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/
#define N 2000 // 定义数组大小
第一反应就是对应的层直接倒序
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
if root is None:return []
queue = collections.deque()
tree = []
queue.append(root)
while queue:
tmp = []
for _ in range(len(queue)):
node = queue.popleft()
tmp.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
tree.append(tmp)
return tree
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res = new ArrayList<>();
if (root==null){
return res;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
int size;
TreeNode node;
int z=0;
while (!queue.isEmpty()){
List<Integer> list = new ArrayList<>();
size=queue.size();
for (int i = 0; i < size; i++) {
node=queue.poll();
if (node.left!=null){
queue.add(node.left);
}
if (node.right!=null){
queue.add(node.right);
}
if (z%2==0){
list.add(node.val);
}else {
list.add(0,node.val);
}
}
res.add(list);
z++;
}
return res;
}
}
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
if (root == null) {
return new ArrayList<>();
}
Queue<TreeNode> queue = new LinkedList<>();
List<List<Integer>> ans = new ArrayList<>();
int sum = 1;
queue.add(root);
while (!queue.isEmpty()) {
int k = queue.size();
LinkedList<Integer> tmp = new LinkedList<>();
for (int i = 0; i < k; i++) {
TreeNode p = queue.poll();
if (sum % 2 == 1) {
tmp.add(p.val);
} else {
tmp.addFirst(p.val);
}
if (p.left != null) {
queue.add(p.left);
}
if (p.right != null) {
queue.add(p.right);
}
}
ans.add(tmp);
sum++;
}
return ans;
}
}
shuaidi
共以下 19 个回答
void printBinaryTree(TreeNode* root, int layer) {
if (root nullptr) {
return;
}
if (layer 1) {
cout << root->val << ” “;
} else if (layer % 2 1) {
printBinaryTree(root->right, layer – 1);
cout << root->val << ” “;
} else {
printBinaryTree(root->left, layer – 1);
cout << root->val << ” “;
}
}//时间复杂度是 O(n)，空间复杂度是 O(n)
//从上到下打印二叉树 呈之字形> levelOrder(TreeNode *root) > res; q{{root}}; level(n); 1)
// 偶数从右到左 奇数从左到右
//用II的改编
//设定一个足够大的空间level(n) sum%2进行奇偶判断 将值传入
class Solution{
public:
vector<vector
{
vector<vector
if(root NULL)
return NULL;
queue
int sum =1;
while(!q.empty())
{
int n= q.size();
vector
for(int i =0;i<n;i++){
auto t = q.front;
q.pop();
if(sum %2
{
level[i] = t->val;
}
else
{
level[n-i-1] = t->val;
}
if(t->left) q.push(t->left);
if(t->right) q.push(t->right);
}
res.push_back(level);
sum++
}
return res;
};
/**> levelOrder(TreeNode root) {> res; levelList; // 使用一个双端队列来存放当前层的节点元素 {levelList.begin(), levelList.end()});
* 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
vector<vector
if (root nullptr) return res;
queue<TreeNode*> que;
que.emplace(root);
bool isorderleft = true; // 表示是否要从左往右遍历
while (!que.empty()) {
deque
int size = que.size();
for (int i = 0; i < size; ++i) {
auto node = que.front();
que.pop();
if (isorderleft) {
levelList.emplace_back(node->val);
} else {
levelList.emplace_front(node->val);
}
if (node->left) que.emplace(node->left);
if (node->right) que.emplace(node->right);
}
res.emplace_back(vector
isorderleft = !isorderleft;
}
return res;
}
};
时间复杂度：O(n)> levelOrder(TreeNode root) {> bfs; vals(n); t;
空间复杂度：O(n)
/**
* 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
vector<vector
queue<TreeNode> q;
if(rootNULL) return {};
q.push(root);
int k=1;
while(!q.empty()){
int n=q.size();
vector
TreeNode
for(int i=0;i<n;i++){
t = q.front();
if(k%20) vals[n-i-1]=t->val;
else vals[i]=t->val;
if(t->left!=NULL) q.push(t->left);
if(t->right!=NULL) q.push(t->right);
q.pop();
}
bfs.push_back(vals);
k++;
}
return bfs;
}
};
时间On
时间复杂度on，空间on
/*对于这行代码 nodeQueue[right++] = root; ，根节点入队的意思是将根节点 root 存储在队列 nodeQueue 中的特定位置。
nodeQueue 是一个存储节点的队列，通过数组来实现，right 是队列的右指针，表示队列的尾部位置。在这行代码中，nodeQueue[right++] 表达式的含义是先将根节点 root 存储在 nodeQueue 队列的 right 位置，然后将 right 的值增加1，指向下一个空闲的队列位置。
根节点的 next 指针通常用于指向二叉树中下一个要访问的节点。如果你想实现后续根节点的入队操作，可以使用类似的语句，将 next 指向的节点存储在队列中的下一个位置。
例如，假设你要将根节点的左子节点入队，可以使用以下代码：
nodeQueue[right++] = root->left; // 左子节点入队
这行代码将根节点的左子节点（如果存在）存储在队列 nodeQueue 的下一个位置，然后将 right 的值增加1，指向下一个空闲的队列位置。
通过这种方式，你可以依次将二叉树中的节点按层次顺序入队，以实现层次遍历等操作。*/
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
/**
* Return an array of arrays of size *returnSize.
* The sizes of the arrays are returned as *returnColumnSizes array.
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/
#define N 2000 // 定义数组大小
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
*returnSize = 0;
}
加个顺便标识来控制输出的正反序
通过行数区别是从左到右打印还是从右到左打印
時間複雜度 : O(n)
空間複查度: O(n) 最多有一半的節點儲存在隊列中
一開始首先想到利用 flag來反轉儲存順序, 後來也是照這個思路寫出來
其餘部分跟上一題差不多 也是層序遍歷的概念
第一反应就是对应的层直接倒序
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
if root is None:return []
queue = collections.deque()
tree = []
使用标记位
// 偶数层倒序
1、层次遍历。双端队列
通过增加标记为来判断层序遍历时，节点值加在头还是尾
增加标记位