题解：二叉树的中序遍历（94.二叉树的中序遍历）

题目描述

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

解题思路

        二叉树的中序遍历是一种常见的树遍历方法。它按照访问左子树——根节点——右子树的顺序进行。本文将介绍三种实现二叉树中序遍历的方法：递归、迭代和 Morris 遍历，并详细分析每种方法的复杂度。

方法一：递归

思路与算法

        递归是最直观的中序遍历实现方式。中序遍历的特点是先遍历左子树，然后访问根节点，最后遍历右子树。因此，可以通过递归函数来实现这一过程：

1. 定义 inorder(root) 表示当前遍历到 root 节点的答案。
2. 递归调用 inorder(root.left) 遍历 root 节点的左子树。
3. 将 root 节点的值加入结果数组 res。
4. 递归调用 inorder(root.right) 遍历 root 节点的右子树。
5. 递归终止条件为碰到空节点。

代码实现

class Solution {
public:
    void inorder(TreeNode* root, vector<int>& res){
        if(root == NULL){
            return;
        }
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        return res;
    }
};

复杂度分析

- 时间复杂度：O(n)，其中 n 为二叉树节点的个数。每个节点会被访问一次且只会被访问一次。
- 空间复杂度：O(n)，取决于递归的栈深度，在最坏情况下（例如一条链表），栈深度会达到 O(n)。

方法二：迭代

思路与算法

        迭代方法通过显式地使用栈来模拟递归过程。具体实现步骤如下：

1. 初始化一个栈 stk 和结果数组 res。
2. 当 root 不为空或栈不为空时，执行以下操作：
   - 将所有左子树节点压入栈，直至左子树为空。
   - 弹出栈顶节点，将其值加入结果数组。
   - 访问弹出节点的右子树。

代码实现

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stack;
        while(root != NULL || !stack.empty()){
            while(root != NULL){
                stack.push(root);
                root = root->left;
            }
            root = stack.top();
            stack.pop();
            res.push_back(root->val);
            root = root->right;
        }
        return res;
    }
};

复杂度分析

- 时间复杂度：O(n)，每个节点会被访问一次。
- 空间复杂度：O(n)，栈的最大深度为 n。

方法三：Morris 中序遍历

思路与算法

        Morris 遍历算法通过修改树结构实现中序遍历，能将空间复杂度降为 O(1)。其核心思想是利用树的叶节点的空闲指针来回溯树结构。具体步骤如下：

对于当前节点 root：
   - 如果 root 没有左孩子，将 root 的值加入结果数组，并访问 root 的右孩子。
   - 如果 root 有左孩子，找到左子树中最右的节点（前驱节点 predecessor）。
           - 如果 predecessor 的右孩子为空，则将其右孩子指向 root，并继续遍历左子树。
           - 如果 predecessor 的右孩子不为空，说明已回到 root，将 predecessor 的右孩子置空，将 root 的值加入结果数组，并访问右孩子。

 代码实现

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        TreeNode *predecessor = NULL;

        while (root != NULL) {
            if (root->left != NULL) {
                // predecessor 节点就是当前 root 节点向左走一步，然后一直向右走至无法走为止
                predecessor = root->left;
                while (predecessor->right != NULL && predecessor->right != root) {
                    predecessor = predecessor->right;
                }
                
                // 让 predecessor 的右指针指向 root，继续遍历左子树
                if (predecessor->right == NULL) {
                    predecessor->right = root;
                    root = root->left;
                }
                // 说明左子树已经访问完了，我们需要断开链接
                else {
                    res.push_back(root->val);
                    predecessor->right = NULL;
                    root = root->right;
                }
            }
            // 如果没有左孩子，则直接访问右孩子
            else {
                res.push_back(root->val);
                root = root->right;
            }
        }
        return res;
    }
};

复杂度分析

- 时间复杂度：O(n)，每个节点最多被访问两次。
- 空间复杂度：O(1)，只使用了常数级别的额外空间。

总结

        本文介绍了二叉树中序遍历的三种方法：递归、迭代和 Morris 遍历。递归方法最为直观，迭代方法显式使用栈，Morris 遍历则巧妙地使用空闲指针，实现了 O(1) 空间复杂度。选择哪种方法主要取决于具体应用场景和对空间复杂度的要求。Morris遍历还没弄得很明白！

拓展

        二叉树的遍历方法（前序，中序，后序）中前中后针对的是根节点。

DLR--前序遍历（根在前，从左往右，一棵树的根永远在左子树前面，左子树又永远在右子树前面 ）

LDR--中序遍历（根在中，从左往右，一棵树的左子树永远在根前面，根永远在右子树前面）

LRD--后序遍历（根在后，从左往右，一棵树的左子树永远在右子树前面，右子树永远在根前面）

typedef struct TreeNode
{
    int data;
    TreeNode * left;
    TreeNode * right;
    TreeNode * parent;
}TreeNode;
 
void pre_order(TreeNode * Node)//前序遍历递归算法
{
    if(Node == NULL)
        return;
    printf("%d ", Node->data);//显示节点数据，可以更改为其他操作。在前面
    pre_order(Node->left);
    pre_order(Node->right);
}
void middle_order(TreeNode *Node)//中序遍历递归算法
{
    if(Node == NULL)
        return;
    middle_order(Node->left);
    printf("%d ", Node->data);//在中间
    middle_order(Node->right);
}
void post_order(TreeNode *Node)//后序遍历递归算法
{
    if(Node == NULL)
        return; 
    post_order(Node->left);
    post_order(Node->right);
    printf("%d ", Node->data);//在最后
}