# Title one sword refers to Offer 32 - I. print binary tree from top to bottom

Source: LeetCode

Link: https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/

#### 1. Description

Each node of the binary tree is printed from top to bottom, and the nodes of the same layer are printed from left to right.

#### 2. Examples

- Example 1:

Given binary tree: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 return: [3,9,20,15,7]

### Solution I breadth first traversal + auxiliary queue

#### Problem solving ideas

It's not difficult to think of the simplest way is to traverse the binary tree with the help of a queue.

1. If the root node is empty, an empty array is returned directly; otherwise, the queued root node;

2. Add the team head node value to the answer array;

3. The non empty child node of the incoming team head node will take the team head node out of the team.

4. Repeat 2 and 3 until the queue is empty.

#### code

/** * 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> ans;//Store answers if(!root) return ans;//If the root node is empty, an empty answer array is returned queue<TreeNode*> q;//Auxiliary queue q.push(root);//Root node queue while(!q.empty()){//As long as the queue is not empty ans.push_back(q.front()->val);//Add the team head node value to the answer array //Non empty child node of queue header node if(q.front()->left) q.push(q.front()->left); if(q.front()->right) q.push(q.front()->right); q.pop();//Remove the team head node from the team } return ans;//Return answer } };

#### Complexity analysis

Time complexity: O(m). M is the number of binary tree nodes. It takes O(m) time to traverse the whole binary tree.

Spatial complexity: O(m). Space consumption for storing answers and using auxiliary queues.

### Solution 2 depth first search + auxiliary array

#### Problem solving ideas

In addition to the intuitive breadth first search, we can also use depth first search + auxiliary two-dimensional array to solve this problem.

Specifically, we perform a depth first search on the binary tree and maintain a level, which is initially 0. Every time you enter a layer of recursion, that is, when traversing the child node from the current node, the number of layers will be increased by one, then access the two-dimensional array through the number of layers as a subscript, add the node value to the one-dimensional array of the corresponding layer, and finally straighten the two-dimensional array by layers, which is the final answer.

#### code

/** * 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> ans;//Store answers if(!root) return ans;//If the root node is empty, an empty array is returned vector<vector<int>> aid;//Auxiliary array dfs(root, 0, aid);//Depth first traversal for(auto a : aid) ans.insert(ans.end(), a.begin(), a.end());//Straighten the two-dimensional array by layer return ans; //Return answer } void dfs(TreeNode* root, int level, vector<vector<int>>& aid){ if(!root) return;//If the node is empty, return if(aid.size()<=level){//If the layer array has not been created, create it vector<int> temp; aid.push_back(temp); } aid[level].push_back(root->val);//Add the node value to the corresponding layer array dfs(root->left, level+1, aid);//Traverse the left child node, and level+1 dfs(root->right, level+1, aid);//Traverse the right child node, and level+1 } };

#### Complexity analysis

Time complexity: O(m). Recursion and the time consumption of straightening the two-dimensional array

Spatial complexity: O(m). Recursion and space consumption of auxiliary array and answer array.

# Title 2: Sword finger Offer 32 - II Print binary tree II from top to bottom

Source: LeetCode

Link: https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof/

#### 1. Description

The binary tree is printed by layers from top to bottom, the nodes of the same layer are printed from left to right, and each layer is printed to one line.

#### 2. Examples

- Example 1:

Given binary tree: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 Return its hierarchy traversal result: [ [3], [9,20], [15,7] ]

### Solution I breadth first search + auxiliary queue

#### Problem solving ideas

Referring to topic 1, we can write the version of breadth first search + auxiliary queue.

However, a slight difference is that we need to choose the appropriate way to layer. Here, two additional variables count and size are used for hierarchical operation. For each layer, size is the size of the layer. Initially, it is 1, that is, the size of the queue when there is only the root node. For each node recorded, the count value is increased by one. When count is equal to size, it indicates that the current layer has been traversed. Then update the layer size and reset count to 0.

1. If the root node is empty, an empty array is returned directly; otherwise, the queued root node;

2. Add the team head node value to the answer array;

3. The non empty child node of the incoming team head node, and the team head node out of the team;

4. Add one to count. If count equals size, update size and reset count to 0;

5. Repeat the processes 2, 3 and 4 until the queue is empty.

#### code

/** * 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<vector<int>> ans;//Store answers if(!root) return ans;//If the root node is empty, an empty array is returned queue<TreeNode*> q;//Auxiliary queue q.push(root);//Queue root node int size = q.size(), count = 0;//Initialize size and count vector<int> temp;//Auxiliary array while(!q.empty()){//As long as the queue is not empty temp.push_back(q.front()->val);//Record the value of the queue head node //Non empty child node of queue header node if(q.front()->left) q.push(q.front()->left); if(q.front()->right) q.push(q.front()->right); q.pop();//Outgoing head node ++count;//count+1 if(count == size){//If count==size, it means that the current layer has been recorded ans.push_back(temp);//Add temp to the answer array temp.clear();//Empty temp count = 0;//Reset count to 0 size = q.size();//Update size } } return ans;//Return answer } };

#### Complexity analysis

Time complexity: O(m). M is the number of binary tree nodes, and it takes O(m) time to traverse the whole binary tree.

Spatial complexity: O(m). Auxiliary queue, answer array, space consumption of auxiliary array.

### Solution 2 depth first search + auxiliary array

#### Problem solving ideas

In addition to the intuitive breadth first search, we can also use depth first search + auxiliary two-dimensional array to solve this problem.

Specifically, we perform a depth first search on the binary tree and maintain a level, which is initially 0. Every time you enter a layer of recursion, that is, when traversing the child node from the current node, the number of layers will be increased by one, and then access the two-dimensional array through the number of layers as a subscript, and add the node value to the one-dimensional array of the corresponding layer. After traversing, it will be the final answer.

#### code

/** * 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<vector<int>> ans;//Store answers if(!root) return ans;//If the root node is empty, an empty array is returned dfs(root, 0, ans);//Depth first traversal return ans;//Return answer } void dfs(TreeNode* root, int level, vector<vector<int>>& aid){//Depth first traversal if(!root) return;//If the node is empty, return directly if(aid.size()<=level){//If the current layer array has not been created, create it vector<int> temp; aid.push_back(temp); } aid[level].push_back(root->val);//Save the current node value to the corresponding layer dfs(root->left, level+1, aid);//Traverse the left child, the number of layers plus one dfs(root->right, level+1, aid);//Traverse the right child, the number of layers plus one } };

#### Complexity analysis

Time complexity: O(m). The time consumption of traversing the binary tree.

Spatial complexity: O(m). Stack space consumption for storing answers and recursion.

# Title Three sword fingers Offer 32 - III. printing binary tree III from top to bottom

Source: LeetCode

Link: https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof/

#### 1. Description

Please implement a function to print the binary tree in zigzag order, that is, the first line is printed from left to right, the second layer is printed from right to left, the third line is printed from left to right, and so on.

#### 2. Examples

- Example 1:

Given binary tree: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 Return its hierarchy traversal result: [ [3], [20,9], [15,7] ]

### Solution I breadth first search + auxiliary queue

#### Problem solving ideas

Referring to topic 2, we can write the version of breadth first search + auxiliary queue.

We need to choose the right way to layer. Here, two additional variables count and size are used for hierarchical operation. For each layer, size is the size of the layer. Initially, it is 1, that is, the size of the queue when there is only the root node. For each node recorded, the count value is increased by one. When count is equal to size, it indicates that the current layer has been traversed. Then update the layer size and reset count to 0. However, the slight difference is that we need to process the result array after traversal, that is, flip the even layer array. The answer is after processing.

1. If the root node is empty, an empty array is returned directly; otherwise, the queued root node;

2. Add the team head node value to the answer array;

3. The non empty child node of the incoming team head node, and the team head node out of the team;

4. Add one to count. If count equals size, update size and reset count to 0;

5. Repeat processes 2, 3 and 4 until the queue is empty;

6. Flip the result array of even layers.

#### code

/** * 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<vector<int>> ans;//Store answers if(!root) return ans;//If the root node is empty, an empty array is returned queue<TreeNode*> q;//Auxiliary queue q.push(root);//Queue root node int size = q.size(), count = 0;//Initialize size and count vector<int> temp;//Auxiliary array while(!q.empty()){//As long as the queue is not empty temp.push_back(q.front()->val);//Record the value of the queue head node //Non empty child node of queue header node if(q.front()->left) q.push(q.front()->left); if(q.front()->right) q.push(q.front()->right); q.pop();//Outgoing head node ++count;//count+1 if(count == size){//If count==size, it means that the current layer has been recorded ans.push_back(temp);//Add temp to the answer array temp.clear();//Empty temp count = 0;//Reset count to 0 size = q.size();//Update size } } for(int i = 0; i < m; ++i) if(i%2!=0) reverse(ans[i].begin(), ans[i].end());//Flip even layers return ans;//Return answer } };

#### Complexity analysis

Time complexity: O(m). M is the number of binary tree nodes. It takes O(m) time to traverse the whole binary tree and flip the even layer.

Spatial complexity: O(m). Auxiliary queue, answer array, space consumption of auxiliary array.

### Solution 2 depth first traversal + auxiliary array

#### Problem solving ideas

The depth first traversal version is also provided here.

#### code

/** * 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<vector<int>> ans;//Store answers if(!root) return ans;//If the root node is empty, an empty array is returned dfs(root, 0, ans);//Depth first traversal for(int i = 0; i < m; ++i) if(i%2!=0) reverse(ans[i].begin(), ans[i].end());//Flip even layers return ans;//Return answer } void dfs(TreeNode* root, int level, vector<vector<int>>& aid){//Depth first traversal if(!root) return;//If the node is empty, return directly if(aid.size()<=level){//If the current layer array has not been created, create it vector<int> temp; aid.push_back(temp); } aid[level].push_back(root->val);//Save the current node value to the corresponding layer dfs(root->left, level+1, aid);//Traverse the left child, the number of layers plus one dfs(root->right, level+1, aid);//Traverse the right child, the number of layers plus one } };

#### Complexity analysis

Time complexity: O(m). The time consumption of traversing binary tree and flipping even layers.

Spatial complexity: O(m). Stack space consumption for storing answers and recursion.

Generally speaking, breadth first traversal is more intuitive, but the code is longer; The depth first traversal code is concise, but difficult to understand. Use more and practice more to master it.

More knowledge content sharing:

Blog Garden personal home page https://home.cnblogs.com/u/newCoderTheWarrior

Li Kou personal homepage https://leetcode-cn.com/profile/articles/