【leetcode 最长公共前缀】

官方题解

解法一: 横向比较

遍历strs，两两进行求公共前缀，一旦前缀为空串，直接返回，遍历完，返回结果。

class Solution {
    public String longestCommonPrefix(String[] strs) {

        if (strs.length == 0 || strs == null) {
            return "";
        }

        String prefix = strs[0];

        for (int i = 1; i < strs.length; i++) {
            prefix = longestCommonPrefix(prefix,strs[i]);
            if (prefix.length() == 0) {
                break;
            }
        }
        return prefix;
    }

    /**
     * 获取两个字符串的最大公共前缀
     *
     * @param prefix
     * @param str
     * @return
     */
    public String longestCommonPrefix(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);
    }
}

解法二：纵向比较

初始化前缀为第一个字符串strs[0]，依次和其他字符串比较i位，如果不相等或者长度大于其他字符串，则返回第一个字符串的[0,i-1]字串，反之依次比较，直到结束，返回str[0]即可。

class Solution {
    public String longestCommonPrefix(String[] strs) {

        if (strs.length == 0 || strs == null) {
            return "";
        }

        String str = strs[0];
        // 纵向最大比较次数
        int length = str.length();
        // strs元素个数
        int count = strs.length;

        for (int i = 0; i < length; i++) {
            // 纵向比较的字符
            char ch = str.charAt(i);
            // 依次比较每个字符串
            for (int j = 0; j < count; j++) {
                // i == strs[j].length() 避免前面的字符与后面的长，导致越界
                // strs[j].charAt(i) != ch字符不相等，则之前的为前缀
                if (i == strs[j].length() || strs[j].charAt(i) != ch) {
                    return str.substring(0, i);
                }
            }
        }
        return str;
    }
}

下面当时自己写的思路，效率较低。

class Solution {
    public String longestCommonPrefix(String[] strs) {

        // 如果strs为空或str为空字符串，之间返回空字符串
        if (strs.length == 0 || strs == null) {
            return "";
        // 如果只有一个字符串，那么他就是前缀
        } else if (strs.length == 1) {
            return strs[0];
        }

        // >=2 个以上字符串，按照长短，字典顺序排序
        Arrays.sort(strs, (a, b) -> {
            if (a.length() != b.length()) {
                return a.length() - b.length();
            } else {
                return a.compareTo(b);
            }
        });

        // 初始化前缀为最短的
        String prefix = strs[0];

        // 遍历每一个字符串，如果以当前前缀开头，则遍历下一个，反之，
        // 就将前缀依次去除一位，再进行判断，直到匹配，然后进行下一
        // 个字符串，如果直到前缀为空串了，依然没有以它开头，则直接
        // 跳出循环，此时说明无公共前缀，最后返回前缀。
        for (int i = 1; i < strs.length; i++) {
            while (prefix.length() != 0) {
                if (!strs[i].startsWith(prefix)) {
                    // 前缀依次去除一位
                    prefix = prefix.substring(0,prefix.length()-1);
                } else {
                    // 前缀匹配成功，进行下一个字符串进行匹配
                    break;
                }
                if (prefix.length() == 0) {
                    return "";
                }
            }
        }
        return prefix;
    }
}