leetcode刷题记录day010：14和38

14、难度简单：通过率40%

方法一：横向扫描：

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

substring() 方法返回字符串的子字符串。class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        //prefix是每两项的公共前缀
        String prefix = strs[0];
        int count = strs.length;
        //依次遍历字符串数组中的每一项
        for (int i = 1; i < count; i++) { 
            //获取当前两项的公共前缀
            prefix = longestCommonPrefix(prefix, strs[i]);
            if (prefix.length() == 0) {
                break;
            }
        }
        return prefix;
    }
    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);
    }
}

依次遍历字符串数组中的每个字符串，对于每个遍历到的字符串，更新最长公共前缀，当遍历完所有的字符串以后，即可得到字符串数组中的最长公共前缀。
假设共有a、b、c三个字符串，那么三者的最长公共前缀 = a、b的最长公共前缀形成的字符串和 c 的最长公共前缀。据此原理我们写出上述代码。

substring() 方法返回字符串的子字符串。
参数：beginIndex – 起始索引（包括）, 索引从 0 开始；endIndex – 结束索引（不包括）。

38、难度中等：

题意：输入的正整数 n 是根据题给规律进行的层数。
题给规律：从字符1开始，这时第一层。后一层是对前一层的描述。所以第二层是11，代表第一层出现了1个1。同理，第三层是对第二层的描述，内容为21，意为第二层出现了2个1。

递归法：

class Solution {
    public String countAndSay(int n) {
        if (n == 1) return "1";
        else {
            String lastStr = countAndSay(n - 1); // 1 2 1 1
            StringBuilder ans = new StringBuilder();
            int i = 0, j = 1, len = lastStr.length();
            while (j < len) {
                if (lastStr.charAt(i) != lastStr.charAt(j)) {
                    ans.append(j - i).append(lastStr.charAt(i));
                    i = j;
                }
                j++;
            }
            ans.append(j - i).append(lastStr.charAt(i));
            return ans.toString();
        }
    }
}

递归出口为n == 1时，返回"1"；
当n > 1时，我们只需要计算countAndSay(n - 1)中每个数字的个数：

对于计算字符串中每个数字出现的个数，使用双指针i, j，其中i表示当前字符，j则是计数指针，向后移动判断；
以求n = 5，lastStr = countAndSay(4) = "1211"为例，answer = “”，一开始让i = 0, j = 1，此时’1’ != ‘2’，
故answer += (j - i) + lastStr.charAt(i)，ans = “11”；然后让i = j（第二个不同字符起始位置），
（ j 是 i 后几位中直到与 i 指向的元素不同的指针，所以 j - i 就是i指向元素的出现次数）
然后j++往后移动；此时i = j = 1，j = j + 1 = 2，又’2’ != ‘1’，
所以answer += (j - i) + lastStr.charAt(i),ans = “1112”,重复i = j = 2， j = ++j = 3；此时’1’ = ‘1’；
故直接j = ++j = 4 == lastStr.length()，所以跳出循环，然后把最后一次的字符个数字符加上，即执行：
answer += (j - i) + lastStr.charAt(i),ans = “111221”，即countAndSay(5) = “111221”。

java中用于处理字符串常用的有三个类:

1、java.lang.String；2、java.lang.StringBuffer；3、java.lang.StrungBuilder
三者共同之处:都是final类,不允许被继承。
运行速度，或者说是执行速度，在这方面运行速度快慢为：StringBuilder > StringBuffer > String
String最慢的原因：String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。
线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的

String：适用于少量的字符串操作的情况
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况