每日算法 - 二叉树中序遍历（基础算法）

目录

题目

解题思路

中序遍历代码

递归（最基础）

栈

莫瑞斯

总结

完整测试代码

---

---

题目

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

示例:

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

输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

解题思路

https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/er-cha-shu-de-zhong-xu-bian-li-by-leetcode/

 

 

---

中序遍历代码

• 递归（最基础）

public List < Integer > inorderTraversal(TreeNode root) {
        List < Integer > res = new ArrayList < > ();
        helper(root, res);
        return res;
    }

    public void helper(TreeNode root, List < Integer > res) {
        if (root != null) {
            // 左
            if (root.left != null) {
                helper(root.left, res);
            }
            // 根
            res.add(root.val);
            // 右
            if (root.right != null) {
                helper(root.right, res);
            }
        }
    }

 

---

• 栈

public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode curr = root;
        while (curr != null || !stack.isEmpty()) {
            while (curr != null) {
                stack.push(curr);
                curr = curr.left;
            }
            curr = stack.pop(); 
            res.add(curr.val); // 先存左，然后根，最后右
            curr = curr.right;
        }
        return res;
    }

---

• 莫瑞斯

  public List < Integer > inorderTraversal(TreeNode root) {
        List < Integer > res = new ArrayList < > ();
        TreeNode curr = root;
        TreeNode pre;
        while (curr != null) {
            if (curr.left == null) {
                res.add(curr.val);
                curr = curr.right; // move to next right node
            } else { // has a left subtree
                pre = curr.left;
                while (pre.right != null) { // find rightmost
                    pre = pre.right;
                }
                pre.right = curr; // put cur after the pre node
                TreeNode temp = curr; // store cur node
                curr = curr.left; // move cur to the top of the new tree
                temp.left = null; // original cur left be null, avoid infinite loops
            }
        }
        return res;
    }

 

---

总结

1、中序遍历： 左 - 中 - 右；

2、三种方法掌握最基础的递归，能够使用栈，了解使用莫瑞斯；

 

---

完整测试代码

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

/**
 * 前序遍历
 */
public class InorderTraversal {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.setLeft(new TreeNode(0));
        root.setRight(new TreeNode(2));
        root.getRight().setLeft(new TreeNode(3));
        root.getRight().setRight(new TreeNode(0));

        // 递归实现
        List<Integer> res = inorderTraversalByRecursive(root);

        // 迭代实现
        List<Integer> res2 = inorderTraversal(root);

        // Morris实现
        List<Integer> res3 = inorderTraversalByMorris(root);

        System.out.println("递归实现:");
        for (Integer item : res) {
            System.out.print(item + " ");
        }

        System.out.println(" ");
        System.out.println("迭代实现：");
        for (Integer item : res2) {
            System.out.print(item + " ");
        }

        System.out.println(" ");
        System.out.println("Morris实现：");
        for (Integer item : res2) {
            System.out.print(item + " ");
        }
    }

    /**
     * 迭代使用栈，中序遍历
     *
     * @param root
     * @return
     */
    public static List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode curr = root;
        while (curr != null || !stack.isEmpty()) {
            while (curr != null) {
                stack.push(curr);
                curr = curr.left;
            }
            curr = stack.pop();
            res.add(curr.val); // 先存左，然后根，最后右
            curr = curr.right;
        }
        return res;
    }

    /**
     * 递归
     */

    public static List<Integer> inorderTraversalByRecursive(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        helper(root, res);
        return res;
    }

    public static void helper(TreeNode root, List<Integer> res) {
        if (root != null) {
            // 左
            if (root.left != null) {
                helper(root.left, res);
            }
            // 根
            res.add(root.val);
            // 右
            if (root.right != null) {
                helper(root.right, res);
            }
        }
    }


    /**
     * Morris
     */

    public static List<Integer> inorderTraversalByMorris(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        TreeNode curr = root;
        TreeNode pre;
        while (curr != null) {
            if (curr.left == null) {
                res.add(curr.val);
                curr = curr.right; // move to next right node
            } else { // has a left subtree
                pre = curr.left;
                while (pre.right != null) { // find rightmost
                    pre = pre.right;
                }
                pre.right = curr; // put cur after the pre node
                TreeNode temp = curr; // store cur node
                curr = curr.left; // move cur to the top of the new tree
                temp.left = null; // original cur left be null, avoid infinite loops
            }
        }
        return res;
    }

}

 

输入如题，null用0代替。输出如下：

 

递归实现:
0 1 3 2 0  
迭代实现：
0 1 3 2 0  
Morris实现：
0 1 3 2 0