leetcode解题思路01

Posted 2022-12-03 雪狐晨光

一路走来,太累了,停下来歇歇吧,多休息一会,是为了走更远的路！

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链表