递归实现二叉树的前序遍历

题目

（1）给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
（2）示例如下：

输入：root = [1,null,2,3]
输出：[1,2,3]

解决思路

• 采用递归思想解决。
• 二叉树前序遍历的顺序是：根节点 --> 左节点 --> 右节点。
• 具体步骤：
  • 第一步：输出根节点的值。
  • 第二步：递归遍历左子树。
  • 第三步：递归遍历右子树。

代码

• 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:
    // 前序遍历：将当前根节点的值放入answer数组末尾，然后递归遍历左右节点。
    void mypreorder(TreeNode* root, vector<int>& answer) {
        if (nullptr == root) {
            return;
        }
        answer.push_back(root->val);        // 第一步：输出根节点的值。
        mypreorder(root->left, answer);     // 第二步：递归遍历左子树。
        mypreorder(root->right, answer);    // 第三步：递归遍历右子树。
    }

    vector<int> preorderTraversal(TreeNode* root) {
        if (NULL == root) {
            return vector<int> ();
        }
        vector<int> answer;
        mypreorder(root, answer);
        return answer;
    }
};

int main() {
    TreeNode* n1 = new TreeNode(1);
    TreeNode* n2 = new TreeNode(2);
    TreeNode* n3 = new TreeNode(3);

    n1->left = nullptr;
    n1->right = n2;
    n2->left = n3;
    n2->right = nullptr;
    n3->left = nullptr;
    n3->right = nullptr;

    TreeNode* root = n1;
    Solution *solution = new Solution();
    vector<int> ret = solution->preorderTraversal(root);
    for (auto x : ret) {
        printf("%d  ", x);
    }
    printf("\n");
    return 0;
}

• Python代码

# -*- coding: utf-8 -*-

from typing import List, Optional


class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:
    def __init__(self):
        pass

    # 前序遍历：将当前根节点的值放入answer数组末尾，然后递归遍历左右节点。
    def mypreorder(self, root: Optional[TreeNode], answer: List[int]):
        if None == root:
            return

        answer.append(root.val)             # 第一步：输出根节点的值。
        self.mypreorder(root.left, answer)  # 第二步：递归遍历左子树。
        self.mypreorder(root.right, answer) #  第三步：递归遍历右子树。

    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        answer: List[int] = []
        self.mypreorder(root, answer)
        return answer


def main():
    n1 = TreeNode(1)
    n2 = TreeNode(2)
    n3 = TreeNode(3)

    n1.left = None
    n1.right = n2
    n2.left = n3
    n2.right = None
    n3.left = None
    n3.right = None

    root: TreeNode = n1
    solution = Solution()
    ret = solution.preorderTraversal(root)
    print(ret)


if __name__ == "__main__":
    main()

说明

• 对应LeetCode第144题。
• 链接：https://leetcode-cn.com/problems/binary-tree-preorder-traversal/