LeetCode第十四题：最长公共前缀(java)_最长公共前缀java

题目:最长公共前缀

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

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

示例：

输入：strs = ["flower","flow","flight"]
输出："fl"
 
 
输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。

题目解读：

题目比较简单，对字符串进行操作。

我当时做时候第一想法是，循环比较每个元素的字符是否相等，直到不相等退出循环。

方法一：纵向扫描

以第一个元素为准，循环比较每个元素相同位置的字符是否相等。

不相等则退出循环，最长公共长缀为substring(0,i)。

注意：substring左闭右开，公共部分为0 到 i-1位置的元素。

其中 被比较的元素长度 小于 第一个元素长度  时 就会出现 取不到 第 i 个元素，此时被比较的字符串长度 等于 i 。也就是 strs[j].length() == i 这个条件。最长公共长缀 最长也只能是最短元素的长度。

这种思路比较容易想到。

//纵向扫描
    public static String longestCommonPrefix1(String[] strs) {
        if (strs.length == 0 || strs == null) {
            return "";
        }
        //第一个字符串的长度
        int len = strs[0].length();
        //数组里有几个元素
        int legth = strs.length;
        for (int i = 0; i < len; i++) {
            for (int j = 1; j < legth; j++) {
                //strs[j].length() == i 表示当前字符串的长度小于strs[0]的长度
                if (strs[j].length() == i || strs[j].charAt(i) != strs[0].charAt(i)) {
                    return strs[0].substring(0, i);
                }
            }
        }
        return strs[0];
    }

 官方的图很清晰明了，就不自己画了

方法二：横向扫描

 第一二组元素比较得出公共前缀，得到的公共前缀再依次和后面的元素比较，同时更新公共前缀。可以遍历完各个元素，得到的就是最长公共前缀。若未遍历完，公共前缀已经是空，则前面的元素已经没有公共前缀，也不需要后面的循环，直接退出循环即可。

//横向扫描
    public static String longestCommonPrefix2(String[] strs) {
        if (strs.length == 0 || strs == null) {
            return "";
        }
        int len = strs.length;
        //注意prefix 不能为空字符串
        String prefix = strs[0];
        for (int i = 0; i < len - 1; i++) {
            prefix = maxPrefix(prefix, strs[i + 1]);
            //公共最长前缀为0，无公共前缀
            if (prefix.length() == 0) {
                break;
            }
        }
        return prefix;
    }
 
    //最长前缀
    public static String maxPrefix(String str1, String str2) {
        int length = Math.min(str1.length(), str2.length());
        int index = 0;
 
        while (index < length && str1.charAt(index) == str2.charAt(index) ) {
            index++;
        }
//        for (int i = 0; i < length; i++) {
//            if (str1.charAt(i) == str2.charAt(i)) {
//                index++;
//            } else {
//                break;
//            }
//        }
        return str1.substring(0, index);
    }

 这种思路我没想到，但是不难理解。得到公共前缀，一次和每个元素比较，更新公共前缀。

方法三：分而治之

类似归并排序的思路

把整个数组分为左右两部分，左边的最长公共前缀 与 右边的最长公共前缀 的 最长公共前缀 就是 整个数组的最长公共前缀。左边的最长公共前缀可以再分为左右两部分，同上操作。直至分为一个元素，他自己就是最长公共长缀。再算它和另一部分的最长公共前缀，往上不断合并。

思想有点类似

    public static String longestCommonPrefix(String[] strs) {
        if (strs.length == 0 || strs == null) {
            return "";
        }
        return longestCommonPrefix(strs,0,strs.length-1);
    }
 
    public static String longestCommonPrefix(String[] strs, int start, int end) {
        if (start == end) {
            return strs[start];
        }
        //mid这么计算可以防止溢出，舍位
        int mid = (end - start) / 2 + start;
        //左边最长公共长缀
        String left=longestCommonPrefix3(strs,start,mid);
        //右边最长公共长缀
        String right=longestCommonPrefix3(strs,mid+1,end);
        //计算最长前缀
        return maxPrefix(left,right);
    }
 
    //最长前缀
    public static String maxPrefix(String str1, String str2) {
        int length = Math.min(str1.length(), str2.length());
        int index = 0;
 
        while (index < length && str1.charAt(index) == str2.charAt(index) ) {
            index++;
        }
        return str1.substring(0, index);
    }

 把问题不断分解成子问题，解决最小的子问题，在合并。最小子问题的循环结束条件要找到。感觉很像递归。

方法四：二分法

这种方法我没自己敲，就简单看了一下。用二分法，找到最长公共前缀的尾索引是多少。不断缩小所查找的范围。

    public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        int minLength = Integer.MAX_VALUE;
        for (String str : strs) {
            minLength = Math.min(minLength, str.length());
        }
        int low = 0, high = minLength;
        while (low < high) {
            int mid = (high - low + 1) / 2 + low;
            //是公共前缀则最长公共前缀的 尾索引 一定在mid之后
            if (isCommonPrefix(strs, mid)) {
                low = mid;
            } else {
               //不是公共前缀则最长公共前缀的 尾索引 一定在mid之前
                high = mid - 1;
            }
        }
        return strs[0].substring(0, low);
    }
    //判断是否是公共长缀
    public boolean isCommonPrefix(String[] strs, int length) {
        String str0 = strs[0].substring(0, length);
        int count = strs.length;
        for (int i = 1; i < count; i++) {
            String str = strs[i];
            for (int j = 0; j < length; j++) {
                if (str0.charAt(j) != str.charAt(j)) {
                    return false;
                }
            }
        }
        return true;
    }

总结： 

第一种思路很容易想到，但是没想到可以用分治和二分法解决。

复习一下各种查找算法和排序算法

int mid = (end - start) / 2 + start; 这么计算中间位置，可以有效防止溢出，很常用。