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

一、前序

(1)、题目

示例 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]

(2)、思路分析和完整代码

1.主函数的返回类型是int*类型，代表要将二叉树数据存储在一个数组中。

2.数组不能是静态数组，对内存不友好，而动态数组就必须要知道节点个数,因此需要一个函数来求节点个数。

3.二叉树的前序遍历不能放在PreorderTraversal,要另外再创建一个函数。

计算二叉树的节点个数

巧妙地使用了三元运算符和递归

如果根节点是NULL，就返回0，否则就返回根的左节点的个数和根的右节点的个数。

 //计算二叉树的节点个数
int TreeSize(struct TreeNode*root){
    return root==NULL?0:TreeSize(root->left)+TreeSize(root->right)+1;

 }

二叉树的前序遍历

注意：以 *i 为数组的下标标记，传参时要传下标的地址，不能只传参。如果只传参的话，在递归中，遍历左子树时，数组的下标也发生了变化。但是返回到上一级以后，下标还是原来遍历左数组之前的下标，又将原下标传给了右子树的遍历。所以要传下标的地址。

 void PrevOrder(struct TreeNode*root,int *a,int* i){
    if(root==NULL){
        return ;
    }
    a[*i] = root->val;
    (*i)++;
    PrevOrder(root->left,a,i);
    PrevOrder(root->right,a,i);

 }

返回二叉树遍历后的数组

细节：在main函数中要使用数组，就必须要知道数组的大小，所以传二叉树节点个数的地址int*returnSize。因为函数只能返回一个值，函数已经要返回二叉树节点的数组，除了将个数设置为全局变量以外，还可以将个数的地址作为一个参数传入函数。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
   //要动态开辟一个数组之前，要先确定数组的大小
    int size=TreeSize(root);
    //创建数组
    int*a=(int*)malloc(sizeof(int)*size);
    //二叉树的前序遍历调用递归,递归过程不能直接放在该函数中，可以再调用一个遍历函数
    int i=0;
    PrevOrder(root,a,&i);
    *returnSize=size;
    return a;
}

二、二叉树的后序遍历

后序的遍历和前序的遍历的思路几乎差不多。只是在遍历二叉树时，要先遍历左子树，然后是右子树，最后再存储根节点。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 //计算节点个数
 int TreeSize(struct TreeNode*root){
    return root==NULL?0:TreeSize(root->left)+TreeSize(root->right)+1;
 }
 //遍历二叉树
 void PostOrder(struct TreeNode*root,int *a,int *i){
    if(root==NULL){
        return ;
    }
    PostOrder(root->left,a,i);
    PostOrder(root->right,a,i);
    a[*i]=root->val;
    (*i)++;

 }
 //返回二叉树节点的数组
int* postorderTraversal(struct TreeNode* root, int* returnSize) {
    int size=TreeSize(root);
    int*a=(int*)malloc(sizeof(int)*size);
    int i=0;
    PostOrder(root,a,&i);
    *returnSize=size;
    return a;
}

三、二叉树的中序遍历

中序的遍历和前序的遍历的思路几乎差不多。只是在遍历二叉树时，要先遍历左子树，然后是存储根节点，最后再遍历右子树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 //计算二叉树的节点个数
 int TreeSize(struct TreeNode*root){
    return root==NULL?0:TreeSize(root->left)+TreeSize(root->right)+1;
 }
 void InOrder(struct TreeNode*root,int*a,int*i){
    if(root==NULL){
        return ;
    }
    InOrder(root->left,a,i);
    a[*i]=root->val;
    (*i)++;
    InOrder(root->right,a,i);

 }
int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    int size=TreeSize(root);
    int* a=(int*)malloc(sizeof(int)*size);
    int i=0;
    InOrder(root,a,&i);
    *returnSize=size;
    return a;
}