C++ 解法, 执行用时: 2ms, 内存消耗: 376KB, 提交时间: 2021-07-18

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

C 解法, 执行用时: 2ms, 内存消耗: 376KB, 提交时间: 2021-05-10

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param root TreeNode类 
 * @return int整型一维数组
 * @return int* returnSize 返回数组行数
 */
int* inorderTraversal(struct TreeNode* root, int* returnSize ) {
    // write code here
    struct TreeNode *tmpnode[200]={0};
    struct TreeNode *node = root;
    int index = 0;
    int num = 0;
    if(NULL == root || NULL == returnSize)
        return NULL; 
    int *arr = (int*)malloc(sizeof(int)*200);
    memset(arr,0,sizeof(int)*200);
    
    while(node)
    {
        while(node)
        {
            tmpnode[index++] = node;
            node = node->left; 
        }
         
        do
        {
            node = tmpnode[--index];
            arr[num++] = node->val;
        }while(index && !node->right);
        node = node->right;
    }
    
    *returnSize = num;
    return arr;
}

C++ 解法, 执行用时: 2ms, 内存消耗: 376KB, 提交时间: 2021-04-24

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> inorderTraversal(TreeNode* root) {
        // write code here
        stack<TreeNode*>s;
        vector<int> res;
        while(root!=NULL || !s.empty()){
            while(root!=NULL){
                s.push(root);
                root=root->left;
            }
            auto tmp=s.top();
            s.pop();
            res.push_back(tmp->val);
            root=tmp->right;
        }
        return res;
    }
};

C++ 解法, 执行用时: 2ms, 内存消耗: 380KB, 提交时间: 2021-07-17

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> inorderTraversal(TreeNode* root) {
        // write code here
        vector<int> in = inOrder(root);
        return in;
    }
    
    vector<int> inOrder(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        
        while (root || stk.size()) {
            while (root) {
                stk.push(root);
                root = root->left;
            }
            root = stk.top();
            stk.pop();
            res.push_back(root->val);
            root = root->right;
        }
        
        return res;
    }
};

C++ 解法, 执行用时: 2ms, 内存消耗: 384KB, 提交时间: 2021-07-18

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> ans;
    vector<int> inorderTraversal(TreeNode* root) {
        // write code here
        dfs(root);
        return ans;
    }
    
    void dfs(TreeNode* root){
        if(root==nullptr){
            return ;
        }
        dfs(root->left);
        ans.push_back(root->val);
        dfs(root->right);
    }
};