刷题随笔 Day5

题目一

题目描述

【力扣707.设计链表】

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

Python代码

class ListNode:
    def __init__(self,val):
        self.val=val
        self.next=None

class MyLinkedList:

    def __init__(self):
        self.size=0
        self.head=ListNode(0)

    def get(self, index: int) -> int:
        if index<0 or index>=self.size:
            return -1
        cur = self.head
        for i in range(index+1):
            cur = cur.next
        return cur.val

    def addAtIndex(self, index: int, val: int) -> None:
        if index>self.size:
            return
        if index <=0:
            self.size+=1
            self.t=ListNode(val)
            self.t.next=self.head.next
            self.head.next = self.t
        else:
            self.size+=1
            self.m = ListNode(val)
            pre = self.head
            for i in range(index):
                pre=pre.next
            self.m.next = pre.next
            pre.next = self.m  
    def deleteAtIndex(self, index: int) -> None:
        if index<0 or index>=self.size:
            return
        self.size-=1
        pred = self.head
        for i in range(index):
            pred = pred.next
        pred.next = pred.next.next
    def addAtHead(self,val:int)->None:
        self.addAtIndex(0,val)
    def addAtTail(self,val:int)->None:
        self.addAtIndex(self.size,val)

解题小记

是一个用代码实现链表的六个基本操作的题目。首先定义了一个单链表，包括一个值域和一个指针域，并将初始指针指向None（Python中None表示空值）。然后对链表进行初始化，创建一个头指针，并且用size记录链表的长度。

get函数：参数有一个，就是所要获取的值的索引。要注意这里的索引相当于是数组的下标，是从0开始的，所以最大索引其实是size-1，根据题目，先对索引进行判断，如果小于0或者大于链表长度则返回-1.如果索引在合理范围内，设置一个虚拟指针，指向头指针所在节点，使用for循环，一步一步将指针后移到索引的位置。注意边界问题，由于是从0开始，循环也是从0开始，所要循环的次数是索引数＋1，最后返回指针所指向的值。

addAtIndex函数：有一个参数，是要在该索引值前插入新结点。按照题意，索引大于链表长度时，直接return；索引值小于0时，在头部插入新节点，假设一个新指针t，将新指针指向新节点，将新节点的指针域指向头指针指向的结点，再将头指针的指向新节点即可插入；当索引值在0-size之间时，依然假设一个新指针指向头结点，先使用for循环将新指针指向索引值节点的前一个节点（在这里循环次数就是index了），然后依然是创建一个新节点，然后使新节点的指针域指向索引值所在节点，再将新指针指向新节点即可完成插入。注意size需要＋1.

deleteAtIndex函数：与插入函数类似，先将指针指向前一个节点，然后将该节点的指针域指向下下一个节点，即可删除。注意size需要-1。

题目二

题目描述

【力扣242.有效的字母异位词】

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

Python代码

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        a = [0]*26
        for i in range(len(s)):
            m=ord(s[i])-ord('a')
            a[m]+=1
        for j in range(len(t)):
            n = ord(t[j])-ord('a')
            a[n]-=1
        for k in range(26):
            if a[k]!=0:
                return False
        return True

解题小记

使用哈希表：

这里的哈希表相当于一个数组，因为所要存储的数据是有限的，分别遍历两个字母列表，由于26个字母的ASCII码值是连续的，将每个字母的ASCII码值与字母a的ASCII码值相减得到的值为0-25，可以将其看作数组的下标，而数组中存储该字母的个数。先遍历一个字母列表，遇到一个就在相应数组+1。再遍历另一个，遇到一个就在相应数组-1。最后检查数组是否都是空值。

ord（）函数：将字符转化为数字

题目三

【力扣349.两个数组的交集】

题目描述

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

Python代码

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        x=set(nums1)
        y=set(nums2)
        if len(x)<len(y):
            return [i for i in x if i in y]
        else:
            return [j for j in y if j in x]

解题小记

由于不考虑列表元素的位置并且需要进行删除重复值的操作，所以使用set函数完成。

set（）函数：创建一个无序不重复的元素集，是一个集合，为了降低运行时间，判断集合长短，遍历较短的集合中的各个元素是否在另一个集合中，在就把他放入列表中返回。

题目四

题目描述

【力扣1.两数之和】

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

Python代码

暴力解法

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        #暴力解法
        sum = 0
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                sum = nums[i] + nums[j]
                if sum==target:
                    return [i,j]
        return

哈希表

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        #哈希表解法
        hashtable = dict()#创建一个字典
        for i,value in enumerate(nums):
            if target-value in hashtable:
                return [hashtable[target-value],i]
            hashtable[nums[i]]=i
        return

解题小记

暴力解法：由于规定了是两个数，且只对应一个答案，所以直接使用两个for循环，将列表中的数亮亮相加，符合条件就返回其下标列表。

哈希表解法：使用dict()函数创建一个字典，enumerate（）函数可以在for循环中给出索引和元素的值。所以使用for循环获得每个元素的索引值和元素值，逐个存入字典中，键是元素值，值是索引值。并且在存入前进行判断，如果发现字典中已经有可以和该值相加满足目标值的键时，就返回该键所对应的值以及当前循环的索引值，即为所求。

题目五

题目描述

【力扣454.四数相加2】

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

Python代码

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        hash = dict()
        count = 0
        for i in range(len(nums1)):
            for j in range(len(nums2)):
                sum = nums1[i]+nums2[j]
                if sum in hash:
                    hash[sum]+=1
                else:
                    hash[sum]=1
        for m in range(len(nums3)):
            for n in range(len(nums4)):
                s = nums3[m]+nums4[n]
                if -s in hash:
                    count = count+hash[-s]
        return count

解题小记

哈希表解法：也是先创建一个字典，用键来存储前两个列表中元素相加的值，而键对应的值表示这些加和所出现的次数。先遍历前两个列表的值进行加和，存入字典，再对后两个列表进行加和，如果它们加和的负值存在于字典中，就将对应的值存入count进行计数，最后输出count的值。