最大子串匹配

最大子串匹配
/**
 * 
 */
package com.daniel.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.Map.Entry;

/**
 * @author Dianel Cao
 * @date   2007-4-10
 * @time   下午05:29:42
 *
 */
public class StringPattern {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		getMaxPattern("CABA","AABCABAC");
	}
	
	public static void getMaxPattern(String strA, String strB) {
		//只要有一个null,就返回null
		if (strA == null || strB == null || strA.trim().equals("") ||strB.trim().equals("")){
			System.out.println("");
			return;
		}
		int lengthA = strA.length();
		int lengthB = strB.length();
		String longStr = lengthA > lengthB ? strA : strB;
		String shortStr = lengthA > lengthB ? strB : strA;
		Map<Integer,List<String>> maxSubstrList = new TreeMap<Integer,List<String>>();
		for (int length = shortStr.length(); length > 0; length--) {
			for (int startIndex = 0; startIndex <= shortStr.length() - length; startIndex++) {
				String substr = shortStr.substring(startIndex, startIndex + length);
				if (longStr.indexOf(substr) > -1) {
					int len = substr.length();
					List<String> list;
					if (maxSubstrList.containsKey(len)){
						list = (List<String>)maxSubstrList.get(len);
					}else{
						list = new ArrayList<String>();
					}
					if (!list.contains(substr)){
						list.add(substr);
					}
					maxSubstrList.put(len, list);
				}
			}
		}
		// 找到最大匹配子串
		if (maxSubstrList.size() == 0){
			return;
		}else{
			Iterator<Entry<Integer,List<String>>> it = maxSubstrList.entrySet().iterator();
			Entry<Integer,List<String>> entry = it.next();
			while (it.hasNext()){
				entry = it.next();
			}
			List<String> maxList = entry.getValue();
			for(String str:maxList){
				System.out.println(str);
			}
		}
	}

}
 
### 字符子串匹配算法实验方法与示例 #### Brute Force (暴力匹配) 暴力匹配是一种基础且易于理解的方法,适用于各种编程语言。该方法通过逐一比较主串中的字符与模式串中的字符来完成匹配操作[^1]。 ```python def brute_force(text, pattern): n = len(text) m = len(pattern) for i in range(n - m + 1): j = 0 while(j < m and text[i + j] == pattern[j]): j += 1 if j == m: return i return -1 ``` 此函数接收两个参数:`text`表示待搜索的大字符串,`pattern`则是要查找的小字符串。当找到完全一致的情况时返回起始索引;如果没有发现任何匹配,则给出-1作为结果。 #### Boyer-Moore 算法 Boyer-Moore 是一种高效的字符串搜索算法,在某些情况下可以显著优于暴力匹配。它利用坏字符规则和好后缀规则跳过不可能发生匹配的部分,从而减少不必要的对比次数[^3]。 ```python def boyer_moore(text, pattern): def build_bad_char_shift(): shift = {} for k in range(len(pattern)): shift[pattern[k]] = max(1, len(pattern)-k-1) return shift bad_char = build_bad_char_shift() s = 0 while(s <= len(text)-len(pattern)): j = len(pattern)-1 while j >= 0 and pattern[j] == text[s+j]: j -= 1 if j < 0: return s else: char_shift = bad_char.get(text[s+len(pattern)-1], len(pattern)) s += max(char_shift, j+1) return -1 ``` 这段代码实现了完整的 BM 算法逻辑,并定义了一个辅助函数 `build_bad_char_shift()` 来构建坏字符表。最终输出的是首次出现的位置或者是未找到的结果 `-1`. #### 动态规划求解最长公共子串 对于特定需求下的优化问题,比如寻找两段文字之间的最大相同部分,可以通过动态规划的方式解决这个问题。这种方法的时间复杂度为 O(m * n)[^4]。 ```python def longest_common_substring(str1, str2): dp = [[0]*(len(str2)+1) for _ in range(len(str1)+1)] maxLength = 0 endIndex = -1 for i in range(1, len(str1)+1): for j in range(1, len(str2)+1): if str1[i-1]==str2[j-1]: dp[i][j]=dp[i-1][j-1]+1 if dp[i][j]>maxLength: maxLength=dp[i][j] endIndex=i startIndex=endIndex-maxLength return str1[startIndex:endIndex] print(longest_common_substring('abcdfgh', 'abedfha')) ``` 上述例子展示了如何计算并打印出给定两个字符串间的最长共同连续片段。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值