递归实现二叉树的锯齿形层序遍历

题目

（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/