前面写过一个[b]变位词算法[/b]的博文:
[url]http://zhuyufufu.iteye.com/blog/1988169[/url]
当时没有给出[b]变位词相似度算法[/b],现在补上一个简单相似度算法:
一.是变位词与彻底不是变位词都有明确的定义
二.其余情况处理如下:
1. 取两个单词长度较大的作为基准单词,如:abc与acff 则取acff作为基准单词。
2. 计算要增删多少个单词才能使长度小的单词达到长度大的那样,以 abc、acff为例:abc要删除b增加ff,则需要操作3个字母
3. 相似度公式 1 - 操作的字母数/基准单词长度 ,上例则为:1 - 3/4 = 0.25
算法的核心思想很简单: 取向长单词靠拢所需的操作次数来计算相似度
算法的缺陷:
举例说明 abc 与 cbc 在本算法中相似度为 1/3;正常人看应该为 2/3。
以后再改进吧!
package com.zas.anagram;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 变位词算法设计
* @author zas
*
*/
public class Anagram {
/**
* @param args
*/
public static void main(String[] args) {
System.out.println(Anagram.getSimilarity(null, null));
System.out.println(Anagram.getSimilarity("", ""));
System.out.println(Anagram.getSimilarity("", null));
System.out.println(Anagram.getSimilarity(null, ""));
System.out.println(Anagram.getSimilarity(null, "cba"));
System.out.println(Anagram.getSimilarity("cba", null));
System.out.println(Anagram.getSimilarity("abc", "cba"));
System.out.println(Anagram.getSimilarity("abc", "cbaa"));
System.out.println(Anagram.getSimilarity("abc", "cbc"));
System.out.println(Anagram.getSimilarity("", "cbc"));
System.out.println(Anagram.getSimilarity("abc", ""));
System.out.println(Anagram.getSimilarity("abc", "acff"));
}
/**
* 给出一个两个字符串互为变位词的相似度算法。
* 当他们为变位词的时候输出1.0;
* 当他们长度不同且没有相同字母时输出0;
* 其他情况给出一个规则输出一个0到1之间的浮点数。
* @param wordA
* @param wordB
* @return
*/
public static Float getSimilarity(String wordA, String wordB) {
/**
* 算法设计说明:
* 一.是变位词与彻底不是变位词都有明确的定义
* 二.其余情况处理如下:
* 1. 取两个单词长度较大的作为基准单词,如:abc与acff 则取acff作为基准单词。
* 2. 计算要增删多少个单词才能使长度小的单词达到长度大的那样,以 abc、acff为例:abc要删除b增加ff,则需要操作3个字母
* 3. 相似度公式 1 - 操作的字母数/基准单词长度 ,上例则为:1 - 3/4 = 0.25
*/
//是变位词,返回1
if(isAnagram(wordA, wordB)){
return 1f;
}
if(isNotAnagram(wordA, wordB)){
return 0f;
}
//基准单词
String word = wordA;
String otherWord = wordB;
if(wordA.length() < wordB.length()){
word = wordB;
otherWord = wordA;
}
Map<Character, Integer> mapWord = getWordMap(word);
Map<Character, Integer> mapForOtherWord = getWordMap(otherWord);
int count = getOperateCount(mapWord, mapForOtherWord);
float result = 1f - (float)count/word.length();
return result;
}
/**
* @param mapWord 基准单词 长单词
* @param mapForOtherWord 短单词
* @return
*/
private static int getOperateCount(Map<Character, Integer> mapWord,
Map<Character, Integer> mapForOtherWord) {
// 字母操作计数器
int count = 0;
Set<Character> key = mapWord.keySet();
for (Iterator<Character> it = key.iterator(); it.hasNext();) {
Character c = (Character) it.next();
Integer charCount = mapWord.get(c);
Integer charCountOther = mapForOtherWord.get(c);
// 短单词中没有字母时字母操作数加上字母数
if (null == charCountOther) {
count = count + charCount;
} else {
// 否则加上字母个数差值的绝对值
count = count + Math.abs(charCount - charCountOther);
}
}
Set<Character> keyOther = mapForOtherWord.keySet();
for (Iterator<Character> it = keyOther.iterator(); it.hasNext();) {
Character c = (Character) it.next();
Integer charCount = mapWord.get(c);
Integer charCountOther = mapForOtherWord.get(c);
// 短单词中没有字母时字母操作数加上字母数
if (null == charCount) {
count = count + charCountOther;
}
}
return count;
}
/**
* 判断是否不为变位词
* @param wordA
* @param wordB
* @return
*/
private static boolean isNotAnagram(String wordA, String wordB) {
//当为变位词时,返回false
if(isAnagram(wordA, wordB)){
return false;
}
//处理null
if(null == wordA && null != wordB){
return true;
}
if(null != wordA && null == wordB){
return true;
}
//当他们长度不同且没有相同字母时不是变位词
if(wordA.length() != wordB.length()){
for (int i = 0; i < wordA.length(); i++) {
if(wordB.contains(String.valueOf(wordA.charAt(i)))){
return false;
}
}
return true;
}
return false;
}
/**
* 判断两个单词是否互为变位词
* @param string
* @param string2
* @return true/false
*/
public static boolean isAnagram(String wordA, String wordB) {
//异常情况处理
if(null == wordA && null == wordB){
return true;
}
if(false == handleNull(wordA, wordB)){
return false;
}
//return isAnagramBySort(wordA, wordB);
return isAnagramByMap(wordA, wordB);
}
/**
* 处理异常情况 返回 true表示要继续处理 false表示不为变位词
* @param wordA
* @param wordB
* @return true/false
*/
private static boolean handleNull(String wordA, String wordB) {
//一个为空,另一个不为空不是变位词
if(null == wordA && null != wordB){
return false;
}
if(null == wordB && null != wordA){
return false;
}
//长度不同不为变位词
if(wordA.length() != wordB.length()){
return false;
}
return true;
}
/**
* 通过排序后比较其是否相同判断是否为变位词
* @param wordA
* @param wordB
* @return true/false
*/
private static boolean isAnagramBySort(String wordA, String wordB) {
//获取两个单词的小写复本
wordA = wordA.toLowerCase();
wordB = wordB.toLowerCase();
//对两个单词按字母大小顺序排序
wordA = sort(wordA);
wordB = sort(wordB);
if(wordA.equals(wordB)){
return true;
}
return false;
}
/**
* 按字母顺序排序字符串
* @param wordA
* @return
*/
private static String sort(String word) {
char[] charArray = word.toCharArray();
//排序基本为小数据量的,因此采用冒泡、选择、插入中的一种,这里选择选择排序
for (int i = 0; i < charArray.length; i++) {
//内层循环找到未排序的最小字母
int selectedIndex = i;
for (int j = 0; j < charArray.length; j++) {
if(charArray[selectedIndex] > charArray[j]){
selectedIndex = j;
}
}
if(selectedIndex != i){
char tempForSwap = charArray[selectedIndex];
charArray[selectedIndex] = charArray[i];
charArray[i] = tempForSwap;
}
}
return String.valueOf(charArray);
}
/**
* 通过 字母-字母个数 键值对来判断变位词
* @param wordA
* @param wordB
* @return true false;
*/
private static boolean isAnagramByMap(String wordA, String wordB) {
Map<Character, Integer> mapForWordA = getWordMap(wordA);
Map<Character, Integer> mapForWordB = getWordMap(wordB);
//字母的个数不同肯定不是变位词
if(mapForWordA.size() != mapForWordB.size()){
return false;
}
//迭代mapForWordA的字母 并在mapForWordB中获得对应的字母个数 若不同则不是变位词
Set<Character> key = mapForWordA.keySet();
for (Iterator<Character> it = key.iterator(); it.hasNext();) {
Character c = (Character) it.next();
Integer charCountA = mapForWordA.get(c);
Integer charCountB = mapForWordB.get(c);
if(charCountA != charCountB){
return false;
}
}
return true;
}
/**
* 获得一个字符串的字母-字母个数键值对
* @param wordA
* @return
*/
private static Map<Character, Integer> getWordMap(String word) {
Map<Character, Integer> map = new HashMap<Character, Integer>();
char[] charArray = word.toCharArray();
for (int i = 0; i < charArray.length; i++) {
Character c = charArray[i];
Integer charCount = map.get(c);
if(null == charCount){
charCount = 1;
}else{
charCount = charCount + 1;
}
map.put(c, charCount);
}
return map;
}
/**
* 从文件中获取词典列表
* @param path
* @return List<String>
*/
private static List<String> getWordsListFromFile(String path) {
List<String> wordList = new ArrayList<String>();
File file = new File(path);
FileReader fr = null;
BufferedReader br = null;
try{
fr = new FileReader(file);
br = new BufferedReader(fr);
String s;
while((s = br.readLine()) != null){
//去首尾空白
s = s.trim();
wordList.add(s);
}
}catch(FileNotFoundException e){
e.printStackTrace();
}catch (Exception e) {
e.printStackTrace();
}finally{
if(br != null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fr != null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return wordList;
}
/**
* 获取所有变位词集合列表
* @param wordList
* @return
*/
private static Map<String, List<String>> getAnagramCollectionMap(List<String> wordList) {
Map<String, List<String>> anagramCollectionMap = new HashMap<String, List<String>>();
while(wordList.size() > 0){
String word = wordList.remove(0);
//将单词存入变位词集合map中
//这里有两种算法,一种是把单词排序之后放入map这样就不需要遍历map
//另一种是遍历map的key判断它是否和该单词互为变位词
//这里采用第一种
String sortedWord = sort(new String(word).toLowerCase());
List<String> list = anagramCollectionMap.get(sortedWord);
if(list == null){
list = new ArrayList<String>();
}
list.add(word);
anagramCollectionMap.put(sortedWord, list);
}
return anagramCollectionMap;
}
/**
* 根据某种条件从map集中获取符合条件的列表 可以考虑实现一个说明模式
* 为了演示简便,给出获取特定大小变位词集合的实现
* @param anagramCollectionMap
* @return
*/
private static Map<String, List<String>> getAnagramCollectionMapByCondition(Map<String, List<String>> anagramCollectionMap, int size) {
Map<String, List<String>> resultMap = new HashMap<String, List<String>>();
Set<String> key = anagramCollectionMap.keySet();
for (Iterator<String> it = key.iterator(); it.hasNext();) {
String str = (String) it.next();
List<String> list= anagramCollectionMap.get(str);
if(list.size() == size){
resultMap.put(str, list);
}
}
return resultMap;
}
/**
* 向文件中输出变位词集合列表
* @param path
* @return
*/
private static void writeWordsListToFile(String path, Map<String, List<String>> anagramCollectionMap) {
File file = new File(path);
FileWriter fw = null;
BufferedWriter bw = null;
try{
fw = new FileWriter(file);
bw = new BufferedWriter(fw);
Set<String> key = anagramCollectionMap.keySet();
for (Iterator<String> it = key.iterator(); it.hasNext();) {
String str = (String) it.next();
List<String> list= anagramCollectionMap.get(str);
bw.write(str + list.toString());
bw.newLine();
}
}catch(FileNotFoundException e){
e.printStackTrace();
}catch (Exception e) {
e.printStackTrace();
}finally{
if(bw != null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fw != null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}