Binary Tree Inorder Traversal

四种方法。

方法一：使用递归。

方法二：使用栈。

方法三：使用栈。

方法四：Morris遍历。

方法一代码：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        
        vector<int> result;
        
        if(root == NULL)
            return result;
        
        vector<int> lefts = inorderTraversal(root->left);
        vector<int> rights= inorderTraversal(root->right);
        
        result.insert(result.end(), lefts.begin(), lefts.end());
        result.push_back(root->val);
        result.insert(result.end(), rights.begin(), rights.end());
        
        return result;
    }
};

方法二，与先序访问类似，只需改变访问当前节点的代码位置，代码如下：

class Solution {  
public:  
    vector<int> inorderTraversal(TreeNode *root) {  
          
        vector<int> result;  
        stack<TreeNode*> s;  
        TreeNode *p = root;  
          
        while(p != NULL || !s.empty())  
        {  
            if(p != NULL)  
            {  
                //result.push_back(p->val); 前序遍历，在此访问  
                s.push(p);  
                p = p->left;  
            }
            else {
                p = s.top();  
                s.pop();  
                result.push_back(p->val); //中序遍历，在此访问  
                p = p->right;   
            }
        } 
        return result;  
    }  
}; 

方法三，与先序遍历的算法三类似，但因为需要先访问左右子树，然后才访问根节点，因此先将右子树进栈再将左子树进栈的方法，无法获取到根节点了，需要将根节点也进栈。此方法效率不高，在此省略，详细可参考博文 http://blog.csdn.net/kofsky/article/details/2886453。

方法四，Morris遍历。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> result;
        TreeNode *cur = root, *prev = NULL;
        
        while(cur != NULL)
        {
            if(cur->left == NULL)
            {
                result.push_back(cur->val);
                cur = cur->right;
            }
            else
            {
                prev = cur->left;
                while(prev->right != NULL && prev->right != cur)
                    prev = prev->right;
                
                if(prev->right == NULL)
                {
                    prev->right = cur;
                    cur = cur->left;
                }
                else
                {
                    prev->right = NULL;
                    result.push_back(cur->val);
                    cur = cur->right;
                }
            }
        }
        return result;
    }
};