LeetCode-14-最长公共前缀

题目

来源：LeetCode.

编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。

示例 1：

输入：strs = ["flower","flow","flight"]
输出："fl"

示例 2：

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

提示：

• 1 <= strs.length <= 200
• 0 <= strs[i].length <= 200
• strs[i] 仅由小写英文字母组成

接下来看一下解题思路：

思路一：横向扫描：

    寻找字符串数组里最长公共子串；
    首先，找前两个字符串的公共子串；
    然后用该公共子串以后和后面的字符串比较，并更新公共子串；
    当遍历完所有的字符串以后，即可得到字符串数组中的最长公共前缀；
    如果在尚未遍历完所有的字符串时，最长公共前缀已经是空串，则最长公共前缀一定是空串，因此不需要继续遍历剩下的字符串，直接返回空串即可。

public static String longestCommonPrefix2(String[] strs) {
        if (strs == null || strs.length < 1) {
            return "";
        }
        String prefix = strs[0];
        for (int i = 1; i < strs.length; ++i) {
            prefix = longestCommon(prefix, strs[i]);
            if (prefix.length() == 0) {
                break;
            }
        }
        return prefix;
    }

    private static String longestCommon(String prefix, String str) {
        int length = Math.min(prefix.length(), str.length());
        int index = 0;
        while (index < length && prefix.charAt(index) == str.charAt(index)) {
            ++index;
        }
        return prefix.substring(0, index);
}

总结

    时间复杂度 $O(mn)$，其中 $m$ 是字符串数组中的字符串的平均长度，$n$ 是字符串的数量。最坏情况下，字符串数组中的每个字符串的每个字符都会被比较一次；
    空间复杂 $O(1)$；

思路二：纵向扫描：

    纵向扫描时，从前往后遍历所有字符串的每一列，比较相同列上的字符是否相同；
    如果相同则继续对下一列进行比较；
    如果不相同则当前列不再属于公共前缀，当前列之前的部分为最长公共前缀。

public static String longestCommonPrefix3(String[] strs) {
        if(strs == null || strs.length < 1) {
            return "";
        }

        int len = strs[0].length();
        int count = strs.length;
        for (int i = 0; i < len; ++i) {
            char c = strs[0].charAt(i);
            for (int j = 1; j < count; ++j) {
                if (i == strs[j].length() || c != strs[j].charAt(i)) {
                    return strs[0].substring(0, i);
                }
            }

        }
        return strs[0];
}

总结

    时间复杂度 $O(mn)$，其中 $m$ 是字符串数组中的字符串的平均长度，$n$ 是字符串的数量。最坏情况下，字符串数组中的每个字符串的每个字符都会被比较一次；
    空间复杂 $O(1)$；

思路三：分治法：

    可以将字符串数组从中间拆分；
    分别寻找前后两部的最长公共子串；
    然后再找最终的公共子串；

public static String longestCommonPrefix4(String[] strs) {
        if(strs == null || strs.length < 1) {
            return "";
        } else {
            return partition(strs, 0, strs.length - 1);
        }
    }

    private static String partition(String[] strs, int start, int end) {
        if (start == end) {
            return strs[start];
        } else {
            int mid = ((end - start) >> 1) + start;
            String leftString = partition(strs, start, mid);
            String rightString = partition(strs, mid + 1, end);
            return commonString(leftString, rightString);
        }
    }

    private static String commonString(String leftString, String rightString) {
        int minLen = Math.min(leftString.length(), rightString.length());
        for (int i = 0; i < minLen; ++i) {
            if (leftString.charAt(i) != rightString.charAt(i)) {
                return leftString.substring(0, i);
            }
        }
        return leftString.substring(0, minLen);
    }

总结

    时间复杂度 $O(mn)$，其中 $m$ 是字符串数组中的字符串的平均长度，$n$ 是字符串的数量。时间复杂度的递推式是$$T(n)=2\cdot T(\frac{n}{2})+O(m)$$，通过计算可得 $T(n)=O(mn)$；
    空间复杂：$O(m\log n)$，其中 $m$ 是字符串数组中的字符串的平均长度，$n$ 是字符串的数量。空间复杂度主要取决于递归调用的层数，层数最大为 $\log n$，每层需要 $m$ 的空间存储返回结果；

思路四：二分查找：

    最长公共前缀的长度不会超过字符串数组中的最短字符串的长度；
    用 $\text{minLength}$ 表示字符串数组中的最短字符串的长度，则可以在 $[0,\text{minLength}]$ 的范围内通过二分查找得到最长公共前缀的长度；
    每次取查找范围的中间值 $\text{mid}$，判断每个字符串的长度为 \textit{mid}mid 的前缀是否相同；
    如果相同则最长公共前缀的长度一定大于或等于 $\text{mid}$；
    如果不相同则最长公共前缀的长度一定小于 $\text{mid}$;
    通过上述方式将查找范围缩小一半，直到得到最长公共前缀的长度;

public static String longestCommonPrefix(String[] strs) {
        if(strs == null || strs.length < 1) {
            return "";
        }
        int minLen = Integer.MAX_VALUE;
        for (int i = 0; i < strs.length; ++i) {
            minLen = Math.min(minLen, strs[i].length());
        }
        int low = 0;
        int high = minLen;

        while (low < high) {
            int mid = ((high - low + 1) >> 1) + low;
            if (isCommon(strs, mid)) {
                low = mid;
            } else {
                high = mid - 1;
            }
        }
        return strs[0].substring(0, low);
}

    private static boolean isCommon(String[] strs, int length) {
        String str0 = strs[0].substring(0, length);
        int len = strs.length;
        for (int i = 1; i < len; ++i) {
            String str = strs[i];
            for (int j = 0; j < length; ++j) {
                if (str0.charAt(j) != str.charAt(j)) {
                    return false;
                }
            }
        }
        return true;
}

总结

    时间复杂度 $O(mnlogm)$，其中 $m$ 是字符串数组中的字符串的平均长度，$n$ 是字符串的数量。二分查找的迭代执行次数是 $O(\log m)$，每次迭代最多需要比较 $mn$ 个字符，因此总时间复杂度是 $O(mn\log m)$；
    空间复杂 $O(1)$；