零基础数据结构与算法——第七章：算法实践与工程应用-搜索引擎

7.3 Java算法库

7.3.3 算法库的选择与使用

在选择和使用算法库时，需要考虑以下因素：

1. 功能需求：库是否提供了所需的功能。

2. 性能要求：库的性能是否满足需求。

3. 可靠性：库是否经过充分测试，是否有已知的bug。

4. 维护状态：库是否仍在积极维护，是否有社区支持。

5. 许可证：库的许可证是否与项目兼容。

6. 依赖关系：库的依赖是否会引入冲突。

使用算法库的最佳实践：

1. 了解库的API：在使用库之前，先了解其API和使用方法。

2. 阅读文档和示例：通过文档和示例了解库的功能和用法。

3. 测试库的性能：在实际项目中使用之前，测试库的性能是否满足需求。

4. 关注库的更新：定期关注库的更新，及时升级以获取新功能和bug修复。

5. 考虑封装：将库的使用封装在自己的类中，以便在需要时更换库。

// 封装第三方库的使用
public class GraphUtils {
    private static final Graph<String, DefaultEdge> graph = new DefaultDirectedGraph<>(DefaultEdge.class);
    
    public static void addVertex(String vertex) {
        graph.addVertex(vertex);
    }
    
    public static void addEdge(String source, String target) {
        graph.addEdge(source, target);
    }
    
    public static List<String> shortestPath(String source, String target) {
        DijkstraShortestPath<String, DefaultEdge> dijkstra = new DijkstraShortestPath<>(graph);
        return dijkstra.getPath(source, target).getVertexList();
    }
}

7.4 实际工程应用案例

7.4.1 搜索引擎

搜索引擎是算法在实际工程中的典型应用，涉及到文本处理、索引构建、相关性排序等多个方面。

搜索引擎的主要组件：

1. 爬虫：负责从互联网上收集文档。

2. 索引器：负责处理文档并构建索引。

3. 查询处理器：负责处理用户查询并返回相关结果。

4. 排序器：负责对搜索结果进行排序。

搜索引擎中使用的算法：

1. 倒排索引：将文档中的词映射到包含该词的文档列表。

public class InvertedIndex {
    private Map<String, List<Integer>> index = new HashMap<>();
    
    public void addDocument(int docId, String content) {
        String[] words = content.toLowerCase().split("\\s+");
        for (String word : words) {
            index.computeIfAbsent(word, k -> new ArrayList<>()).add(docId);
        }
    }
    
    public List<Integer> search(String word) {
        return index.getOrDefault(word.toLowerCase(), Collections.emptyList());
    }
}

2. TF-IDF算法：计算词在文档中的重要性。

public class TFIDF {
    private Map<String, Map<Integer, Integer>> termFrequency = new HashMap<>(); // 词频
    private Map<String, Integer> documentFrequency = new HashMap<>(); // 文档频率
    private int totalDocuments = 0; // 总文档数
    
    public void addDocument(int docId, String content) {
        totalDocuments++;
        String[] words = content.toLowerCase().split("\\s+");
        Set<String> uniqueWords = new HashSet<>(Arrays.asList(words));
        
        for (String word : words) {
            // 更新词频
            termFrequency.computeIfAbsent(word, k -> new HashMap<>())
                         .merge(docId, 1, Integer::sum);
        }
        
        for (String word : uniqueWords) {
            // 更新文档频率
            documentFrequency.merge(word, 1, Integer::sum);
        }
    }
    
    public double getTFIDF(String word, int docId) {
        word = word.toLowerCase();
        
        // 计算TF（词频）
        double tf = termFrequency.getOrDefault(word, Collections.emptyMap())
                                .getOrDefault(docId, 0);
        
        // 计算IDF（逆文档频率）
        double idf = Math.log((double) totalDocuments / 
                             (documentFrequency.getOrDefault(word, 0) + 1));
        
        return tf * idf;
    }
}

3. PageRank算法：计算网页的重要性。

public class PageRank {
    private Map<Integer, List<Integer>> graph = new HashMap<>(); // 网页链接关系
    private Map<Integer, Double> ranks = new HashMap<>(); // 网页排名
    
    public void addLink(int from, int to) {
        graph.computeIfAbsent(from, k -> new ArrayList<>()).add(to);
        if (!graph.containsKey(to)) {
            graph.put(to, new ArrayList<>());
        }
    }
    
    public void calculatePageRank(int iterations, double dampingFactor) {
        int n = graph.size();
        
        // 初始化排名
        for (int page : graph.keySet()) {
            ranks.put(page, 1.0 / n);
        }
        
        // 迭代计算PageRank
        for (int i = 0; i < iterations; i++) {
            Map<Integer, Double> newRanks = new HashMap<>();
            
            for (int page : graph.keySet()) {
                double sum = 0;
                for (int from : graph.keySet()) {
                    if (graph.get(from).contains(page)) {
                        sum += ranks.get(from) / graph.get(from).size();
                    }
                }
                
                double newRank = (1 - dampingFactor) / n + dampingFactor * sum;
                newRanks.put(page, newRank);
            }
            
            ranks = newRanks;
        }
    }
    
    public double getPageRank(int page) {
        return ranks.getOrDefault(page, 0.0);
    }
}