除了遞迴演算法，要如何最佳化實現檔案搜尋功能

威哥爱编程發表於2024-09-24

大家好，我是 V 哥，今天的文章來聊一聊 Java實現檔案搜尋功能，並且比較遞迴演算法、迭代方式和Memoization技術的優缺點。

以下是一個使用 Java 實現的檔案搜尋功能，它會在指定目錄及其子目錄中搜尋包含特定關鍵字的檔案。此實現使用遞迴方式遍歷目錄，並可以使用檔名或內容搜尋檔案。

使用遞迴搜尋檔案

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class FileSearcher {

    // 在指定目錄中搜尋包含關鍵字的檔案
    public static void searchFiles(File directory, String keyword) {
        // 獲取目錄下的所有檔案和子目錄
        File[] files = directory.listFiles();

        if (files == null) {
            System.out.println("目錄不存在或無法讀取：" + directory.getAbsolutePath());
            return;
        }

        // 遍歷檔案和子目錄
        for (File file : files) {
            if (file.isDirectory()) {
                // 如果是目錄，遞迴搜尋
                searchFiles(file, keyword);
            } else {
                // 如果是檔案，檢查檔名或檔案內容是否包含關鍵字
                if (file.getName().contains(keyword)) {
                    System.out.println("找到匹配檔案（檔名）： " + file.getAbsolutePath());
                } else if (containsKeyword(file, keyword)) {
                    System.out.println("找到匹配檔案（檔案內容）： " + file.getAbsolutePath());
                }
            }
        }
    }

    // 檢查檔案內容是否包含關鍵字
    private static boolean containsKeyword(File file, String keyword) {
        try (Scanner scanner = new Scanner(file)) {
            // 逐行讀取檔案內容並檢查是否包含關鍵字
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                if (line.contains(keyword)) {
                    return true;
                }
            }
        } catch (FileNotFoundException e) {
            System.out.println("無法讀取檔案：" + file.getAbsolutePath());
        }
        return false;
    }

    public static void main(String[] args) {
        // 指定搜尋的目錄和關鍵字
        String directoryPath = "C:/java"; // 替換為實際目錄路徑
        String keyword = "vg"; // 替換為實際關鍵字

        // 建立檔案物件表示目錄
        File directory = new File(directoryPath);

        // 開始搜尋
        searchFiles(directory, keyword);
    }
}

關鍵方法說明一下

searchFiles 方法：這是遞迴搜尋檔案的主方法。它遍歷給定目錄中的所有檔案和子目錄。如果發現某個檔名或檔案內容包含指定關鍵字，則輸出檔案路徑。
containsKeyword 方法：檢查檔案內容是否包含關鍵字。它逐行讀取檔案內容，以查詢是否有包含關鍵字的行。
main 方法：在主方法中，指定要搜尋的目錄路徑和關鍵字，然後呼叫 searchFiles 方法開始搜尋。

使用說明

修改 directoryPath 和 keyword 變數，指定你要搜尋的目錄路徑和關鍵字。
執行程式碼後，它將在指定目錄及其子目錄中搜尋檔案，並輸出匹配的檔案路徑。

注意嘍

該實現使用遞迴搜尋目錄，適用於層次較淺的檔案目錄。對於非常深的目錄結構，可以考慮使用迭代方式。
containsKeyword 方法在搜尋檔案內容時使用 Scanner 逐行讀取，這種方式適用於文字檔案。對於非文字檔案（如二進位制檔案），需要不同的處理方式。

問題來了，如果檔案層次非常深的目錄結構，需要怎麼最佳化？

對於非常深的目錄結構，使用遞迴搜尋檔案可能會導致棧溢位問題，因為每次遞迴呼叫都會消耗棧空間。要最佳化這種情況下的檔案搜尋，可以使用迭代的方式來替代遞迴，從而避免棧溢位風險。迭代方式通常使用一個棧或佇列來模擬遞迴的過程，這樣可以處理任意深度的目錄結構。

以下是最佳化後的 Java 檔案搜尋實現，使用迭代方式遍歷深層次的目錄結構：

使用迭代方式搜尋檔案

import java.io.File;
import java.io.FileNotFoundException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class FileSearcherIterative {

    // 使用迭代方式搜尋包含關鍵字的檔案
    public static void searchFiles(File rootDirectory, String keyword) {
        // 使用佇列來進行廣度優先搜尋
        Queue<File> queue = new LinkedList<>();
        queue.add(rootDirectory);

        while (!queue.isEmpty()) {
            // 取出佇列頭部的檔案/目錄
            File current = queue.poll();

            // 如果是目錄，新增子檔案和子目錄到佇列中
            if (current.isDirectory()) {
                File[] files = current.listFiles();

                // 如果目錄無法讀取，跳過
                if (files == null) {
                    System.out.println("無法讀取目錄：" + current.getAbsolutePath());
                    continue;
                }

                for (File file : files) {
                    queue.add(file);
                }
            } else {
                // 如果是檔案，檢查檔名或檔案內容是否包含關鍵字
                if (current.getName().contains(keyword)) {
                    System.out.println("找到匹配檔案（檔名）： " + current.getAbsolutePath());
                } else if (containsKeyword(current, keyword)) {
                    System.out.println("找到匹配檔案（檔案內容）： " + current.getAbsolutePath());
                }
            }
        }
    }

    // 檢查檔案內容是否包含關鍵字
    private static boolean containsKeyword(File file, String keyword) {
        try (Scanner scanner = new Scanner(file)) {
            // 逐行讀取檔案內容並檢查是否包含關鍵字
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                if (line.contains(keyword)) {
                    return true;
                }
            }
        } catch (FileNotFoundException e) {
            System.out.println("無法讀取檔案：" + file.getAbsolutePath());
        }
        return false;
    }

    public static void main(String[] args) {
        // 指定搜尋的目錄和關鍵字
        String directoryPath = "C:/java"; // 替換為實際目錄路徑
        String keyword = "vg"; // 替換為實際關鍵字

        // 建立檔案物件表示目錄
        File rootDirectory = new File(directoryPath);

        // 開始搜尋
        searchFiles(rootDirectory, keyword);
    }
}

程式碼說明

使用佇列實現廣度優先搜尋（BFS）：
- 在這裡，我們使用 Queue 來實現廣度優先搜尋（BFS），也可以使用 Stack 實現深度優先搜尋（DFS）。BFS 更加適合處理檔案目錄，因為它可以在處理一個目錄前先將其所有子檔案/子目錄新增到佇列中，從而降低棧深度。
迭代遍歷目錄：
- 每次從佇列中取出一個檔案或目錄，如果是目錄則將其子檔案和子目錄新增到佇列中，如果是檔案則檢查其是否包含關鍵字。
處理不可讀目錄：
- 在嘗試讀取目錄時，可能遇到無法讀取的情況（例如許可權問題），這裡使用 if (files == null) 進行檢查並跳過不可讀的目錄。

最佳化要點

避免棧溢位：使用迭代方式而不是遞迴，避免遞迴呼叫帶來的棧溢位風險。
適應任意深度的目錄結構：無論目錄層次多深，都可以正常工作，不受遞迴深度限制。
廣度優先或深度優先搜尋：可以根據需求使用 Queue（BFS）或 Stack（DFS）。BFS 更適合較寬的目錄結構，而 DFS 可以更快找到較深層次的檔案。

注意一下

在非常深的目錄或含有大量檔案的情況下，搜尋操作可能會很耗時。可以考慮增加其他最佳化，如多執行緒處理。
containsKeyword 方法適用於文字檔案，對於二進位制檔案需調整邏輯以防止誤匹配。

來，我們繼續最佳化。

如果檔案或目錄中存在符號連結（軟連結）或迴圈引用的檔案系統，會導致重複訪問相同檔案或目錄的情況，那要怎麼辦呢？

Memoization技術閃亮登場

Memoization 技術介紹

Memoization 是一種用於最佳化遞迴演算法的技術，它透過快取函式的中間結果來避免重複計算，從而提高效能。這個技術在計算具有重疊子問題（overlapping subproblems）的遞迴演算法時非常有用，如斐波那契數列、揹包問題、動態規劃等。

Memoization 的工作原理

快取中間結果：每次函式呼叫時，將結果儲存在一個資料結構（如雜湊表、陣列或字典）中，以後如果函式再次被呼叫，且引數相同，則直接從快取中返回結果，而不再進行重複計算。
減少時間複雜度：透過儲存中間結果，Memoization 將遞迴演算法的時間複雜度從指數級降低到多項式級。

使用 Memoization 技術最佳化深層次遞迴演算法

以下是如何使用 Memoization 技術來最佳化 Java 中的深層次遞迴演算法的示例。這裡以斐波那契數列為例，首先展示一個未最佳化的遞迴實現，然後透過 Memoization 進行最佳化。

1. 未最佳化的遞迴演算法

public class FibonacciRecursive {
    // 未使用 Memoization 的遞迴斐波那契演算法
    public static int fib(int n) {
        if (n <= 2) {
            return 1;
        }
        return fib(n - 1) + fib(n - 2);
    }

    public static void main(String[] args) {
        int n = 40; // 比較大的 n 會導致大量重複計算
        System.out.println("Fibonacci of " + n + " is: " + fib(n)); // 非常慢
    }
}

這種實現的時間複雜度是 O(2^n)，因為它會重複計算相同的子問題，特別是當 n 很大時，效率非常低。

2. 使用 Memoization 最佳化遞迴演算法

使用 Memoization，我們可以透過快取中間結果來避免重複計算。這裡使用一個陣列 memo 來儲存已經計算過的斐波那契值。

import java.util.HashMap;
import java.util.Map;

public class FibonacciMemoization {
    // 使用 Memoization 的遞迴斐波那契演算法
    private static Map<Integer, Integer> memo = new HashMap<>();

    public static int fib(int n) {
        // 檢查快取中是否已有結果
        if (memo.containsKey(n)) {
            return memo.get(n);
        }

        // 遞迴邊界條件
        if (n <= 2) {
            return 1;
        }

        // 計算結果並快取
        int result = fib(n - 1) + fib(n - 2);
        memo.put(n, result);

        return result;
    }

    public static void main(String[] args) {
        int n = 40;
        System.out.println("Fibonacci of " + n + " is: " + fib(n)); // 快速計算
    }
}

解釋一下

快取結果：memo 是一個 HashMap，用來儲存每個 n 對應的斐波那契數值。每次計算 fib(n) 時，先檢查 memo 中是否已經存在結果，如果存在，直接返回快取值。
減少重複計算：透過儲存中間結果，避免了對相同子問題的重複計算，將時間複雜度降低為 O(n)。
遞迴邊界：當 n <= 2 時，直接返回 1。

最佳化效果

透過使用 Memoization 技術，遞迴演算法從指數級時間複雜度 O(2^n) 降低到了線性時間複雜度 O(n)。這意味著，即使 n 非常大，計算時間也將大大縮短。

更通用的 Memoization 例子

Memoization 不僅可以應用於斐波那契數列，還可以應用於其他需要深層次遞迴的場景，例如：

動態規劃問題：如揹包問題、最長公共子序列、字串編輯距離等。
樹和圖演算法：如求樹的最大路徑、圖中的最短路徑。

注意事項

空間複雜度：Memoization 使用了額外的空間來儲存中間結果，可能導致空間複雜度增加，尤其在處理大量中間結果時需要注意。
適用場景：Memoization 適用於具有重疊子問題的遞迴問題，對於無重疊子問題的遞迴（如分治法）不適用。
多執行緒環境：在多執行緒環境中使用 Memoization 時需要考慮執行緒安全問題，可以使用執行緒安全的資料結構或同步機制。

Memoization 是一種簡單而有效的最佳化技術，透過快取中間結果可以極大地提升遞迴演算法的效能。

所以，我們透過Memoization技術來改造一下檔案搜尋功能。

Memoization 技術最佳化

對於深層次檔案搜尋功能，Memoization 技術可以用來最佳化重複訪問相同檔案或目錄的情況。特別是對於可能存在符號連結（軟連結）或迴圈引用的檔案系統，Memoization 可以防止多次搜尋相同的目錄或檔案，避免死迴圈和效能下降。

以下是使用 Memoization 最佳化檔案搜尋的示例，在搜尋過程中快取已經訪問過的目錄，防止重複搜尋：

使用 Memoization 最佳化檔案搜尋

import java.io.File;
import java.io.FileNotFoundException;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;

public class FileSearcherMemoization {
    // 使用 HashSet 來快取已經訪問過的目錄路徑
    private static Set<String> visitedPaths = new HashSet<>();

    // 使用迭代方式搜尋包含關鍵字的檔案，並利用 Memoization 防止重複訪問
    public static void searchFiles(File rootDirectory, String keyword) {
        // 使用佇列來進行廣度優先搜尋
        Queue<File> queue = new LinkedList<>();
        queue.add(rootDirectory);

        while (!queue.isEmpty()) {
            // 取出佇列頭部的檔案/目錄
            File current = queue.poll();

            // 獲取當前路徑
            String currentPath = current.getAbsolutePath();

            // 檢查是否已經訪問過該路徑
            if (visitedPaths.contains(currentPath)) {
                continue; // 如果已經訪問過，跳過，防止重複搜尋
            }

            // 將當前路徑加入到已訪問集合
            visitedPaths.add(currentPath);

            // 如果是目錄，新增子檔案和子目錄到佇列中
            if (current.isDirectory()) {
                File[] files = current.listFiles();

                // 如果目錄無法讀取，跳過
                if (files == null) {
                    System.out.println("無法讀取目錄：" + currentPath);
                    continue;
                }

                for (File file : files) {
                    queue.add(file);
                }
            } else {
                // 如果是檔案，檢查檔名或檔案內容是否包含關鍵字
                if (current.getName().contains(keyword)) {
                    System.out.println("找到匹配檔案（檔名）： " + current.getAbsolutePath());
                } else if (containsKeyword(current, keyword)) {
                    System.out.println("找到匹配檔案（檔案內容）： " + current.getAbsolutePath());
                }
            }
        }
    }

    // 檢查檔案內容是否包含關鍵字
    private static boolean containsKeyword(File file, String keyword) {
        try (Scanner scanner = new Scanner(file)) {
            // 逐行讀取檔案內容並檢查是否包含關鍵字
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                if (line.contains(keyword)) {
                    return true;
                }
            }
        } catch (FileNotFoundException e) {
            System.out.println("無法讀取檔案：" + file.getAbsolutePath());
        }
        return false;
    }

    public static void main(String[] args) {
        // 指定搜尋的目錄和關鍵字
        String directoryPath = "C:/ java"; // 替換為實際目錄路徑
        String keyword = "vg"; // 替換為實際關鍵字

        // 建立檔案物件表示目錄
        File rootDirectory = new File(directoryPath);

        // 開始搜尋
        searchFiles(rootDirectory, keyword);
    }
}

解釋

Memoization 資料結構：
- 使用 HashSet<String> 作為快取（visitedPaths），儲存已經訪問過的目錄的絕對路徑。HashSet 提供 O(1) 時間複雜度的查詢操作，確保檢查是否訪問過一個路徑的效率很高。
快取訪問的目錄：
- 在每次處理一個檔案或目錄時，先檢查其路徑是否在 visitedPaths 中。如果存在，說明已經訪問過，直接跳過，防止重複搜尋。
- 如果沒有訪問過，則將當前路徑加入到 visitedPaths 中，並繼續搜尋。
防止死迴圈：
- 透過快取路徑，可以防止在存在符號連結或迴圈引用時的無限遞迴或重複搜尋。特別是檔案系統中符號連結可能導致目錄迴圈引用，Memoization 技術可以有效地避免這種情況。
迭代搜尋：
- 繼續使用迭代方式進行廣度優先搜尋（BFS），適合深層次的目錄結構，防止因遞迴深度過深導致棧溢位。

最佳化效果

透過引入 Memoization，檔案搜尋功能可以：

避免重複訪問相同的目錄或檔案，從而提高效能，尤其在存在符號連結或迴圈結構的情況下。
防止由於重複搜尋導致的死迴圈，確保搜尋過程安全可靠。

注意事項

記憶體使用：
- 使用 Memoization 會增加記憶體使用，因為需要儲存已經訪問過的目錄路徑。在搜尋非常大的目錄樹時，注意記憶體消耗。
多執行緒環境：
- 如果需要並行化搜尋，可以使用執行緒安全的資料結構，如 ConcurrentHashMap 或 ConcurrentSkipListSet，確保在多執行緒環境中快取的訪問安全。

這個最佳化版本透過 Memoization 技術避免了重複搜尋和死迴圈，提高了搜尋效能和穩定性，特別適合在複雜的檔案系統中進行深層次搜尋。原創不易，感謝點贊支援。收藏起來備孕哦。

HHDESK檔案內文字搜尋功能
2023-02-13
實現延遲搜尋功能
2017-07-28
vue + axios 實現分頁引數傳遞，高階搜尋功能實現
2020-12-18
VueiOS
DjangoRestFramework 實現分頁功能與搜尋功能
2019-08-15
DjangoRESTFramework
HoudahSpot for Mac多功能檔案搜尋軟體
2021-01-14
Mac
HoudahSpot for Mac(多功能檔案搜尋軟體)
2021-12-08
Mac
Elasticsearch搜尋功能的實現（五）-- 實戰
2023-04-18
Elasticsearch
【演算法】遞迴實現全排列
2012-10-03
演算法遞迴
Sunday搜尋演算法實現
2019-02-25
演算法
BM搜尋演算法C實現
2019-02-25
演算法
多功能檔案搜尋：HoudahSpot 最新中文版
2023-04-13
檔案智慧搜尋
2024-04-09
如何遞迴實現陣列求和
2015-05-14
遞迴陣列
[轉載] PHP 基於字典樹演算法實現搜尋聯想功能
2020-06-17
PHP演算法
微信小程式簡易搜尋功能實現
2021-08-26
微信小程式
如何用Redis實現搜尋介面
2021-02-05
Redis
功能強大的檔案搜尋工具：ProFind mac版
2020-09-04
Mac
【演算法拾遺】二分查詢遞迴非遞迴實現
2014-06-24
演算法遞迴
遞迴演算法實踐---實現排列組合
2020-03-21
遞迴演算法
java檔案受限搜尋
2013-12-14
Java
【問題】檔案搜尋
2009-05-19
使用ElasticSearch6.0快速實現全文搜尋功能
2018-02-08
Elasticsearch
【Django】組合條件的搜尋功能實現
2018-04-12
Django
Html5實現的語音搜尋功能
2017-02-10
HTML
二十、快速排序演算法——JAVA實現(遞迴)
2019-01-15
排序演算法Java遞迴
實用的檔案搜尋工具：ProFind for Mac
2022-07-26
Mac
二十一、氣泡排序演算法——JAVA實現(遞迴與非遞迴)
2019-01-18
排序演算法Java遞迴
Python如何實現窮舉搜尋?
2021-04-14
Python
二分搜尋演算法的實現
2020-11-28
演算法
棧實現遞迴
2024-09-21
遞迴
lambda實現遞迴
2024-08-30
遞迴
win10如何搜尋檔案或資料夾 win10怎麼全盤搜尋檔案
2020-09-30
Win10
MacOS使用搜尋功能查詢隱藏檔案的方法
2020-05-29
Mac
Vue + element.ui table 分頁功能+搜尋功能的實現
2020-11-30
VueUI
如何使用 pdfgrep 從終端搜尋 PDF 檔案
2021-09-09
前端 Website 的 sitemap.xml 檔案和搜尋引擎最佳化
2023-05-12
前端WebXML
相見恨晚！開源的傻瓜搜尋引擎，幫你快速實現搜尋功能
2021-08-13
win10搜尋檔案在哪裡檢視搜尋檔案位置的方法
2021-01-25
Win10

除了遞迴演算法，要如何最佳化實現檔案搜尋功能

使用遞迴搜尋檔案

關鍵方法說明一下

使用說明

注意嘍

使用迭代方式搜尋檔案

程式碼說明

最佳化要點

注意一下

Memoization 技術介紹

Memoization 的工作原理

使用 Memoization 技術最佳化深層次遞迴演算法

1. 未最佳化的遞迴演算法

2. 使用 Memoization 最佳化遞迴演算法

解釋一下

最佳化效果

更通用的 Memoization 例子

注意事項

Memoization 技術最佳化

使用 Memoization 最佳化檔案搜尋

解釋

最佳化效果

注意事項

相關文章