基于不同策略的英文单词的查找和检索系统

基于不同策略的英文单词的查找和检索系统可以使用线性表、二叉排序树和哈希表三种不同的存储结构来实现。下面是对每种存储结构的介绍和相应的查找和检索功能的演示：

1. 线性表：
线性表是一种简单的数据结构，可以使用数组或链表来实现。在线性表中，单词按照插入的顺序进行存储。对于查找功能，可以使用顺序查找的方法，逐个比较单词，直到找到目标单词或者遍历完整个线性表。对于检索功能，可以统计目标单词在线性表中出现的次数。

# 线性表的查找和检索功能演示
word_list = ['apple', 'banana', 'orange', 'apple', 'grape']
target_word = 'apple'

# 查找功能
def linear_search(word_list, target_word):
    for i in range(len(word_list)):
        if word_list[i] == target_word:
            return i
    return -1

# 检索功能
def word_frequency(word_list, target_word):
    count = 0
    for word in word_list:
        if word == target_word:
            count += 1
    return count

# 演示
index = linear_search(word_list, target_word)
frequency = word_frequency(word_list, target_word)
print("Index of target word:", index)  # 输出：0
print("Frequency of target word:", frequency)  # 输出：2

2. 二叉排序树：
二叉排序树是一种有序的二叉树，左子树的值小于根节点的值，右子树的值大于根节点的值。在二叉排序树中，单词按照字典序进行存储。对于查找功能，可以使用二叉排序树的性质，递归地比较目标单词和当前节点的值，直到找到目标单词或者遍历完整个二叉排序树。对于检索功能，可以统计目标单词在二叉排序树中出现的次数。

# 二叉排序树的查找和检索功能演示
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

# 构建二叉排序树
def build_bst(word_list):
    root = None
    for word in word_list:
        root = insert_node(root, word)
    return root

# 插入节点
def insert_node(root, val):
    if root is None:
        return TreeNode(val)
    if val < root.val:
        root.left = insert_node(root.left, val)
    elif val > root.val:
        root.right = insert_node(root.right, val)
    return root

# 查找功能
def bst_search(root, target_word):
    if root is None or root.val == target_word:
        return root
    if target_word < root.val:
        return bst_search(root.left, target_word)
    else:
        return bst_search(root.right, target_word)

# 检索功能
def word_frequency_bst(root, target_word):
    if root is None:
        return 0
    if root.val == target_word:
        return 1 + word_frequency_bst(root.left, target_word) + word_frequency_bst(root.right, target_word)
    elif target_word < root.val:
        return word_frequency_bst(root.left, target_word)
    else:
        return word_frequency_bst(root.right, target_word)

# 演示
word_list = ['apple', 'banana', 'orange', 'apple', 'grape']
target_word = 'apple'
root = build_bst(word_list)
result = bst_search(root, target_word)
frequency = word_frequency_bst(root, target_word)
print("Result of search:", result)  # 输出：TreeNode object
print("Frequency of target word:", frequency)  # 输出：2

3. 哈希表：
哈希表是一种根据关键字直接访问内存位置的数据结构，可以使用字典来实现。在哈希表中，单词根据哈希函数的计算结果进行存储。对于查找功能，可以通过计算目标单词的哈希值，直接访问对应的内存位置，找到目标单词或者判断目标单词不存在。对于检索功能，可以统计目标单词在哈希表中出现的次数。

# 哈希表的查找和检索功能演示
word_dict = {'apple': 2, 'banana': 1, 'orange': 1, 'grape': 1}
target_word = 'apple'

# 查找功能
def hash_search(word_dict, target_word):
    if target_word in word_dict:
        return True
    else:
        return False

# 检索功能
def word_frequency_hash(word_dict, target_word):
    if target_word in word_dict:
        return word_dict[target_word]
    else:
        return 0

# 演示
result = hash_search(word_dict, target_word)
frequency = word_frequency_hash(word_dict, target_word)
print("Result of search:", result)  # 输出：True
print("Frequency of target word:", frequency)  # 输出：2