二叉树的中序遍历以及应用场景

定义

中序遍历（LDR）是二叉树遍历的一种，也叫做中根遍历、中序周游。在二叉树中，中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。

题目

给定一个二叉树，返回它的中序 遍历。

示例:

输入: [1,null,2,3]
1

2
/
3

输出: [1,3,2]

实现

public class BinaryTree_中序遍历 {
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) { val = x; }
    }

    /**
     * 递归实现
     */
    class Solution_by_recursion {
        public List<Integer> inorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            getResult(root,list);
            return list;
        }

        //递归
        private void getResult(TreeNode root,List<Integer> list){
            if(root != null){
                if (root.left != null){
                    getResult(root.left,list);
                }
                list.add(root.val);
                if(root.right != null){
                    getResult(root.right,list);
                }
            }
        }

        /**
         * 复杂度分析
         时间复杂度：O(n)O(n)。递归函数 T(n) = 2 \cdot T(n/2)+1T(n)=2⋅T(n/2)+1。
         空间复杂度：最坏情况下需要空间O(n)O(n)，平均情况为O(\log n)O(logn)。
         */

    }

    /**
     * 栈实现
     */
    class Solution_by_stack {

        //栈遍历
        public List<Integer> inorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            Stack<TreeNode> stack = new Stack<>();
            TreeNode current = root;
            while (current != null || !stack.empty()){
                while (current != null){
                    stack.push(current);
                    current = current.left;
                }
                current = stack.pop();
                list.add(current.val);
                current = current.right;
            }

            return list;
        }

        /**
         *
         * 复杂度分析

         时间复杂度：O(n)O(n)。

         空间复杂度：O(n)O(n)。
         */

    }

    public static void main(String[] args) {
        //输入: [1,null,2,3]
      
        BinaryTree_中序遍历 br = new BinaryTree_中序遍历();

        TreeNode  tn1 = br.new TreeNode(1);
        TreeNode  tn2 = br.new TreeNode(2);
        TreeNode  tn3 = br.new TreeNode(3);
        tn1.right = tn2;
        tn2.left = tn3;


        //递归
        Solution_by_recursion recursion = br.new Solution_by_recursion();
        List<Integer> list_1 = recursion.inorderTraversal(tn1);
        System.out.println("=============递归=============");
        for (Integer v : list_1) {
            System.out.println(v);
        }

        //栈
        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println("=============栈=============");
        Solution_by_stack stack = br.new Solution_by_stack();
        List<Integer> list_2 = stack.inorderTraversal(tn1);
        for (Integer v : list_2) {
            System.out.println(v);
        }
    }
}

# 应用场景
可以用来做表达式树，在编译器底层实现的时候用户可以实现基本的加减乘除，比如 a*b+c