剑指leetcode—最长公共前缀

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

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

示例 1:
输入: [“flower”,“flow”,“flight”]
输出: “fl”

示例 2:
输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。

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

解法一：暴力解法
算法阐述：
依次取出字符串数组第一个字符串中的每一个字符，然后和其他字符串的字符按顺序进行比较，如果遇到不同的则返回之前的结果，否则继续下去。
java语言实现：

class Solution {
    public String longestCommonPrefix(String[] strs) {
                   String res="";
                    if(strs.length==0||strs==null)
                    return res.toString();
                    int i=0;
                    int j=0;
                    for(char c:strs[0].toCharArray())
                    {
                        for(j=1;j<strs.length;j++)
                        {
                            char temp[]=strs[j].toCharArray();
                            if(i<temp.length)
                            {
                                if(temp[i]!=c)
                                return res.toString();
                            }else
                            return res.toString();
                        }
                    res=res+c;
                    i++;
                    }
                    return  res.toString();
    }
}

太惨了，效率极其低下；
由于太久没用java了，导致写代码的时候磕磕碰碰。总结一下遇到的知识点

1. 数组长度是arr.length;
   字符串长度是s.length();
   集合长度是c.size();
2. 将字符串转化为字符数组，利用toCharArray（）；
3. java中的String就只是一个对象，如果需要转化为字符串，需要方法toString（）方法。
   但是这样的思想用C语言写效率挺高

char * longestCommonPrefix(char ** strs, int strsSize)
{
    int flag = 1;
    if(strsSize == 0)
    {
        return "";
    }
    for(int j = 0 ; j < strlen(strs[0]) && flag ; j++)
    {
        for(int i = 0 ; i < strsSize ; i++)       //i表示行，j表示列
        {
            if(strs[i][j] != strs[0][j])
            {
                strs[0][j] = '\0';
                flag = 0;
                break;
            }
        }
    }
    return strs[0];
}

方法二：
水平扫描法
算法分析：

java语言实现：

public String LCP(String [] strs)
{
if(strs.length==0) return "";
String prefix=strs[0];
for(int i=1;i<strs.length;i++)
while(strs[i].indexOf(prefix)!=0)
{
prefix=prefix.substring(0,prefix.length()-1);
if(prefix.isEmpty())  return "";
}
return prefix;
}

算法三：
垂直扫描
算法分析：
想象数组的末尾有一个非常短的字符串，使用上述方法依旧会进行 S​S​S​ 次比较。优化这类情况的一种方法就是水平扫描。我们从前往后枚举字符串的每一列，先比较每个字符串相同列上的字符（即不同字符串相同下标的字符）然后再进行对下一列的比较。
java语言实现：

public String longestCommonPrefix(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)
           // i == strs[j].length() || strs[j].charAt(i)顺序不可以倒过来，否则会发生下标越界的错误。
                return strs[0].substring(0, i);             
        }
    }
    return strs[0];
}

算法四：分治
算法分析
这个算法的思路来自于LCP操作的结合律。 我们可以发现：
LCP(S1…Sn)=LCP(LCP(S1…Sk),LCP(Sk+1…Sn))，其中 LCP(S1…Sn)是字符串 [S1…Sn] 的最长公共前缀，1<k<n。

java语言实现：

public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) return "";    
        return longestCommonPrefix(strs, 0 , strs.length - 1);
}
private String longestCommonPrefix(String[] strs, int l, int r) {
    if (l == r) {
        return strs[l];
    }
    else {
        int mid = (l + r)/2;
        String lcpLeft =   longestCommonPrefix(strs, l , mid);
        String lcpRight =  longestCommonPrefix(strs, mid + 1,r);
        return commonPrefix(lcpLeft, lcpRight);
   }
}
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);
}

算法五：二分查找法

java代码实现

public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0)
        return "";
    int minLen = Integer.MAX_VALUE;
    for (String str : strs)
        minLen = Math.min(minLen, str.length());
   //找出strs字符串数组中最短的字符串的长度
    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 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;
}

算法六
使用字典树查找最长公共前缀
待更新。
参考leetcode官方解析