LeetCode Top 100 Liked Questions 94. Binary Tree Inorder Traversal (Java版; Medium)

welcome to my blog

LeetCode Top 100 Liked Questions 94. Binary Tree Inorder Traversal (Java版; Medium)

题目描述

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]

第一次做, 中续遍历, 循环版; 理解并牢记下面的核心

复杂度分析

时间复杂度：O(n)

空间复杂度：O(n)

核心(理解并牢记):
初始时curr指向head
当栈不为空或者curr不为null时
    如果curr不为null
        curr入栈
        curr指向curr.left
    如果curr为null
        curr指向弹出的栈顶元素
        将curr.val加入到最终结果中
        curr指向curr.right

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

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root==null)
            return res;
        Stack<TreeNode> s = new Stack<>();
        TreeNode curr = root;
        while(!s.isEmpty() || curr!=null){
            if(curr!=null){
                s.push(curr);
                curr = curr.left;
            }
            else{
                curr = s.pop();
                //保存"左"
                res.add(curr.val);
                //这一步非常妙, 下一次循环时
                //如果curr==null,则保存"根"; 如果curr!=null,则先处理"左"的右子树
                //(联想某一题:中序遍历下找某个节点的后继节点)
                curr = curr.right;
            }
        }
        return res;
    }
}

第一次做, 中序遍历, 递归版; 递归函数逻辑:打印左子树(新条件)的中序遍历结果, 打印当前节点(当前条件)的值, 打印右子树(新条件)的中序遍历结果

复杂度分析

时间复杂度：O(n)。递归函数 T(n) =2⋅T(n/2)+1。
空间复杂度：最坏情况下需要空间O(n),比如说只有左孩子的二叉树;平均情况为O(logn)

import java.util.List;
import java.util.ArrayList;

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root==null)
            return res;
        Core(res, root);
        return res;
    }
    //递归函数逻辑:打印左子树(新条件)的中序遍历结果, 打印当前节点(当前条件)的值, 打印右子树(新条件)的中序遍历结果
    public void Core(List<Integer> res, TreeNode root){
        //base case
        if(root==null)
            return;
        //
        Core(res, root.left);
        res.add(root.val);
        Core(res, root.right);
    }
}

题解, 中续遍历循环版, 使用内循环处理左孩子, 这样就直接找到了最左的节点; 思路相对更加直接

public class Solution {
    public List < Integer > inorderTraversal(TreeNode root) {
        List < Integer > res = new ArrayList < > ();
        Stack < TreeNode > stack = new Stack < > ();
        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;
    }
}