这是悦乐书的第285次更新，第302篇原创

01 看题和准备

今天介绍的是LeetCode算法题中Easy级别的第153题（顺位题号是671）。给定非空的特殊二叉树，其由具有非负值的节点组成，其中该树中的每个节点具有恰好两个或零个子节点。 如果节点具有两个子节点，则该节点的值是其两个子节点中的较小值。给定这样的二叉树，您需要输出由整个树中所有节点的值组成的集合中的第二个最小值。如果不存在这样的第二个最小值，则输出-1。例如：

    2
   / \
  2   5
     / \
    5   7

输出：5

    2
   / \
  2   2

输出：-1

本次解题使用的开发工具是eclipse，jdk使用的版本是1.8，环境是win7 64位系统，使用Java语言编写和测试。

02 第一种解法

使用HashSet和递归。将每一个节点值添加进set，然后遍历set，找出其中第二小的值，最后输出即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {

    public int findSecondMinimumValue(TreeNode root) {
        Set<Integer> set = new HashSet<Integer>();
        helper(root, set);
        int min = Integer.MAX_VALUE;
        int second = Integer.MAX_VALUE;
        for (int value : set) {
            if (value < min) {
                second = min;
                min = value;
            } else if (value < second) {
                second = value;
            }
        }
        if (min == second) {
            return -1;
        }
        return second == Integer.MAX_VALUE ? -1 : second;
    }

    public void helper(TreeNode node, Set<Integer> set){
        if (node == null) {
            return ;
        }
        set.add(node.val);
        helper(node.left, set);
        helper(node.right, set);
    }
}

03 第二种解法

我们也可以不使用HashSet。依旧使用递归，但是将最小值，第二最小值作为了全局变量，最小值只申明，在方法内部初始化为根节点的节点值。在递归方法里，如果当前节点值大于最小值且小于第二小值，那么就更新第二小的值；如果当前节点值等于最小值，就继续遍历其左子节点和右子节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int min ;
    int second = Integer.MAX_VALUE;
    public int findSecondMinimumValue(TreeNode root) {
        min = root.val;
        helper(root);
        if (min == second) {
            return -1;
        }
        return second == Integer.MAX_VALUE ? -1 : second;
    }

    public void helper(TreeNode node) {
        if (node == null) {
            return ;
        }
        if (node.val > min && node.val < second) {
            second = node.val;
        } else if (node.val == min) {
            helper(node.left);
            helper(node.right);
        }
    }
}

04 第三种解法

针对第一种解法，也可以使用迭代的方式。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int findSecondMinimumValue(TreeNode root) {
        Set<Integer> set = new HashSet<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode temp = stack.pop();
            set.add(temp.val);
            if (temp.left != null) {
                stack.push(temp.left);
            }
            if (temp.right != null) {
                stack.push(temp.right);
            }
        }
        int min = Integer.MAX_VALUE;
        int second = Integer.MAX_VALUE;
        for (int value : set) {
            if (value < min) {
                second = min;
                min = value;
            } else if (value < second) {
                second = value;
            }
        }
        if (min == second) {
            return -1;
        }
        return second == Integer.MAX_VALUE ? -1 : second;
    }
}

05 第四种解法

针对第二种解法，也可以使用迭代的方式。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int findSecondMinimumValue(TreeNode root) {
        int min = root.val;
        int second = Integer.MAX_VALUE;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            if (node.val > min && node.val < second) {
                second = node.val;
            } else if (node.val == min) {
                if (node.left != null) {
                    stack.push(node.left);
                }
                if (node.right != null) {
                    stack.push(node.right);
                }
            }
        }
        if (min == second) {
            return -1;
        }
        return second == Integer.MAX_VALUE ? -1 : second;
    }
}

06 小结

算法专题目前已日更超过四个月，算法题文章153+篇，公众号对话框回复【数据结构与算法】、【算法】、【数据结构】中的任一关键词，获取系列文章合集。

以上就是全部内容，如果大家有什么好的解法思路、建议或者其他问题，可以下方留言交流，点赞、留言、转发就是对我最大的回报和支持！