摘要：第二題羅馬數字轉整數難度簡單羅馬數字包含以下七種字符，，，，，和。字符數值例如，羅馬數字寫做，即為兩個并列的。通常情況下，羅馬數字中小的數字在大的數字的右邊。給定一個羅馬數字，將其轉換成整數。

TIME:2019-02-01
昨晚其實刷了題來著，但是沒有解出來，哭泣！
但是，今天重新寫了下，解出來咯~
所以今天的題量要增加咯~
我會加油的！

14. 最長公共前綴
難度：簡單

編寫一個函數來查找字符串數組中的最長公共前綴。
如果不存在公共前綴，返回空字符串 ""。

我的解題代碼如下：

class Solution:
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        length = len(strs)
        result = ""
        if length < 1:#如果空就不需要比較
            return result
        if length < 2:
            result = strs[0]
            return result
        #找到最短詞，避免越界
        l = len(strs[0])
        for i in strs[1:]:
            if l > len(i):
                l = len(i)#最小的循環次數
        for j in range(l):#循環二維 strs[a][j]
            for a in range(1,length):
                if strs[0][j] == strs[a][j]:#始終按第一個數組來做比對
                    if a == length - 1:#數組最后一位
                        result = result + strs[0][j]
                else:
                    return result
        return result            

因為是第二遍寫了，所以加了很多奇怪的注釋，但是思路清晰很多。
注釋還是很重要的~

我的主要思路是：

判斷數據量是否需要繼續循環判斷，數組長度為0和為1情況下結果不同。（為1的時候要返回數組本身....因為這個所以執行錯誤一次）

當需要循環判斷的時候，始終拿strs[0][j]就是數組第一項的每一個字母來做比較。

雙重循環來判斷，一層是判斷數組每個數，一層是判斷是否有項目超出字母數量。

總結：
雙重循環的效率還是比較低的，可以再考慮優化下，看下官方題解的方式。

13. 羅馬數字轉整數
難度：簡單

羅馬數字包含以下七種字符: I， V， X， L，C，D 和 M。
字符          數值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000
例如， 羅馬數字 2 寫做 II ，即為兩個并列的 1。12 寫做 XII ，即為 X + II 。 27 寫做  XXVII, 即為 XX + V + II 。
通常情況下，羅馬數字中小的數字在大的數字的右邊。但也存在特例，例如 4 不寫做 IIII，而是 IV。數字 1 在數字 5 的左邊，所表示的數等于大數 5 減小數 1 得到的數值 4 。同樣地，數字 9 表示為 IX。這個特殊的規則只適用于以下六種情況：
I 可以放在 V (5) 和 X (10) 的左邊，來表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左邊，來表示 40 和 90。 
C 可以放在 D (500) 和 M (1000) 的左邊，來表示 400 和 900。
給定一個羅馬數字，將其轉換成整數。輸入確保在 1 到 3999 的范圍內。

我的解題代碼如下：

class Solution:
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """
        result = 0
        dic = {"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000,"IV":4,"IX":9,"XL":40,"XC":90,"CD":400,"CM":900}
        if len(s) < 2:
            result = dic[s[0]]
            return result
        length = len(s)
        l = 0
        while l < length:
            point = s[l]
            if l + 1 == length:
                l = l + 1
            elif point == "I" and (s[l+1] == "V" or s[l+1] == "X"):
                point = point + s[l+1]
                l = l + 2
            elif point == "X" and (s[l+1] == "L" or s[l+1] == "C"):
                point = point + s[l+1]
                l = l + 2
            elif point == "C" and (s[l+1] == "D" or s[l+1] == "M"):
                point = point + s[l+1]
                l = l + 2
            else:
                l = l + 1
            result = result + dic[point]
        return result

執行效率上屬于偏慢的那一撥。
我的主要思路是：

用字典來映射字母對應的數字，包括需要特殊對待的朋友們

當遇到特殊字符的時候做特殊判斷

總結：

看了佳揚的思路后茅塞頓開，其實對于特殊字符可以簡單的判斷，他們對應數字的大小。這樣就簡化判斷為比大小，而不是多重對比字符內容。

字典用來做映射還是比較快，還是要多研究下它的用法。

21. 合并兩個有序鏈表
難度：簡單

將兩個有序鏈表合并為一個新的有序鏈表并返回。新鏈表是通過拼接給定的兩個鏈表的所有節點組成的。

我的解題代碼如下：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        r = ListNode(0)#游標
        result = r
        while 1:
            if l1 is None and l2 is None:
                return None
            elif l1 is None:
                return l2
            elif l2 is None:
                return l1
            elif l1.val < l2.val:
                r.val = l1.val
                l1 = l1.next
                if l1 is None:
                    r.next = l2
                    break
                r.next = ListNode(0)
                r = r.next
            else:
                r.val = l2.val
                l2 = l2.next
                if l2 is None:
                    r.next = l1
                    break
                r.next = ListNode(0)
                r = r.next
        return result            

算是比較大眾的一個效率。

我的主要思路是：

對比兩個鏈表節點的值，首先取小的值，才會有序。

判斷每次的l1和l2是否有next，當其中一個不存在的時候，就可以直接連接另一條鏈表了。

總結：

鏈表的結構第一次接觸。本題主要是熟悉了下對當前節點部署下一節點的方法。主要方式為將游標指向下一節點即可。每次都對節點進行操作。

鏈表的形式還有多種，包括對其的增刪改查，都需要再熟悉。