多字符串相关题目

一般围绕两个字符串的算法题，都有如下思路：

（1）两个字符串同时遍历

（2）嵌套遍历

两个二进制字符串相加

class Solution {
    public String addBinary(String a, String b) {
        StringBuilder result = new StringBuilder();
        int i = a.length() - 1, j = b.length() - 1, carry = 0;
        while (i >= 0 || j >= 0) {
            int sum = carry;
            if (i >= 0) {
                sum += a.charAt(i--) - '0';
            }
            if (j >= 0) {
                sum += b.charAt(j--) -'0';
            }
            result.append(sum%2);
            carry = sum/2;
        }
        if (carry != 0)
            result.append(carry);
        return result.reverse().toString();
    }
}

求一个字符串在另一个字符串中，从左到右第一次出现的位置（实现java String的indexOf函数）

class Solution {
    public int strStr(String haystack, String needle) {
        if (needle.length() == 0) return 0;
        if (needle.length() > haystack.length()) return -1;
        for (int i = 0; i < haystack.length(); i++) {
            int firstPos = i;
            boolean find = false;
            for (int j = 0; j < needle.length(); j++) {
                //这块需要注意
                if (j + i >= haystack.length()) {
                    find = false;
                    break;
                } else {
                    if (needle.charAt(j) != haystack.charAt(j + i)) {
                        find = false;
                        break;
                    } else {
                       find = true; 
                    }
                } 
            }
            if (find) return firstPos;
        }
        return -1;
    }
}

找出一个字符串数组中，最长的相同前缀子字符串

这道题很有趣，也稍微有点难度。其实也是使用嵌套遍历，由于是获取前缀字符串，所以，我们可以把数组中的第一个字符串当作初始默认的“最长的相同前缀子字符串“，遍历数组，检测它是不是所有字符串的前缀，如果是就找到了，如果不是修正默认值。

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs.length == 0) return "";
        String common = strs[0];
        for (int i = common.length(); i > 0; i--) {
            common = common.substring(0, i);
            boolean find = true;
            for(int j = 0; j < strs.length; j++) {
                if(strs[j].indexOf(common) != 0) {
                    find = false;
                    break;
                }
            }
            if (find) {
                return common;
            }
        }
        return "";
    }
}