leetcode【中等】94、144、145二叉树的中序、前序、后序遍历

思路1：递归

中序遍历：

一直向左遍历，直到最后一层最左边，打印当前，转向右边

inorder(root.left)
	inorder(root.left)
		inorder(root.left)
			为null返回
		打印节点
		inorder(root.right)
			inorder(root.left)
				inorder(root.left)
				........

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        def inorder(root):
            if not root:
                return
            inorder(root.left)
            res.append(root.val)
            inorder(root.right)
                
        inorder(root)
        return res

class Solution {
    List<Integer>res=new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        dfs(root);
        return res;
    }
    public void dfs(TreeNode root){
        if(root==null) return;
        dfs(root.left);
        res.add(root.val);
        dfs(root.right);
    }
}

前序遍历：

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        def preorder(root,res):
            if not root:
                return
            res.append(root.val)
            preorder(root.left,res)
            preorder(root.right,res)

        res=[]
        preorder(root,res)
        return res

class Solution {
    List<Integer>res=new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        dfs(root);
        return res;
    }
    public void dfs(TreeNode root){
        if(root==null) return;
        res.add(root.val);
        dfs(root.left);
        dfs(root.right);
    }
}

后序遍历：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        def postorder(root,res):
            if not root:
                return
            postorder(root.left,res)
            postorder(root.right,res)
            res.append(root.val)

        res=[]
        postorder(root,res)
        return res

思路2：非递归（迭代）

中序遍历：

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        stack=[]

        while root or stack:
            if root:
                stack.append(root)
                root=root.left#找到最左
            else:
                tem=stack.pop()
                res.append(tem.val)#中
                root=tem.right#右
        return res

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer>res=new ArrayList<>();
        List<TreeNode>stack=new ArrayList<>();
        while(root!=null || stack.size()!=0){
            if(root!=null){
                stack.add(root);
                root=root.left;
            }else{
                TreeNode node=stack.remove(stack.size()-1);
                res.add(node.val);
                root=node.right;
            }
        }
        return res;
    } 
}

前序遍历：

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        stack=[]

        while root or stack:
            if root:
                stack.append(root)
                res.append(root.val)#中
                root=root.left#左
            else:
                tem=stack.pop()
                root=tem.right#右
        return res

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer>res=new ArrayList<>();
        List<TreeNode>stack=new ArrayList<>();
        while(root!=null || stack.size()!=0){
            if(root!=null){
                res.add(root.val);
                stack.add(root);
                root=root.left;
            }else{
                TreeNode node=stack.remove(stack.size()-1);
                root=node.right;
            }
        }
        return res;
    }
}

后序遍历：

（本来是左右中，可以中右左然后每次插入到列表开端）

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        stack=[]

        while root or stack:
            if root:
                stack.append(root)
                res.insert(0,root.val)#中，每次插入到最前面
                root=root.right#右
            else:
                tem=stack.pop()
                root=tem.left#左
        return res

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer>res=new ArrayList<>();
        List<TreeNode>stack=new ArrayList<>();
        while(root!=null || stack.size()!=0){
            if(root!=null){
                res.add(0,root.val);
                stack.add(root);
                root=root.right;
            }else{
                TreeNode node=stack.remove(stack.size()-1);
                root=node.left;
            }
        }
        return res;
    }
}