初级算法-最长公共前缀，初级算法-删除链表中的节点

第一题：最长公共前缀

1. 首先想到的是每次循环对数组比对一个字符，直到找到不匹配的返回就好，正好可以练习一下递归，也就是方法里只关心每次的index位字符的比对，最后调用自己继续比对。

    public String longestCommonPrefix(String[] strs) {
        return prefix(0, strs, new StringBuilder()).toString();
    }

    private StringBuilder prefix(int index, String[] strs, StringBuilder pre) {
        char s = 0;
        for (int i = 0; i < strs.length; i++) {
            if (strs[i].length() - index == 0) {
                return pre;
            }
            if (i == 0) {
                s = strs[i].charAt(index);
            } else if (s != strs[i].charAt(index)) {
                return pre;
            }
        }
        pre.append(s);
        return prefix(++index, strs, pre);
    }

2. 也可以每次从数组取出一个字符串，和之前比对的公共部分进行比对，直到比对完或者没有公共，这个也可以用递归。

	// 调用和上面的一样
    private StringBuilder prefix2(int index, String[] strs, StringBuilder pre) {
        if (index == 0) {
            pre = new StringBuilder(strs[index]);
            return prefix2(++index, strs, pre);
        }
        if (pre.length() == 0) {
            return pre;
        }
        if (index == strs.length) {
            return pre;
        }
        int length = Math.min(pre.length(), strs[index].length());
        for (int i = 0; i < length; i++) {
            if (pre.charAt(i) != strs[index].charAt(i)) {
                pre.replace(i, pre.length(), "");
                break;
            }
        }
        if (pre.length() > strs[index].length()) {
            pre.replace(strs[index].length(), pre.length(), "");
        }
        return prefix2(++index, strs, pre);
    }

3. 对应第二个写法，官方给出的是不递归的方法，学习一下

    public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        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);
    }

4. 对应第一个写法，官方也是给出的非递归写法。

    public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        int length = strs[0].length();
        int count = strs.length;
        // 这个for循环在第一个写法可以说就是那个递归
        for (int i = 0; i < length; i++) {
            char c = strs[0].charAt(i);
            for (int j = 1; j < count; j++) {
                if (i == strs[j].length() || strs[j].charAt(i) != c) {
                    return strs[0].substring(0, i);
                }
            }
        }
        return strs[0];
    }

至于分治法和二分法，感觉是可以练一练，不过要是真为了解这题，就算了。

第二题：删除链表中的节点

1. 这道题之所以放这，实在是这题太特娘的简单了，不值当新加一个文档，既然删的肯定不是最后一个，那就把后面那个节点赋值给要删的那个节点就好（别想着改上面那个，这是单向链表）。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}