刷题一周一总结（1）--20211227~20220102

20211227-20220102之间python做题记录总结：
leetcode1.两数之和—无序数组
题目描述：
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

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

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

输入：nums = [2,7,11,15], target = 9
输出：[0,1]

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

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

方法一：哈希算法

def twoSum(nums, target):
    hashtable = {}  # 定义一个空的字典，key:value存放nums的值:索引
    for i, num in enumerate(nums):
        if target - num in hashtable:
            return [hashtable[target - num], i]
        hashtable[nums[i]] = i
    return [-1, -1]
    # 时间复杂度：O(n)
	# 空间复杂度：O(n)	

方法二：暴力解法

def twoSum(nums,target):
    ls = len(nums)
    for i in range(ls-1):
        for j in range(i+1,ls):
            if nums[i]+nums[j]==target:
                return [i,j]
    return [-1,-1]
# 时间复杂度：O(n**2)
#空间复杂度：O(1)

leetcode167.两数之和—有序数组
题目描述：
给定一个已按照 非递减顺序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。
输入：numbers = [2,7,11,15], target = 9
输出：[1,2]

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

输入：numbers = [-1,0], target = -1
输出：[1,2]

思路：这道题可以使用上面那道题的解法，但没有使用有序数组这一特性；

解法一：二分法
一出现有序，我们应该会想到二分法
这个我发现我也没太理解，后面理解了再补充

解法二：双指针

def twoSum(nums,target):
    left,right=0,len(nums)-1
    while left <= right:
        if nums[left]+nums[right]==target:
            return [left,right]
        elif nums[left]+nums[right]>target:
            right -= 1
        else:
            left += 1
    return [-1,-1]
# 时间复杂度：O(n)-双指针，只需要遍历一次列表
# 空间复杂度：O(1)

leetcode344.反转字符串
题目描述：
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

输入：s = [“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

输入：s = [“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

思路：题目要求原地修改，因此直接return s[::-1]是不对的，如下图s和s1地址不同，不是在原地修改：

方法一：python列表内置reverse函数

def reverseString(s):
    s.reverse()
    return s
#时间复杂度O（n），但需要操作n次
#空间复杂度O（1）    

这里再说一下reverse和reversed的区别，类似的还有sort和sorted：
reverse是内建方法，只对列表有效，用法：list.reverse()–原地修改列表
reversed()是函数，对所有可迭代对象生效，用法：revered（可迭代对象）–返回迭代器

方法二：双指针法

def reverseString(s):
    left,right=0,len(s)-1
    while left < right:
        s[left],s[right]=s[right],s[left]
        left += 1
        right -= 1
    return s
# 时间复杂度O（n），共需要循环n/2次
# 空间复杂度O（1）

leetcode557.反转字符串中的单词
问题描述：
给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
输入：“Let’s take LeetCode contest”
输出：“s’teL ekat edoCteeL tsetnoc”
我自己的解题方法：

def reverseWords(s):
    ls = s.split(' ')
    lss = []
    for i in range(len(ls)):
        lss.append(ls[i][::-1])
    return ' '.join(lss)
    #时间复杂度：
    #空间复杂度：
    #我不太会算，等我后面学了再补充

下面是看了题解，优秀的同学写出的优雅的代码：

def reverseWords(s):
	return ' '.join(word[::-1] for word in s.split(' '))

def reverseWords(s):
	return ' '.join(s[::-1].split(' ')[::-1])

leetcode189.轮转数组
题目描述：
给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]

def rotate(nums,k):
    n = len(nums)
    k = k % n
    nums[:k],nums[k:]=nums[n-k:],nums[:n-k]
    return nums

可以拿笔写一下，旋转前后两个数组，索引变化

leetcode27.移除元素-双指针
题目描述：
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]

def removeElement(nums,val):
    a=b=0
    n=len(nums)
    while a < n:
        if nums[a] != val:
            nums[b]=nums[a]
            b+=1
        a+=1
    return b

leetcode283.移动零-双指针
题目描述：
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

def moveZerosion(nums):
    left = right = 0
    n = len(nums)
    while right < n:
        if nums[right]!=0:
            nums[left],nums[right]=nums[right],nums[left]
            left += 1
        right += 1
    return nums

以上本周总结，第一次总结，心情是自闭的，最后两个双指针的题目，时隔一周重新做，还不会写，可能一开始就没完全理解，我坚信还是代码写少了，继续努力吧，朝着目标。我会坚持每周更新。