leetcode+字符串+最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1:

输入: ["flower","flow","flight"]
输出: "fl"
示例 2:

输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。
说明:

所有输入只包含小写字母 a-z 。

Leetcode中有一个网页说的很详细，介绍了水平扫描、分治、二分法

class Solution {
	//输入字符串[S1，S2，S3...Sn]
	/* 水平扫描
	 * 时间复杂度O(S),S是所有字符串中字符数量的总和。将S1与其他字符串[S2，S3...Sn]作比较
	 */
	public static String longestCommonPrefix0(String[] strs) {
			if(strs.length==0) return"";
			String prefix=strs[0];
			for (int i=0;i<strs.length;i++) 
				while(strs[i].indexOf(prefix)!=0) {
					prefix=prefix.substring(0,prefix.length()-1);
					if(prefix.isEmpty()) return "";
				}
			return prefix;
	}
	
	/* 水平扫描
	 * 时间复杂度O(S),将S1的每个字符与其他字符串对应位置的字符作比较
	 * 最坏情况下，输入数据为 n个长 m的相同字符串，算法进行S = m*n次比较。算法效率与算法一相同
	 * 最好的情况下，算法只需要进行 n*minLen次比较，其中minLen是数组中最短字符串的长度。
	 */
	public static String longestCommonPrefix1(String[] strs) {
		if(strs==null || strs.length==0) return "";
		for(int i=0;i<strs[0].length();i++) {
			char c=strs[0].charAt(i);
			for(int j=1;j<strs.length;j++)
			{
				if(i==strs[j].length()||strs[j].charAt(i)!=c)
					return strs[0].substring(0,i);
			}
		}
		return strs[0];
	}
		
	/* 分治
	 * 时间复杂度：O(S)，T(n)=2*T(n/2)*O(m)
	 * 空间复杂度：O(m*log(n))，递归过程使用栈空间消耗内存
	 */
	public static String longestCommonPrefix2(String[] strs) {
		if(strs==null||strs.length==0) return "";
		return longestCommonPrefix(strs,0,strs.length-1);
	}
	
	private static String longestCommonPrefix(String[] strs,int l,int r) {
		if(l==r)
			return strs[l];
		else {
			int mid=(l+r)/2;
			String lcpLeft=longestCommonPrefix(strs,1,mid);
			String lcpRight=longestCommonPrefix(strs,mid+1,r);
	    	System.out.println(1);
			return commonPrefix(lcpLeft,lcpRight);
		}
	}
	
	static String commonPrefix(String left,String right) {
		int min=Math.min(left.length(),right.length());
		for(int i=0;i<min;i++) {
			if(left.charAt(i)!=right.charAt(i))
				return left.substring(0,i);
		}
		return left.substring(0,min);
	}
	
	/* 二分查找法
	 * S[1...mid]不是所有串的公共前缀：对所有 j>i S0[1..j]不是公共前缀，丢弃后半查找区间
	 * S[1...mid]是所有串的公共前缀。 对所有 i < j S0[1..i]都是可行公共前缀，把前半个查找区间丢弃
	 * 时间复杂度 O(S*log(n))
	 */	
	public static String longestCommonPrefix3(String[] strs) {
		if(strs==null||strs.length==0) return "";
		int minLen=Integer.MAX_VALUE;
		for(String str:strs)
			minLen=Math.min(minLen, str.length());
		int low=1;
		int high=minLen;
		while(low<=high) {
			int middle=(low+high)/2;
			if(isCommonPrefix(strs,middle))
				low=middle+1;
			else
				high=middle-1;
		}
		return strs[0].substring(0,(low+high)/2);
	}
	private static boolean isCommonPrefix(String[] strs,int len) {
		String str1=strs[0].substring(0,len);
		for(int i=1;i<strs.length;i++)
			if(!strs[i].startsWith(str1))
				return false;
		return true;
	}
	
    public static void main(String[] args) {
    	String[] strs= {"leets","leetcode","leetc","leeds"};
    	System.out.println(longestCommonPrefix3(strs));
    }    
}

下面我们介绍两个常用函数

1. stringObject.indexOf(searchvalue,fromindex)：返回某个指定的字符串值在字符串中首次出现的位置

参数	描述
searchvalue	必需。规定需检索的字符串值。
fromindex	可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。

注释：indexOf() 方法对大小写敏感！

注释：如果要检索的字符串值没有出现，则该方法返回 -1。

2. stringObject.substring(start,stop)： 提取字符串中介于两个指定下标之间的字符

参数	描述
start	必需。一个非负的整数，规定要提取的子串的第一个字符在 stringObject 中的位置。
stop	可选。一个非负的整数，比要提取的子串的最后一个字符在 stringObject 中的位置多 1。 如果省略该参数，那么返回的子串会一直到字符串的结尾。