请尽可能列举更多的方案-Go服务器开发

当然可以！中序遍历二叉树的方法有多种，可以采用不同的方式实现，包括递归、迭代（使用栈）和 Morris 遍历等。以下是几种常见的中序遍历方案：

1. 递归法

这是最直观的方法，通过递归来实现中序遍历。

void inorderTraversal(TreeNode* root, vector<int>& result) {
    if (root == nullptr) return;
    
    inorderTraversal(root->left, result);
    result.push_back(root->val);
    inorderTraversal(root->right, result);
}

2. 迭代法（使用栈）

使用显式栈来模拟递归的过程，适合那些不想使用递归的人。

#include <stack>

vector<int> inorderTraversalIterative(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> stack;

    TreeNode* current = root;
    
    while (current != nullptr || !stack.empty()) {
        while (current != nullptr) {
            stack.push(current);
            current = current->left;
        }
        
        current = stack.top();
        stack.pop();
        
        result.push_back(current->val);
        
        current = current->right;
    }
    
    return result;
}

3. Morris 中序遍历

这种方法在遍历时不需要额外的空间，但会修改树结构，最终需要恢复原来的结构。

vector<int> morrisInorderTraversal(TreeNode* root) {
    vector<int> result;
    TreeNode *current = root, *pre;

    while (current != nullptr) {
        if (current->left == nullptr) {
            result.push_back(current->val);
            current = current->right;
        } else {
            // 找到当前节点左子树的最右节点
            pre = current->left;
            while (pre->right != nullptr && pre->right != current) {
                pre = pre->right;
            }

            // Establish thread
            if (pre->right == nullptr) {
                pre->right = current; // 创建线程
                current = current->left;
            } else { 
                pre->right = nullptr; // 恢复原形态
                result.push_back(current->val);
                current = current->right;
            }
        }
    }

    return result;
}

4. 分层遍历（适用于特定需求）

虽然不是标准中序遍历，但可以根据需求对结果进行调整，例如返回每一层节点的中序值。

vector<vector<int>> levelOrderInorder(TreeNode* root) {
   vector<vector<int>> levels;

   function<void(TreeNode*, int)> dfs =
       [&](TreeNode* node, int level){
           if (!node) return;

           if(levels.size() <= level)
               levels.emplace_back();

           levels[level].push_back(node -> val);

           dfs(node -> left, level + 1);
           dfs(node -> right, level + 1);
       };

   dfs(root, 0);

   for(auto &level : levels)
       sort(level.begin(), level.end()); // 对每层结果进行排序，以符合某些特定要求

   return levels; 
}