Comment l'algorithme de Levenshtein peut-il être utilisé pour calculer la distance d'édition et déterminer la similarité entre deux chaînes en Java ?

Comparaison de chaînes de similarité en Java

Lors de la comparaison de plusieurs chaînes pour identifier les plus similaires, il est essentiel d'exploiter des techniques et des algorithmes appropriés. Cet article se penche sur une approche largement utilisée connue sous le nom de « distance d'édition » pour calculer la similarité entre deux chaînes.

Calcul de la distance d'édition à l'aide de l'algorithme de Levenshtein

Calcul de l'édition distance implique de déterminer le nombre minimum d'insertions, de suppressions et de substitutions de caractères requis pour transformer une chaîne en une autre. L'algorithme de Levenshtein est une approche classique pour calculer la distance d'édition, souvent intégrée aux bibliothèques de programmation. Pour calculer à l'aide de l'algorithme de Levenshtein :

// Levenshtein's Edit Distance Function
public static int editDistance(String s1, String s2) {
    // Convert to lower case for case-insensitive comparison
    s1 = s1.toLowerCase();
    s2 = s2.toLowerCase();

    int[][] matrix = new int[s2.length() + 1][s1.length() + 1];

    // Initialize first column to cost of insertion
    for (int i = 0; i <= s1.length(); i++) {
        matrix[0][i] = i;
    }

    // Initialize first row to cost of deletion
    for (int j = 0; j <= s2.length(); j++) {
        matrix[j][0] = j;
    }

    // Populate the matrix
    for (int j = 1; j <= s2.length(); j++) {
        for (int i = 1; i <= s1.length(); i++) {
            int cost = s1.charAt(i - 1) == s2.charAt(j - 1) ? 0 : 1;
            int min = Math.min(matrix[j - 1][i] + 1, // Deletion
                    Math.min(matrix[j][i - 1] + 1, // Insertion
                            matrix[j - 1][i - 1] + cost)); // Substitution
            matrix[j][i] = min;
        }
    }

    return matrix[s2.length()][s1.length()];
}

Indice de similarité normalisé

Une fois la distance d'édition calculée, l'indice de similarité peut être calculé en le normalisant à la longueur de la chaîne la plus longue :

// Similarity Index Function
public static double similarityIndex(String s1, String s2) {
    int distance = editDistance(s1, s2);
    String longer = s1.length() > s2.length() ? s1 : s2;
    double similarity = 1.0 - (distance / (double) longer.length());
    return similarity;
}

Exemple d'utilisation :

Pour utiliser ces méthodes, vous pouvez les appliquer comme suit :

String str1 = "The quick fox jumped";
String str2 = "The fox";
double similarity = similarityIndex(str1, str2);
System.out.println("Similarity Index: " + similarity);

Sortie :

Similarity Index: 0.70

Cet exemple démontre un indice de similarité de 0,7 entre « Le renard rapide a sauté » et « Le renard ».

Dans l'ensemble, les techniques décrites dans cet article fournit un moyen robuste de quantifier la similarité des chaînes, permettant une comparaison efficace et efficiente de plusieurs chaînes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!