检查二叉树（不是 BST）是否有重复值

在二叉树的操作中，有时候需要检查二叉树中的元素是否存在重复。在二叉搜索树（BST）中，重复没有太大的问题，因为可以根据元素值大小来比较。但在普通的二叉树中，我们需要采用其他的方式来检查是否有重复。

下面我们介绍三种实现方式。

方法一：哈希表

我们可以使用哈希表记录二叉树中已出现的元素。具体实现中，可以使用一个 HashSet（Python 中的 set）来记录。遍历二叉树时，如果当前元素已经在 HashSet 中了，就说明有重复元素。

以下是使用 Python 语言实现：

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def check_duplicate(root):
    seen = set()
    stack = [root]

    while stack:
        node = stack.pop()
        if node:
            if node.val in seen:
                return True
            seen.add(node.val)
            stack.append(node.right)
            stack.append(node.left)

    return False

以上是迭代实现方式，也可以使用递归实现方式。

def check_duplicate(root):
    seen = set()

    def helper(node):
        if not node:
            return False
        if node.val in seen:
            return True
        seen.add(node.val)
        return helper(node.left) or helper(node.right)

    return helper(root)

方法二：中序遍历

我们可以对二叉树进行中序遍历，然后按序查看每个元素是否存在相邻元素相同的情况。具体实现中，可以使用递归实现。

以下是使用 Python 语言实现：

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def check_duplicate(root):
    prev = None

    def helper(node):
        nonlocal prev
        if not node:
            return False
        if helper(node.left):
            return True
        if prev is not None and prev == node.val:
            return True
        prev = node.val
        return helper(node.right)

    return helper(root)

方法三：暴力法

我们可以使用两个嵌套循环来检查每个元素是否有重复。具体实现中，使用一个队列存储需要遍历的节点，然后使用两个循环来取出队列中的节点，对比元素是否相等。

以下是使用 Python 语言实现：

from collections import deque

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def check_duplicate(root):
    queue = deque([root])

    while queue:
        node = queue.popleft()
        if node:
            val = node.val
            for n in queue:
                if n.val == val:
                    return True
            queue.append(node.left)
            queue.append(node.right)

    return False

以上是迭代实现方式，也可以使用递归实现方式。

def check_duplicate(root):
    queue = deque([root])

    def helper(node):
        if not node:
            return False
        val = node.val
        for n in queue:
            if n.val == val:
                return True
        queue.append(node)
        return helper(node.left) or helper(node.right)

    return helper(root)

以上是三种实现方式，其中哈希表方式最为高效，时间复杂度为O(n)，空间复杂度为O(n)。中序遍历方式的时间复杂度也是O(n)，但空间复杂度为O(1)。暴力法时间复杂度为O(n^2)，空间复杂度为O(n)。