求两个集合中 最大公共连续子集

转载请注明出处 juejin.cn/post/702522…

如：求A和B的公共连续的字符串

A:"你的","嘻嘻嘻嘻","额的","你等待","我想休息","新消息","来咯哦哦"

B:"dd","lool","三生三世","嘻嘻嘻嘻","我想休息","新消息","呜呜呜呜","巴巴是是是","来咯哦哦"

如果有更简单的算法，或者需要改进的地方，欢迎大家留言

//求两个集合中 最大公共连续子集
public static List<DataIndexInfo> repeatIndexList = new ArrayList<>();
public static List<DataIndexInfo> repeatMaxLenIndexList = new ArrayList<>();

public static void commonList() {

    List<String> aStrList = new ArrayList<>();
    List<String> bStrList = new ArrayList<String>();
    aStrList.add("你好");
    aStrList.add("我的");
    aStrList.add("信息");
    aStrList.add("相匹配");
    aStrList.add("八十");
    aStrList.add("哦哦你能");
    aStrList.add("弄想");
    aStrList.add("哦哦你能");
    aStrList.add("门派品牌");
    aStrList.add("徐平跑");
    aStrList.add("八十");


    bStrList.add("信息");
    bStrList.add("你等待好");
    bStrList.add("相匹配");
    bStrList.add("八十");
    bStrList.add("哦哦你能");
    bStrList.add("门派品牌");
    bStrList.add("徐平跑");
    bStrList.add("相匹配");
    bStrList.add("小学生");


    //求出长度最小的集合
    List<String> maxLenList;
    List<String> minLenList;
    if (aStrList.size() >= bStrList.size()) {
        maxLenList = aStrList;
        minLenList = bStrList;
    } else {
        maxLenList = bStrList;
        minLenList = aStrList;
    }


    for (int m = 0; m < maxLenList.size(); m++) {//遍历最大长度集合
        System.err.println("m=" + m);
        Log.e(TAG, "m=" + m);
        for (int n = 0; n < minLenList.size(); n++) {//遍历最小长度集合
            //System.err.println(" n="+n);
            if (maxLenList.get(m).equals(minLenList.get(n))) { //如果有相同的元素
                System.err.println("   有相同元素了：m=" + m + "  n=" + n);
                Log.e(TAG, "   有相同元素了：m=" + m + "  n=" + n);
                int i, j;
                for (i = m, j = n; i < maxLenList.size() && j < minLenList.size(); i++, j++) {//两个集合分别往下遍历，看后一个元素是否相同
                    System.out.println("      i=" + i + " j=" + j);
                    Log.i(TAG, "      i=" + i + " j=" + j);
                    if (maxLenList.get(i).equals(minLenList.get(j))) {
                        Log.i(TAG, "      " + maxLenList.get(i) + " " + minLenList.get(j));
                        System.out.println("      " + maxLenList.get(i) + " " + minLenList.get(j));
                    } else {
                        System.out.println("      ----------");
                        Log.i(TAG, "      ----------");
                        break;
                    }
                }
                System.out.println("      不相同时：i=" + i + " j=" + j);
                Log.i(TAG, "      不相同时：i=" + i + " j=" + j);

                repeatIndexList.add(new DataIndexInfo(n, j));
            }
        }
    }
    int repeatLength = -1;
    for (DataIndexInfo dataIndexInfo : repeatIndexList) {
        if (dataIndexInfo.getLength() > repeatLength) {
            repeatLength = dataIndexInfo.getLength();
            repeatMaxLenIndexList.clear();
            repeatMaxLenIndexList.add(dataIndexInfo);
        } else if (dataIndexInfo.getLength() == repeatLength) {
            repeatMaxLenIndexList.add(dataIndexInfo);
        } else {
        }

    }

    for (DataIndexInfo dataIndexInfo : repeatMaxLenIndexList) {
        List<String> repeatList = minLenList.subList(dataIndexInfo.getFirstRepeatIndex(), dataIndexInfo.getNoRepeatIndex());//包含repeatIndex,不包含noRepeatIndex
        StringBuilder stringBuilder = new StringBuilder();
        for (String s : repeatList) {
            stringBuilder.append(s + " ");
        }
        System.out.println("结果：" + stringBuilder.toString());
        Log.i(TAG, "结果：" + stringBuilder.toString());
    }
}

DataIndexInfo.java

/**
 * @title:  TODO(用一句话描述该文件做什么)
 * @author: wangrr
 * @date: 2021年10月30日 下午8:50:00
 */
public class DataIndexInfo {
   private int firstRepeatIndex = -1;
   private int noRepeatIndex = -1;
   public DataIndexInfo() {
      
      // TODO Auto-generated constructor stub
   }
   
   public DataIndexInfo(int firstRepeatIndex, int noRepeatIndex) {
      super();
      this.firstRepeatIndex = firstRepeatIndex;
      this.noRepeatIndex = noRepeatIndex;
   }

   public int getFirstRepeatIndex() {
      return firstRepeatIndex;
   }
   public void setFirstRepeatIndex(int firstRepeatIndex) {
      this.firstRepeatIndex = firstRepeatIndex;
   }
   public int getNoRepeatIndex() {
      return noRepeatIndex;
   }
   public void setNoRepeatIndex(int noRepeatIndex) {
      this.noRepeatIndex = noRepeatIndex;
   }
   public int getLength() {
      return noRepeatIndex - firstRepeatIndex;
   }
}

参考

从两个字符串中找出最大公共子字符串

HashMap 中7种遍历方式的性能分析