题目
(1)给你二叉树的根节点 root ,返回其节点值的锯齿形层序遍历(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。
(2)示例如下所示:
输入:root = [3,9,20,null,null,15,7]
输出:[[3],[20,9],[15,7]]
解决思路
- 采用递归思想解决。
- 具体步骤:
- 第一步:先将树中的所有节点按照从上到下,从左到右的顺序存储在二维数组中,请参考从上到下打印二叉树
- 第二步:将二维数组中下标为奇数的数组中的元素进行倒序。
代码
- C++代码
# include <stdio.h>
# include <vector>
using namespace std;
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(): val(0), left(nullptr), right(nullptr) {}
TreeNode(int _val): val(_val), left(nullptr), right(nullptr) {}
TreeNode(int _val, TreeNode* _left, TreeNode* _right): val(_val), left(_left), right(_right) {}
};
class Solution {
public:
void mylevelOrder(TreeNode* root, int k, vector<vector<int>>& answer) {
if (NULL == root) { // 边界条件
return;
}
// 如果传入的k值和answer的size相等,说明二维数组answer中不存在下标为k的数组,则添加一个数组。
if (k == answer.size()) {
answer.push_back(vector<int>());
}
answer[k].push_back(root->val); // 将根节点放入二维数组中下标为k的数组的末尾
mylevelOrder(root->left, k + 1, answer); // 递归遍历根节点的左节点,并将节点放入二维数组中下标为k+1的数组的末尾
mylevelOrder(root->right, k + 1, answer); // 递归遍历根节点的右节点,并将节点放入二维数组中下标为k+1的数组的末尾
}
void myreverse(vector<int>& arr) {
for (int i = 0, j = arr.size() - 1; i < j; i++, j--) {
swap(arr[i], arr[j]);
}
}
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
if (nullptr == root) {
return vector<vector<int>> ();
}
vector<vector<int>> answer; // 使用二维数组存储树的节点
int k = 0; // 记录树的每一层和二维数组的对应关系(当前根节点的值应该放到二维数组的第几号数组中)
// 第一步:将树的节点存储在二维数组中
mylevelOrder(root, k, answer);
// 第二步:将二维数组中下标为奇数的数组中的元素进行倒序。
for (int i = 1; i < answer.size(); i += 2) {
myreverse(answer[i]);
}
return answer;
}
};
int main() {
TreeNode* n1 = new TreeNode(3);
TreeNode* n2 = new TreeNode(9);
TreeNode* n3 = new TreeNode(20);
TreeNode* n4 = new TreeNode(15);
TreeNode* n5 = new TreeNode(7);
n1->left = n2;
n1->right = n3;
n2->left = nullptr;
n2->right = nullptr;
n3->left = n4;
n3->right = n5;
n4->left = nullptr;
n4->right = nullptr;
n5->left = nullptr;
n5->right = nullptr;
Solution* solution = new Solution();
vector<vector<int>> answer = solution->zigzagLevelOrder(n1);
for (auto ans: answer) {
for (auto a: ans) {
printf("%d ", a);
}
}
printf("\n");
return 0;
}
- Python代码
# -*- coding: utf-8 -*-
from typing import List
class TreeNode:
def __init__(self, _val=0, _left=None, _right=None):
self.val = _val
self.left = _left
self.right = _right
class Soltuion:
def __init__(self):
pass
def myLevelOrder(self, root: 'TreeNode', k: int, answer: List[List[int]]):
if not root: # 边界条件
return
# 如果传入的k值和answer的size相等,说明二维数组answer中不存在下标为k的数组,则添加一个数组。
if k == len(answer):
answer.append([])
answer[k].append(root.val) # 将根节点放入二维数组中下标为k的数组的末尾
self.myLevelOrder(root.left, k + 1, answer) # 递归遍历根节点的左节点,并将节点放入二维数组中下标为k+1的数组的末尾
self.myLevelOrder(root.right, k + 1, answer) # 递归遍历根节点的右节点,并将节点放入二维数组中下标为k+1的数组的末尾
def zigzagLevelOrder(self, root: 'TreeNode') -> List[List[int]]:
if not root:
return []
answer: List[List[int]] = [[]] # 使用二维数组存储树的节点
k: int = 0 # 记录树的每一层和二维数组的对应关系(当前根节点的值应该放到二维数组的第几号数组中)
# 第一步:将树的节点存储在二维数组中
self.myLevelOrder(root, k, answer)
# 第二步:将二维数组中下标为奇数的数组中的元素进行倒序。
i: int = 1
while i < len(answer):
answer[i].reverse()
i += 2
return answer
def main():
n1 = TreeNode(3)
n2 = TreeNode(9)
n3 = TreeNode(20)
n4 = TreeNode(15)
n5 = TreeNode(7)
n1.left = n2
n1.right = n3
n2.left = None
n2.right = None
n3.left = n4
n3.right = n5
n4.left = None
n4.right = None
n5.left = None
n5.right = None
solution = Soltuion()
answer: List[List[int]] = solution.zigzagLevelOrder(n1)
print(answer)
if __name__ == "__main__":
main()
说明
- 对应LeetCode第103题。
- 链接:https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/