二叉树的前序、中序、后序遍历

二叉树的前序、中序、后序

1.二叉树的前序遍历

题目：

二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

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

示例 5：

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

提示：

• 树中节点数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

思路：

1. 其实就是要让二叉树前序遍历
2. 但是题目需要我们将遍历到的节点的值放进数组里面，而我们又不知道二叉树有多少个节点，这样就不知道数组要开辟多少空间，
3. 因此我们需要先编写一个获取二叉树节点个数的函数
4. 然后就让前序遍历二叉树，把遍历到的值放进数组中就行了
5. 但是需要注意的是，传数组的下标i进去的时候，需要传址调用（因为我们采用递归来实现前序遍历）

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    
};

/*
 * Note: The returned array must be malloced, assume caller calls free().
 */

    typedef struct TreeNode TreeNode;

// 获取二叉树的节点个数
int TreeSize(TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }

    return 1 + TreeSize(root->left) + TreeSize(root->right);
}

// 前序遍历  （递归实现）
void _preorderTraversal(TreeNode* root, int* retArr, int* pi)
{
    if (root == NULL)
        return;

    retArr[(*pi)] = root->val; // i 的值我们通过解引用去拿到
    (*pi)++;


    _preorderTraversal(root->left, retArr, pi);
    _preorderTraversal(root->right, retArr, pi);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    // 创建一个数组 空间个数是二叉树的节点数
    int* retArr = (int*)malloc(sizeof(int) * TreeSize(root));

    // 前序遍历 (要把二叉树节点的值 放进retArr数组中)
    int i = 0;
    _preorderTraversal(root, retArr, &i);
    // 这里是一定要传 i的地址的，不然每次递归的时候，都会开辟新的函数栈帧，i的值无法被改变。 传值调用
    // 传地址进去就是 传址调用

    *returnSize = TreeSize(root);

    return retArr;
}

要注意递归展开的过程，理解了就能知道为什么要传址调用了。

2.二叉树的中序遍历

题目：

二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

• 树中节点数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

思路：

中序遍历 - 左子树 ——根——右子树

除了要在递归的时候注意顺序，其他思路和前序是一样的。

代码：

typedef struct TreeNode TreeNode;

// 获取二叉树节点个数
int TreeSize(TreeNode* root)
{
    if (root == NULL)
        return 0;

    // 二叉树节点个数 = 1 + 左子树节点个数 + 右子树节点个数
    return 1 + TreeSize(root->left) + TreeSize(root->right);
}

// 中序遍历
void _inorderTraversal(TreeNode* root, int* retArr, int* pi)
{
    if (root == NULL)
        return;

    // 这里我们要中序遍历，【左子树 根 柚子树】
    _inorderTraversal(root->left, retArr, pi);

    retArr[(*pi)] = root->val;
    (*pi)++;

    _inorderTraversal(root->right, retArr, pi);
}


int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
    // 要将遍历到的节点放进数组中
    // 我们不知道二叉树节点多少，也就不知道数组要开辟多少空间。因此需要自己写一个获取二叉树节点个数的函数
    int size = TreeSize(root);
    int* retArr = (int*)malloc(sizeof(int) * size);

    //中序遍历）（递归实现）
    int i = 0;
    _inorderTraversal(root, retArr, &i);

    *returnSize = size;

    return retArr;
}

3.二叉树的后序遍历

题目：

二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

• 树中节点的数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

思路：

后序遍历 - 左子树——右子树——根

注意递归时的调用顺序，其他思路和前序中序差不多。

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    
};

/*
 * Note: The returned array must be malloced, assume caller calls free().
 */

typedef struct TreeNode TreeNode;

// 获取二叉树的节点个数
int TreeSize(TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }

    return 1 + TreeSize(root->left) + TreeSize(root->right);
}

// 后序遍历
void _postorderTraversal(TreeNode* root, int* retArr, int* pi)
{
    if (root == NULL)
        return;

    // 后序遍历 【左子树 右子树 根】
    _postorderTraversal(root->left, retArr, pi);
    _postorderTraversal(root->right, retArr, pi);

    retArr[(*pi)] = root->val;
    (*pi)++;
}

int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
    // 要将遍历到的节点放进数组中
    // 我们不知道二叉树节点多少，也就不知道数组要开辟多少空间。因此需要自己写一个获取二叉树节点个数的函数
    int size = TreeSize(root);
    int* retArr = (int*)malloc(sizeof(int) * size);

    // 后序遍历（递归实现）
    int i = 0;
    _postorderTraversal(root, retArr, &i);

    *returnSize = size;

    return retArr;
}