二叉树前序、中序和后序遍历

94. Binary Tree Inorder Traversal 二叉树的中序遍历
    解法一：递归

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

解法二：栈

 vector<int> inorderTraversal(TreeNode* root) {
        vector<int>result;
        if(root == NULL) return result;
        stack<TreeNode*>s;
        s.push(root);
        while(!s.empty()){
            while(s.top()->left !=NULL){
                s.push(s.top()->left);
            }
            while(!s.empty()){
                TreeNode* node = s.top();
                result.push_back(node->val);
                s.pop();
                if(node->right !=NULL){
                    s.push(node->right);
                    break;}
            }
        }
        return result;
    }
};

解法三;Morris Traversal

void inorderMorrisTraversal(TreeNode *root) {
    TreeNode *cur = root, *prev = NULL;
    while (cur != NULL)
    {
        if (cur->left == NULL)
        {
            printf("%d ", cur->val);
            cur = cur->right;
        }
        else
        {
            // find predecessor
            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;
        printf("%d ", cur->val);
        cur = cur->right;
    }
}
    }
}

144. 二叉树的前序遍历
     1、栈

def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        stack = [root]
        while stack:
            node = stack.pop()
            if node:
                res.append(node.val)
                stack.append(node.right)
                stack.append(node.left)
        return res

2、递归

class Solution(object):
    def __init__(self):
        self.res = []
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """  
        if root==None:
            return self.res
        self.res.append(root.val)
        if root.left != None:
            list(self.preorderTraversal(root.left))
        if root.right != None:
            list(self.preorderTraversal(root.right))
        return self.res

145. 二叉树的后序遍历
     一、栈

class Solution:
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None:
            return []

        stack, output = [root], []
        while stack:
            root = stack.pop()
            output.append(root.val)
            if root.left is not None:
                stack.append(root.left)
            if root.right is not None:
                stack.append(root.right)
                
        return output[::-1]

二、递归

class Solution:
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        r = []
        
        #if not root:
            #return r
        
        def traversal(_r):
            if not _r:
                return
            traversal(_r.left)
            traversal(_r.right)
            r.append(_r.val)
        
        traversal(root)
        return r