词语搜索算法思想 - 第四步 拼音组合

第三步已经完成了词语的拼音转换，但是我们要解决汉字多音词产生的多种组合问题。

这个问题，我们先看下快速解决方式：

public static void main(String[] args) {
//      String item = "娱乐八卦";
//      System.out.println(Arrays.toString(split(item)));
//      System.out.println(Arrays.toString(split("ylbg")));
//      System.out.println(Arrays.toString(split("yu,le,ba,gua")));
//      ArrayList<String[]> list = pinyin(item);
//      for (String[] arr : list) {
//          System.out.println(Arrays.toString(arr));
//      }
System.out.println(Arrays.toString(composite()));
}

/**
* 拼音组合
*/
public static String[] composite() {
String [] p1 = {"1", "2"};
String [] p2 = {"3"};
String [] p3 = {"4", "5"};
String [] p4 = {"6"};

ArrayList<String> list = new ArrayList<String>();
for (int i = 0; i < p1.length; i++)
for (int j = 0; j < p2.length; j++)
for (int m = 0; m < p3.length; m++)
for (int n = 0; n < p4.length; n++)
list.add(p1[i] + p2[j] + p3[m] + p4
);
return list.toArray(new String[list.size()]);
}

输出：

[1346, 1356, 2346, 2356]

很理想，但是我们需要的是传入“ArrayList<String[]> list = pinyin(item);”，而上面我们的composite()方法是写死的多重循环得到的结果。

递归是一个思路，但是我们换个角度思考，可能会有新发现，因为大部分递归都隐藏一个非递归替代方法。

首先，我们得到的数据是一个二维数组：

String [] p1 = {"1", "2"};
String [] p2 = {"3"};
String [] p3 = {"4", "5"};
String [] p4 = {"6"};

每个数组的循环无非就是数组下标的移动，多个数组递归循环，无非就是p1的下标先移动，然后p2下标移动、然后p3下标移动、然后p4下标移动：

package test;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 多维数组组合类
*/
public class CompositeUtil<T extends Object> {
private List<T[]> input;
private T t = null;

public CompositeUtil(List<T[]> input) {
this.input = input;
this.t = input.iterator().next()[0];
}

public List<T[]> getResult() {
List<T[]> result = new ArrayList<T[]>();
int[] counter = new int[this.input.size()]; // 下标数组
// 监视下标移动
System.out.println(Arrays.toString(counter));
do {
T[] aResult = getCurComposite(counter);
result.add(aResult);
} while (!incCounter(counter));
return result;
}

private boolean incCounter(int[] counter) {
boolean overflow = true;
for (int i = 0; i < counter.length; i++) {
T[] elementArray = (T[]) this.input.get(i);
if (counter[i] < elementArray.length - 1) {
counter[i]++;
overflow = false;
break; // 每次增加一个，后跳出循环
} else {
counter[i] = 0;
}
}
// 监视下标移动
System.out.println(Arrays.toString(counter));
return overflow;
}

@SuppressWarnings("unchecked")
private T[] getCurComposite(int[] counter) {
T[] result = (T[]) Array.newInstance(t.getClass(), counter.length);//
for (int i = 0; i < counter.length; i++) {
T[] elementArray = (T[]) this.input.get(i);
result[i] = elementArray[counter[i]];
}
return result;
}

public static void main(String[] args) {
String[] array1 = { "1", "7" };
String[] array2 = { "2", "3" };
String[] array3 = { "4", "5", "6"};
List<String[]> pinyinList = new ArrayList<String[]>();
pinyinList.add(array1);
pinyinList.add(array2);
pinyinList.add(array3);

CompositeUtil<String> t = new CompositeUtil<String>(pinyinList);
List<String[]> list = t.getResult();
System.out.println("===================================");
for (String[] strings : list) {
System.out.println(Arrays.toString(strings));
}
}
}

输出：

[0, 0, 0]
[1, 0, 0]
[0, 1, 0]
[1, 1, 0]
[0, 0, 1]
[1, 0, 1]
[0, 1, 1]
[1, 1, 1]
[0, 0, 2]
[1, 0, 2]
[0, 1, 2]
[1, 1, 2]
[0, 0, 0]
===================================
[1, 2, 4]
[7, 2, 4]
[1, 3, 4]
[7, 3, 4]
[1, 2, 5]
[7, 2, 5]
[1, 3, 5]
[7, 3, 5]
[1, 2, 6]
[7, 2, 6]
[1, 3, 6]
[7, 3, 6]

呵呵，运行正常。

现在我们把这个组合类使用到第三步，把多音词组合起来：

public static void main(String[] args) {
String item = "娱乐八卦";
//      System.out.println(Arrays.toString(split(item)));
//      System.out.println(Arrays.toString(split("ylbg")));
//      System.out.println(Arrays.toString(split("yu,le,ba,gua")));
ArrayList<String[]> list = pinyin(item);
for (String[] arr : list) {
System.out.println(Arrays.toString(arr));
}
CompositeUtil<String> t = new CompositeUtil<String>(list);
for (String[] strings : t.getResult()) {
System.out.println(Arrays.toString(strings));
}
//      System.out.println(Arrays.toString(composite()));
}

输出：

[yu]
[le, yue]
[ba]
[gua]
[yu, le, ba, gua]
[yu, yue, ba, gua]

组合的数组已经好了。