字符串包含问题

2024年6月8日 68次阅读

问题描述：

两个字符串S1和S2，假设S1长度大于等于S2长度，判断S2是否为S1的一个子集。
例如：S1=ABCDEFGHI, S2=ACEFG，由于S2中的每个元素都出现在S1中，说明S1包含S2.
若S2=ACEFGK, 由于K不在S1中，因此S1不包含S2。


设S1长度为m，S2长度为n
方法1:
Brute-Force 两个for loop，复杂度为O(m*n)

public static boolean compare(String[] s1, String[] s2){
	//s1:longString[]; s2:shortString[]
	int i,j;
	
	for(i = 0; i<s2.length;i++)
	{
		for(j = 0; j<s1.length; j++)
		{
			if(s2[i].compareTo(s1[j])==0)
				break;
		}
		//s2中的一个字符遍历了s1还是没找到，即没有执行break使得j达到了s1.length
		if (j==s1.length) return false;
	}
	return true;
}

方法2:
对s1和s2先排序，例如quicksort，则复杂度为O(mlgm)+O(nlgn)+O(m+n)
首先是quicksort部分

public static int partition(String[] array,int lo, int hi){
	String pivot = array[lo];
	int i = lo;
	int j = lo + 1;
	while(j<=hi){
		if(array[j].compareTo(pivot)<0){
			i++;
			exch(array,i,j);
		}
		j++;
	}
	exch(array,lo,i);
	return i;
}
private static void exch(String[] array, int i, int j){
	String temp = array[i];
	array[i] = array[j];
	array[j] = temp;
}
public static void quickSort(String[] array){
	quickSort(array, 0, array.length-1);
}
private static void quickSort(String array[], int lo, int hi){
	if(hi<=lo) return;
	int i = partition(array,lo,hi);
	quickSort(array,lo,i-1);
	quickSort(array,i+1,hi);
}

在执行下面的代码前，要对s1和s2用quicksort重新排好序。

public static boolean compare(String[] s1, String[] s2){
	int p1 = 0;
	int p2 = 0;
	while(p1<s1.length && p2<s2.length){
		while(s1[p1].compareTo(s2[p2])<0 && p1<s1.length-1) p1++;
		if(s1[p1].compareTo(s2[p2])!=0) break;
		p2++;
	}
	if(p2==s2.length) return true;
	else return false;
}



方法3
利用counting sort，可以将复杂度降低至线性。即O(m) + O(n) + O(m+n) = O(m+n)
计数排序的代码如下：

public static String[] countingSort(String[] array){
	int[] c = new int[26];
	for (int i = 0; i <26; i++)
	{
		c[i] = 0;
	}
	String[] b = new String[array.length];
	//初始化辅助数组
	for (int i = 0; i<array.length; i ++)
	{
		int ind = ((int)array[i].toCharArray()[0] - (int)("a".toCharArray())[0]);
		c[ind] = c[ind] + 1;
	}
	for (int i = 1; i<26; i++)
	{
		c[i] = c[i] + c[i-1];
	}
	for(int i = array.length-1; i>=0; i--)
	{
		int ind = ((int)array[i].toCharArray()[0] - (int)("a".toCharArray())[0]);
		b[c[ind]-1] = array[i];
		c[ind] = c[ind] - 1;
	}
	return b;
}

之后如同方法2，调用compare即可

方法4
用hashtable，将短的字符串的每个元素存储在一张hash table中，O(n)。然后对长字符串进行遍历，看hash(s1[i])映射到的slot是否已经有元素了。如果全部都有，则说明s1包含s2，如果有一个slot是空的，则说明s1不包含s2. 复杂度O(m)。所以总的复杂度是线性的。O(m+n)

public static boolean compare(String[] s1, String[] s2){
	int[] hash = new int[26];//初始化hash
	for(int i = 0; i<hash.length-1; i++)
	{
		hash[i] = 0;
	}
	int num = 0;
	for(int i = 0; i<s2.length;i++)//扫描短字符串
	{
		int ind = ((int)s2[i].toCharArray()[0] - (int)("a".toCharArray())[0]);
		if (hash[ind] == 0)
		{
			hash[ind] = 1;
			num++;
		}
	}

	for(int i = 0; i<s1.length; i++)//扫描长字符串
	{
		int ind = ((int)s1[i].toCharArray()[0] - (int)("a".toCharArray())[0]);
		if(hash[ind] == 1)
		{
			hash[ind] = 0;
			num--;//一个字符匹配到
			if(num==0) break;
		}
	}
	if(num==0) return true;
	else return false;
}
点赞