LeetCode 94. Binary Tree Inorder Traversal（二叉树的中序遍历，C++，Python，递归+非递归）

Given a binary tree, return the inorder traversal of its nodes’ values.

Example:

Input: [1,null,2,3]

   1
    \
     2
    /
   3

Output: [1,3,2]
Follow up: Recursive solution is trivial, could you do it iteratively?

思路：中序遍历二叉树，递归版本非常简单。非递归需要使用栈来完成。具体思路参考这篇博客，其主要思想是：经过分析，中序遍历第一个遍历的元素一定位于二叉树的最左下角，所以先通过循环找到这个元素，因为后期遍历根节点和右子树需要使用路径上的元素，所以在查找左下角元素的同时用栈记录路上的节点
这部分代码：

while (p)
{
	s.push(p);
	p = p->lchild;
}

到达左下这个元素，只有一下两种情况，这时只要取出栈顶元素然后访问根节点，再访问右子树即可，右子树的访问方式继续重复左子树，根节点，右子树，所以只需要把上面的步骤重复执行即可。

p = s.top();
s.pop();
cout << p->data;

上面的说明遍历了根节点位于最左下的3个节点构成的子树，循环重复上面的过程就可以完成对整棵树的遍历。

while(!stk.empty()|| p){//栈不空说明还有元素没有被访问，开始时栈虽然为空但p不为空，最后p指向最右下根节点的右孩子为null
    if(p){//找左子树，
        stk.push(p);//记录路径上的节点
        p = p->left;
    }
    else{//p == NULL，到达了叶节点，或者左孩子为空（总之这时栈顶元素的左边肯定被访问过）
        p = stk.top();//取出栈顶元素
        stk.pop();//访问栈顶元素（根节点）
        ans.push_back(p->val);
        p = p->right;//访问栈顶元素的右子树
    }
}

C++递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        inorderTraversal2(root);
        return ans;
    }
    void inorderTraversal2(TreeNode* root) {
        if (root == NULL)
            return;
        inorderTraversal2(root->left);//左子树
        ans.push_back(root->val);//根节点
        inorderTraversal2(root->right);//右节点
    }
    
    vector<int> ans;
};

结果：

C++非递归
原理可以看这篇博客，非常详细

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> stk;
        TreeNode * p = root;
        while(!stk.empty()|| p){
            if(p){//找左子树，
                stk.push(p);//记录路径上的节点
                p = p->left;
            }
            else{//p == NULL，到达了叶节点，或者左孩子为空（总之这时栈顶元素的左边肯定被访问过）
                p = stk.top();//取出栈顶元素
                stk.pop();//访问栈顶元素（根节点）
                ans.push_back(p->val);
                p = p->right;//访问栈顶元素的右子树
            }
        }
        return ans;
    }

    vector<int> ans;
};

结果：

python递归

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        ans = []
        self.traversal(root, ans)
        return ans
        
    def traversal(self, root, ans):
        if root == None:
            return
        self.traversal(root.left, ans)
        ans.append(root.val)
        self.traversal(root.right, ans)

结果

python非递归

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        ans = []
        stack = []
        while len(stack) or root:
            if root:
                stack.append(root)
                root = root.left
            else:
                print(len(stack))
                root = stack[-1]
                stack.pop()
                ans.append(root.val)
                root = root.right
        
        return ans

结果