leecode | python刷题实战的一些问题与解决笔记

知识点：

一、列表，数组

1、当列表或字符串中有重复内容时，这些重复的索引值是相同的。
获取“内容”对应的索引：s.index(内容)
2、删除一个给定数组中重复的元素：可以利用set函数：

num = [1,2,1,4,5]
print(list(set(num)))
#因为set()输出的是{}，而不是列表[]，因此需要list(set(数组))

3、如果想要获取这些重复内容实际对应的索引，应该采用enumerate方法：
enumerate()方法输出的是一个字典。
eg:

for index, num in nums: 

获取列表a的索引：

list(enumerate(a))

#然后获取索引：
b=-1
for i in a:
	b = a.index(i, b+1,len(a))
    a_index.append(b)
print(a_index)

---

实战题目

一、栈

20.有效的的括号：

思路：消消乐思路，能配对的消除，剩下的如果是空，就为True；如果是非空，则为False。
关键代码：a.replace("()","")
注意：删除的一种方式——直接用空字符串替代原内容。

二、数组

1.两数之和

题目要求：

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。
来源：力扣（LeetCode）——链接

解1：while循环可用于小于某个数字时的循环，for循环适用于遍历。执行用时3896ms，内存消耗15.6MB。

class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
    l=len(nums)
    i=0

    while i<l-1:
        j=i+1
        while j<l:
            if(nums[i]+nums[j]==target):
                return [i,j]
            else:
                j += 1
        i += 1

解2（最优解）：用字典的方式。执行用时24ms，内存消耗16.1MB。

#定义一个空字典。命名随便。这里命名为hashmap，因为python里的字典相当于java里的hashmap。
    hashmap = {}
    for index,num in enumerate(nums):
        another_num = target - num
        #如果另一个数字在字典中，则执行以下返回语句
        if another_num in hashmap:
            return [hashmap[another_num],index]
        #存入字典：字典[key] = value
        hashmap[num] = index

26. 删除有序数组中的重复项

题目要求：

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。
由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。
将最终结果插入 nums 的前 k 个位置后返回 k 。
不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。（这一句还不太懂）
来源：力扣（LeetCode）——链接

解1：执行用时3032ms，内存消耗16.9MB

class Solution:
def removeDuplicates(self, nums: List[int]) -> int:
    #统计数组元素的索引值（元素值相同时，索引值也相同）
    index_list = []
    for i in nums:
        index_list.append(nums.index(i))
    
    #从后往前遍历，当索引列表中：后一个元素值与前一个元素值相同时，取出后一个元素的索引值，删除原数组中对应位置上的索引
    length = len(nums)
    i = length-1
    while i>0:
        if index_list[i] == index_list[i-1]:
            nums.pop(i)
            i -= 1
        else:
            i -= 1
    return len(nums)

解2：执行用时40ms，内存消耗16MB

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
    	#把解1中的第一部分换成这一句
		nums.sort()

        #从后往前遍历，当索引列表中：后一个元素值与前一个元素值相同时，取出后一个元素的索引值，删除原数组中对应位置上的索引
        length = len(nums)
        i = length-1
        while i>0:
            if nums[i] == nums[i-1]:
                nums.pop(i)
                i -= 1
            else:
                i -= 1
        return len(nums)

136.只出现一次的数字：

题目要求：不使用额外空间
思路：往位运算上想
知识点：

交换律：a ^ b ^ c <=> a ^ c ^ b
任何数于0异或为任何数 0 ^ n => n
相同的数异或为0: n ^ n => 0

var a = [2,3,2,4,4]
2 ^ 3 ^ 2 ^ 4 ^ 4等价于 2 ^ 2 ^ 4 ^ 4 ^ 3 => 0 ^ 0 ^3 => 3

关键代码：

a = 0
for i in nums:
	a = a ^ i
return a

169.多数元素：

要求：找出数组中出现次数大于n/2的数字
方法：摩尔投票法 时间复杂度O(N) 空间复杂度O(1)

class Solution {
public:
    int majorityElement(vector<int>& nums) {
//摩尔投票法,先假设第一个数过半数并设cnt=1；遍历后面的数如果相同则cnt+1，不同则减一，当cnt为0时则更换新的数字为候选数（成立前提：有出现次数大于n/2的数存在）
        int res=0,cnt=0;
        for(int i=0;i<nums.size();i++){
            if(cnt==0) {
                res=nums[i];
                cnt++;
            }
            else{
                res==nums[i]?cnt++:cnt--;
            }
        }
        return res;
    }
}

219.存在重复元素II

题目要求：给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。
来源：力扣（LeetCode）链接

解1：执行用时68ms，所占内存27.5MB

class Solution:
def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
    #如果数组中没有重复元素，则返回false
    if len(nums) == len(set(nums)):
        return False

    #反之：有重复元素的情况（将数组表示成字典，将索引值和元素值分开）：
    hashmap = {}
    j = -1
    for index,num in enumerate(nums):
        #给字典中存入第一组数
        if len(hashmap) < 1:
            #存入字典：字典[key] = value
            hashmap[num] = index

        #和前面已经存入hashmap的比较：
        else:
            #如果出现了重复元素，检查索引值的间距是否符合要求
            if num in hashmap:
                j += 1
                if len(hashmap)+j - hashmap[num] <= k:
                    return True
                else:
                    #如果不符合，删除旧数据，存入新数据
                    del hashmap[num]
                    hashmap[num] = index                     
            else:
                hashmap[num] = index

    return False

解2：执行用时64ms，所占内存26MB

class Solution:
def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:

    #将数组表示成字典，将索引值和元素值分开：
    hashmap = {}
    for index,num in enumerate(nums):
        #如果出现了重复元素，检查索引值的间距是否符合要求
        if (num in hashmap) and (index - hashmap[num] <= k):
                return True
        hashmap[num] = index                     

    return False

---

ps：编了一晚上的代码，脑子太乱了！已经可以预见到程序员的辛苦了。太费脑子！