【面試準備】leetcode解題思路01

一路走來,太累了,停下來歇歇吧,多休息一會,是爲了走更遠的路！

1. 兩數之和

此題考察的基本思路是通過map的方式減少一次循環遍歷，如果能夠理清楚就十分容易了。

注意：enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合爲一個索引序列，同時列出數據和數據下標，一般用在 for 循環當中。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        d={} # 聲明一個字典 字典的key使用value 
        for i,num in enumerate(nums):
            if target-num in d:
                return [d[target-num],i]
            d[num]=i # 記錄下標

2. 兩數相加

思路1：最初思路是將鏈表轉換爲兩個數值相加求解，但是存在越界的情況

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

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        n1 = 0
        n1 = l1.val
        c1=1
        while(l1.next!=None):
            l1 = l1.next
            n1 = n1+l1.val*10**c1
            c1 = c1+1
        n2 = 0
        n2 = l2.val
        c2=1
        while(l2.next!=None):
            l2 = l2.next
            n2 = n2+l2.val*10**c2
            c2 = c2+1
        ret = n1+n2
        retListNode = ListNode(0)
        
        print(ret)
        if ret==0:
            return retListNode
        val = ret%10
        ret = int(ret/10)
        retListNode.val=val
        retListNode.next=None

        curNode = retListNode
        while(int(ret/10)>0):
            val = ret%10
            newNode = ListNode(val)
            ret = int(ret/10)
            curNode.next=newNode
            curNode = newNode

        if(ret!=0):
            newNode = ListNode(ret)            
            curNode.next=newNode
            curNode = newNode

        return retListNode

思路2：合併鏈表每一個位置的值，然後鏈表內部進行計算

注意：

   1   在 Python 2.2  ：from __future__ import division
  
         " / "就表示 浮點數除法，返回浮點結果;" // "表示整數除法。

   2    Python 3以後  ：
        " / "就表示 浮點數除法，返回浮點結果;" // "表示整數除法。

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

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        # 如果有一個鏈表爲空，返回另外一個
        if l1 is None:
            return l2
        if l2 is None:
            return l1
        # tmp是暫存（temporal）
        tmp = ListNode(0)  # 引用ListNode類定義了一個鏈表節點並賦給tmp
        # 賦值
        res = tmp     
        # flag 標示
        flag = 0  # 初始化
        while(l1 or l2) :            
            tsum = 0  # 鏈表節點值的和
            if l1:  # 如果l1不爲空，把l1的某個節點值的和賦給tmp_sum
                tsum = l1.val  # 把l1的某個節點的值賦給tmp_sum
                l1 = l1.next # l1 向後遍歷
            if l2:  # 如果l2不爲空，把l2中和l1對應的節點的值加到tmp_sum
                tsum += l2.val
                l2 = l2.next  # 指向下一個節點，爲下一次的加和做準備
            tmp_res = ((tsum + flag) % 10)  #  當前位置的數值
            flag = ((tsum + flag) // 10) #  判斷是否需要進位   
            
            # Python 3以後  ：
    	    #" / "就表示 浮點數除法，返回浮點結果;" // "表示整數除法。

            res.next = ListNode(tmp_res)
            res = res.next  # res 向後遍歷

            if flag:  # 如果flag不爲0，就是對應位置相加後有進位
                res.next = ListNode(1)  # res的下一節點設爲1

        
        res = tmp.next  # 賦值
       
        return res  # 返回res鏈表