从两个顺序的字符串中寻找最大公共子串

本文介绍了一种用于寻找两个字符串之间的最长公共子串的算法实现。通过双层循环匹配字符,并逐步扩展相同部分来确定最长公共子串的起始索引及长度。


int GetMaxComSTR(const char *s, const char *t, int *length)
{
	int i = 0;
	int j = 0;
	int k = 0;
	int tmp_len = 0;
	int condition = 0;
	int index = 0;
	*length = -1;

	while(i<strlen(s))
	{
		j = 0;
		while(j<strlen(t))
		{
			if (s[i] == t[j])
			{
				k = 0;
				tmp_len = 0;
				condition = 1;
				while (condition == 1)
				{
					if (i+k<strlen(s) && j+k <strlen(t) && ——————————1——————————————)
					{
						tmp_len ++;
						k++;
					}
					else
					{
						—————————2———————————
					}
				}

				if (————3————)
				{
					index = i;
					*length = tmp_len;
				}
			}
			————————————4————————————
		}
		——————————5——————————
	}
	return index;
}

答案:

//从两个字符串中找最大字符串
int GetMaxComSTR(const char *s, const char *t, int *length)
{
	int i = 0;//字符串1索引
	int j = 0;//字符串2索引
	int k = 0;//记录的最大公共字符串的长度  X
	int tmp_len = 0;//查找过程中记录暂时的公共字符串长度
	int condition = 0;//是否具有公共字符串标识
	int index = 0;//第一个存储位置 最大存储位置
	*length = -1;

	while(i<strlen(s))//字符串1索引
	{
		j = 0;
		while(j<strlen(t))
		{
			if (s[i] == t[j])//这句精髓,可以避免进入循环后多次比较操作,加快效率
			{
				k = 0;
				tmp_len = 0;
				condition = 1;//相同置1
				while (condition == 1)
				{
					if (i+k<strlen(s) && j+k <strlen(t) && s[i+k] == t[j+k] /*k >= tmp_len*/)//1根据上面比较得到提示
					{
						tmp_len ++;
						k++;
					}
					else
					{
						condition = 0;//2  此处使用break可以少一次条件判断循环
						//break;
					}
				}

				if (tmp_len > *length)//3
				{
					index = i;
					*length = tmp_len;//这个提示3处条件
				}
			}
			j++; //不相等,j自增//4  循环结束,不必多说
		}
		i++;//内层循环结束//5
	}
	return index;
}

       面试总结:不要因为外界条件影响自己的思路,当你在很平坦的大路上行驶时,就算给你画一条很窄的路线,你也能够不偏不移的沿着路线通过,但是如果是同样窄或者更宽一点的桥,没有 围栏,你也会掉到水里。

<think> 根据用户的问题,用户想要了解如何获取两个字符串最大相同子串的实现方法。根据提供的引用内容,有两种不同的实现方法。 引用[1]中的方法返回一个字符串数组,因为可能存在多个相同长度的最大子串。该方法的主要步骤是: 1. 比较两个字符串的长度,确定较长字符串和较短字符串。 2. 使用两层循环遍历较短字符串的所有可能子串,从长度最长的子串开始(即从整个较短字符串开始,然后长度递减)。 3. 对于每一个长度的子串,从起始位置开始滑动窗口,检查较长字符串是否包含当前子串。 4. 一旦找到匹配的子串,就将其添加到StringBuilder中,并继续查找同一长度的其他子串(因为可能有多个相同长度的子串)。 5. 当找到至少一个子串后,跳出循环(因为是从最长子串开始找,所以找到的就是最大的相同子串),然后将收集到的子串分割成数组返回。 引用[2]中的方法返回一个字符串(即找到的第一个最大相同子串)。该方法步骤类似,但是一旦找到匹配的子串就立即返回,因此只返回一个子串(即使有多个相同长度的最大子串,也只返回第一个找到的)。 用户的问题没有明确要求返回多个还是单个,因此我们可以提供两种方法的解释。 ### 方法1:返回所有最大相同子串(引用[1]的实现) 这种方法会返回所有长度最大的相同子串(可能有多个)。代码实现如下: ```java public String[] getStr(String string1, String string2) { if (string1 != null && string2 != null) { StringBuilder stringBuilder = new StringBuilder(); String maxStr = string1.length() > string2.length() ? string1 : string2; String minStr = string1.length() > string2.length() ? string2 : string1; // 从长到短遍历子串(从整个minStr长度开始,逐渐减少长度) for (int i = 0; i < minStr.length(); i++) { // 从索引0开始,窗口大小为minStr.length()-i,滑动窗口 for (int j = 0, k = minStr.length() - i; k <= minStr.length(); j++, k++) { String sub = minStr.substring(j, k); if (maxStr.contains(sub)) { stringBuilder.append(sub).append(","); } } // 如果这一轮找到了,就跳出循环(因为这一轮的子串长度是当前最长的) if (stringBuilder.length() != 0) { break; } } // 将收集到的子串分割成数组返回 return stringBuilder.toString().split(","); } return null; } ``` ### 方法2:返回一个最大相同子串(引用[2]的实现) 这种方法返回找到的第一个最大相同子串(即使有多个相同长度的,也只返回第一个)。代码实现如下: ```java public static String getMaxSubString(String s1, String s2) { String max = (s1.length() > s2.length()) ? s1 : s2; String min = (max.equals(s1)) ? s2 : s1; for (int len = min.length(); len > 0; len--) { // 子串长度从大到小 for (int start = 0; start + len <= min.length(); start++) { // 起始位置从0开始滑动 String sub = min.substring(start, start + len); if (max.contains(sub)) { return sub; } } } return ""; // 没有找到返回空字符串 } ``` ### 两种方法的区别: - 方法1返回所有最大相同子串(可能有多个),而方法2只返回第一个找到的最大子串。 - 方法1使用StringBuilder收集所有匹配的子串,并在找到后立即跳出循环(因为是从最长开始找,所以当前长度就是最大长度)。 - 方法2一旦找到匹配的子串就返回,不再继续查找同一长度的其他子串,因此效率可能稍高(但只返回一个)。 ### 注意事项: 1. 两个方法都区分了较长字符串和较短字符串,因为通常从较短的字符串中取子串去较长的字符串中查找,这样效率更高。 2. 方法1中,由于在找到同一长度的多个子串后,我们使用逗号拼接,最后分割成数组,所以如果子串中本身包含逗号,可能会出错。可以考虑使用List来存储结果。 3. 两个方法都没有考虑子串为空的情况,但根据逻辑,当两个字符串没有相同子串时,方法1返回null(因为一开始的stringBuilder长度为0,不会进入break,循环结束后返回null),而方法2返回空字符串。 ### 改进建议: 对于方法1,我们可以使用List来避免逗号分割可能带来的问题: ```java public List<String> getAllMaxCommonSubstrings(String s1, String s2) { if (s1 == null || s2 == null) return null; String longer = s1.length() >= s2.length() ? s1 : s2; String shorter = s1.length() < s2.length() ? s1 : s2; List<String> result = new ArrayList<>(); int maxLen = 0; // 记录当前找到的最大子串的长度 for (int len = shorter.length(); len > 0; len--) { boolean found = false; for (int start = 0; start + len <= shorter.length(); start++) { String sub = shorter.substring(start, start+len); if (longer.contains(sub)) { // 如果当前子串长度大于之前记录的最大长度,清空列表并更新最大长度 if (sub.length() > maxLen) { result.clear(); maxLen = sub.length(); } result.add(sub); found = true; } } // 如果这一轮长度已经找到,就不需要再找更短的了(因为从大到小,所以找到的都是最大的) if (found) { break; } } return result; } ``` 这样改进后,可以避免使用逗号分割,并且能够处理子串中包含逗号的情况。同时,我们记录了最大长度,确保只收集最大长度的子串。 ### 总结: 用户可以根据需求选择: - 如果只需要一个最大相同子串,使用方法2。 - 如果需要所有最大相同子串,使用方法1的改进版(使用List)。 此外,请注意字符串为空的情况,以及性能问题(如果字符串很长,这种暴力方法可能效率较低,可以考虑使用动态规划等更高效的方法)。 §§相关问题§§ 1. 如何优化获取两个字符串最大相同子串的性能? 2. 除了暴力匹配,还有哪些算法可以解决这个问题? 3. 如何获取两个字符串的所有公共子串? 4. 在获取两个字符串最大相同子串时,如何处理多个最大相同子串的情况? </think> ### 获取两个字符串最大相同子串的实现方法 根据引用内容,获取两个字符串最大相同子串的核心思路是:**从较短的字符串中截取所有可能的子串,检查这些子串是否存在于较长的字符串中,并记录最长的匹配结果**。以下是两种典型实现方法: --- #### 方法1:返回多个最大相同子串(引用[1]的实现) ```java public String[] getMaxCommonSubstrings(String str1, String str2) { if (str1 == null || str2 == null) return null; // 确定较长和较短的字符串 String maxStr = str1.length() > str2.length() ? str1 : str2; String minStr = str1.length() > str2.length() ? str2 : str1; StringBuilder sb = new StringBuilder(); for (int len = minStr.length(); len > 0; len--) { // 子串长度从大到小 for (int start = 0; start + len <= minStr.length(); start++) { // 滑动窗口 String sub = minStr.substring(start, start + len); if (maxStr.contains(sub)) { sb.append(sub).append(","); // 记录所有相同子串 } } // 找到匹配则跳出(当前长度是最大长度) if (sb.length() > 0) break; } return sb.length() > 0 ? sb.toString().split(",") : new String[0]; } ``` **执行示例**: ```java String s1 = "abcwerthelloyuiodef"; String s2 = "cvhellobnhellom"; String[] result = getMaxCommonSubstrings(s1, s2); System.out.println(Arrays.toString(result)); // 输出: [hello, hello] (两个相同长度的最大子串) ``` **特点**: 1. 返回所有长度相等的最大子串(可能有多个) 2. 从最长可能子串开始遍历,找到即终止 3. 时间复杂度:$O(\min(m,n)^2 \times \max(m,n))$,其中 $m,n$ 为字符串长度 --- #### 方法2:返回单个最大相同子串(引用[2]的实现) ```java public static String getMaxSubString(String s1, String s2) { String max = s1.length() > s2.length() ? s1 : s2; String min = max.equals(s1) ? s2 : s1; for (int len = min.length(); len > 0; len--) { // 子串长度递减 for (int start = 0; start <= min.length() - len; start++) { String sub = min.substring(start, start + len); if (max.contains(sub)) { return sub; // 返回第一个找到的最大子串 } } } return ""; // 无相同子串时返回空 } ``` **执行示例**: ```java String s1 = "ab"; String s2 = "cvhellobnm"; System.out.println(getMaxSubString(s2, s1)); // 输出: "b" (第一个找到的最大子串) ``` **特点**: 1. 返回最先找到的最大子串(可能忽略其他等长子串) 2. 更早终止循环,效率略高 3. 适用于只需一个结果的场景 --- ### 关键实现逻辑 1. **确定长短字符串**: ```java String maxStr = str1.length() > str2.length() ? str1 : str2; String minStr = (maxStr == str1) ? str2 : str1; ``` 2. **子串遍历顺序**: - 外层循环:子串长度从 `minStr.length()` 递减到 1 - 内层循环:滑动窗口截取子串,例如 `"abc"` 在长度=2时: - `substring(0,2) → "ab"` - `substring(1,3) → "bc"` 3. **匹配检查**: ```java if (maxStr.contains(currentSubstring)) { // 记录或返回结果 } ``` 4. **终止条件**: - 方法1:当前长度找到匹配后立即终止外层循环 - 方法2:找到第一个匹配立即返回结果 --- ### 性能优化建议 1. **动态规划法**:使用DP表格存储匹配状态,时间复杂度优化至 $O(mn)$ 2. **后缀树法**:构建广义后缀树,时间复杂度 $O(m+n)$(适合大字符串) 3. **提前终止**:当剩余长度小于已找到的最大长度时终止循环 > 示例:动态规划实现片段 > ```java > int[][] dp = new int[m+1][n+1]; > int maxLen = 0; > for (int i=1; i<=m; i++) { > for (int j=1; j<=n; j++) { > if (str1.charAt(i-1) == str2.charAt(j-1)) { > dp[i][j] = dp[i-1][j-1] + 1; > maxLen = Math.max(maxLen, dp[i][j]); > } > } > } > ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值