每日一题——二叉树的前序遍历和中序遍历和后序遍历

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

题目描述

给定一棵二叉树的根节点 root，返回其节点值的前序遍历。前序遍历的顺序是：首先访问当前节点，然后访问左子树，最后访问右子树。

数据范围：

• 二叉树的节点数量满足 $1\le n\le 100$。
• 每个节点的值满足 $1\le val\le 100$，且所有节点值各不相同。

示例：

示例 1：

输入：

{1, #, 2, 3}

返回值：

[1, 2, 3]

解题思路

前序遍历二叉树的方式有两种：递归法和迭代法。

1. 递归法

前序遍历的顺序为：

• 访问当前节点
• 递归地遍历左子树
• 递归地遍历右子树

递归法的实现非常简单，只需要依次访问节点即可。

2. 迭代法

迭代法通过栈来模拟递归过程。通过栈管理节点，先将根节点入栈，然后每次从栈中取出一个节点，访问其值，并将其右子节点和左子节点依次压入栈中。这样，左子节点会被优先访问，符合前序遍历的顺序。

代码实现（递归法）

以下是递归法的实现代码，我们通过辅助函数 Traversal 来进行前序遍历，并将遍历的结果保存在一个数组中。

#include <stdio.h>
#include <stdlib.h>

// 定义二叉树节点结构
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

/**
 * 递归遍历二叉树
 * @param root 当前节点
 * @param returnSize 返回的数组大小
 * @param result 存储遍历结果的数组
 */
void Traversal(struct TreeNode* root, int* returnSize, int* result) {
    if (!root) return;  // 如果当前节点为空，直接返回

    // 将当前节点的值添加到结果数组中
    result[*returnSize] = root->val;
    
    // 增加返回数组的大小计数
    (*returnSize)++;
  
    // 递归遍历左子树
    Traversal(root->left, returnSize, result);
    
    // 递归遍历右子树
    Traversal(root->right, returnSize, result);
}

/**
 * 前序遍历主函数
 * @param root 二叉树的根节点
 * @param returnSize 返回的数组大小
 * @return 遍历结果数组
 */
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    // 为返回数组分配足够的内存
    int* result = (int*)malloc(1000 * sizeof(int));
    
    // 初始化返回的数组大小为0
    *returnSize = 0;

    // 调用辅助函数进行前序遍历
    Traversal(root, returnSize, result);
    
    // 返回遍历结果
    return result;
}

// 测试用例
int main() {
    // 创建一个简单的二叉树
    struct TreeNode root = {1, NULL, NULL};
    struct TreeNode left = {2, NULL, NULL};
    struct TreeNode right = {3, NULL, NULL};
    root.left = &left;
    root.right = &right;

    int returnSize;
    int* result = preorderTraversal(&root, &returnSize);

    // 打印结果
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");

    // 释放内存
    free(result);

    return 0;
}

代码解析

1. TreeNode结构体：

   • 这是二叉树的节点结构，包含节点值 val、左子节点指针 left 和右子节点指针 right。

2. Traversal函数：

   • 该函数负责递归地遍历二叉树。每当访问一个节点时，将该节点的值存入结果数组 result，并递归遍历左子树和右子树。

3. preorderTraversal函数：

   • 该函数是前序遍历的入口。它首先为结果数组分配内存，然后调用 Traversal 函数来执行遍历。
   • 最终返回遍历结果的数组。

4. 内存管理：

   • 结果数组 result 是动态分配的，并且在使用完后会在主函数中释放。

示例输出

对于下面的二叉树：

    1
   / \
  2   3

输出结果为：

1 2 3

复杂度分析

• 时间复杂度：O(n)，其中n是二叉树中的节点数。每个节点都会被访问一次。
• 空间复杂度：O(n)，用于存储结果数组和递归栈空间。递归调用的最大深度为树的高度，最坏情况下为O(n)，即树退化为链表。

中序遍历

中序遍历与前序遍历类似，唯一不同的是访问节点的顺序，先访问左子树，再访问当前节点，最后访问右子树。

#include <stdio.h>
#include <stdlib.h>

// 定义二叉树节点结构
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

/**
 * 递归遍历二叉树的中序遍历
 * @param root 当前节点
 * @param returnSize 返回的数组大小
 * @param result 存储遍历结果的数组
 */
void Traversal(struct TreeNode* root, int* returnSize, int* result) {
    if (!root) return;  // 如果当前节点为空，直接返回

    // 递归遍历左子树
    Traversal(root->left, returnSize, result);
    
    // 将当前节点的值添加到结果数组中
    result[*returnSize] = root->val;

    // 增加返回数组的大小计数
    (*returnSize)++;

    // 递归遍历右子树
    Traversal(root->right, returnSize, result);
}

/**
 * 中序遍历主函数
 * @param root 二叉树的根节点
 * @param returnSize 返回的数组大小
 * @return 遍历结果数组
 */
int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    // 为返回数组分配足够的内存
    int* result = (int*)malloc(1000 * sizeof(int));

    // 初始化返回的数组大小为0
    *returnSize = 0;

    // 调用辅助函数进行中序遍历
    Traversal(root, returnSize, result);

    // 返回遍历结果
    return result;
}

// 测试用例
int main() {
    // 创建一个简单的二叉树
    struct TreeNode root = {1, NULL, NULL};
    struct TreeNode left = {2, NULL, NULL};
    struct TreeNode right = {3, NULL, NULL};
    root.left = &left;
    root.right = &right;

    int returnSize;
    int* result = inorderTraversal(&root, &returnSize);

    // 打印结果
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");

    // 释放内存
    free(result);

    return 0;
}

后序遍历

后序遍历的顺序为：

• 先遍历左子树
• 再遍历右子树
• 最后访问当前节点

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

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 *
 * @param root TreeNode类
 * @return int整型一维数组
 * @return int* returnSize 返回数组行数
 */
void Traversal(struct TreeNode* root, int* returnSize, int* result) {
    if (!root) return;  // 如果当前节点为空，直接返回

    // 递归遍历左子树
    Traversal(root->left, returnSize, result);

    // 递归遍历右子树
    Traversal(root->right, returnSize, result);

    // 将当前节点的值添加到结果数组中
    result[*returnSize] = root->val;

    // 增加返回数组的大小计数
    (*return

Size)++;
}

int* postorderTraversal(struct TreeNode* root, int* returnSize) {
    // 为返回数组分配足够的内存
    int* result = (int*)malloc(1000 * sizeof(int));

    // 初始化返回的数组大小为0
    *returnSize = 0;

    // 调用辅助函数进行后序遍历
    Traversal(root, returnSize, result);

    // 返回遍历结果
    return result;
}