LeetCode个人笔记（easy）

1、反转整数

class Solution:
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        j = 0  
        t = abs(x)
        while int(t) != 0:
            j = j*10+t%10
            t = int(t/10)
        if x < 0:
            j = -j
        if j<-2147483648 or j>2147483647:
            return 0
        return j

    问题1：python不同于C，整数除以10得到的是浮点数，需要转换。问题2：题目问的是反转后的整数溢出则为0，需审题。问题3：Python中最快的解答是将其转换成字符串然后利用切片[::-1]来进行转置。

9、回文数

class Solution:
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        return False if x < 0 else x == int(str(x)[::-1])

        在Python中，is 比较的是两个字符串指针位置是否相同，而 ==则判断字符串是否相同。

09、用两个栈实现队列

class CQueue {
public:
    stack<int>s1, s2;
    CQueue() {

    }
    
    void appendTail(int value) {
        while(s1.size() != 0)
        {
            int tmp = s1.top();
            s1.pop();
            s2.push(tmp);
        }
        s1.push(value);
        while(s2.size() != 0)
        {
            int tmp = s2.top();
            s2.pop();
            s1.push(tmp);
        }
    }
    
    int deleteHead() {
        if( s1.size() == 0){return -1;}
        int value = s1.top();
        s1.pop();
        return value;
    }
};

class CQueue(object):

    def __init__(self):
        self.stack1 = []
        self.stack2 = []

    def appendTail(self, value):
        """
        :type value: int
        :rtype: None
        """
        while self.stack1:
            self.stack2.append(self.stack1.pop())
        self.stack1.append(value)
        while self.stack2:
            self.stack1.append(self.stack2.pop())
        return self.stack1

    def deleteHead(self):
        """
        :rtype: int
        """
        if not self.stack1:
            return -1
        return self.stack1.pop()

像是一个简单版的汉诺塔问题，如果要插入数据，就把s1的所有数据搬运到s2上，插入后再从s2搬回来；删除数据则简单的从s1删除即可。

14、最长公共前缀

第一种做法：找到最短的字符串，然后遍历，第二种做法，打包成zip

        if not strs:
            return ""
        if len(strs) == 1:
            return strs[0]
        minl = min([len(x) for x in strs])
        end = 0
        while end < minl:
            for i in range(1,len(strs)):
                if strs[i][end]!= strs[i-1][end]:
                    return strs[0][:end]
            end += 1
        return strs[0][:end]

        res = ""
        if len(strs) == 0:
            return ""
        for each in zip(*strs):#zip()函数用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
            if len(set(each)) == 1:#利用集合创建一个无序不重复元素集
                res += each[0]
            else:
                return res
        return res

19、删除链表的倒数第N个节点

class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
    res = ListNode(0)
    res.next = head
    l1 = res
    l2 = res
    for i in range(n):
        l1 = l1.next
    while l1.next:
        l1 = l1.next
        l2 = l2.next
    l2.next = l2.next.next
    return res.next

python需要调用ListNode类来完成对链表的操作。其中基本操作如下：

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
 
l1 = ListNode(1)
l2 = ListNode(2)
l3 = ListNode(3)
l4 = ListNode(4)
 
l1.next = l2
l2.next = l3
l3.next = l4
 
print(l1.next.next.next = l4)

21、合并两个有序链表

class Solution:
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        a = l1
        b = l2
        c = ListNode(0)
        p = c
        while a and b:
            if a.val <= b.val:
                p.next = a
                a = a.next
            else:
                p.next = b
                b = b.next
            p = p.next
        if a:
            p.next = a
        elif b :
            p.next = b
        return c.next

26.数组去重

class Solution:
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 0:
            return 0
        i = 0
        for j in range(len(nums)):
            if nums[i] != nums[j]:
                i +=1
                nums[i] = nums[j]
        return i + 1

一说到去重想到的就是转换成集合set，但是题目要求在原数组上进行更改，集合不清楚是作为一个视图显示还是copy了一个数组

30、包含min函数的栈

class MinStack {
public:
    /** initialize your data structure here. */
    stack<int>data, help;
    MinStack() {

    }
    
    void push(int x) {
        data.push(x);
        if(help.empty() || x <= help.top()) {help.push(x);}
    }
    
    void pop() {
        if (data.top() == help.top()){help.pop();}
        data.pop();
    }
    
    int top() {
        return data.top();
    }
    
    int min() {
        return help.top();
    }
};

class MinStack(object):
    def __init__(self):
        """
        initialize your data structure here.
        """
        self.data = []
        self.help_ = []


    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.data.append(x)
        if self.help_ == [] or self.help_[-1] >= x:
            self.help_.append(x)


    def pop(self):
        """
        :rtype: None
        """
        if self.data[-1] == self.help_[-1]:
            self.help_.pop()
        self.data.pop()


    def top(self):
        """
        :rtype: int
        """
        return self.data[-1]


    def min(self):
        """
        :rtype: int
        """
        return self.help_[-1]

设计两个栈，一个作为原本data存放，一个作为辅助栈，辅助栈存放最小元素，当前push元素小于等于辅助栈最顶端元素，压入辅助栈中；当弹出元素等于辅助栈最顶端元素，则辅助栈也弹出。

66、加一

class Solution:
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        l = len(digits)
        i = 0
        digits[l-1] += 1
        if digits[l-1] == 10:
            i = l-2
            while(i >=0):
                digits[i] += 1
                digits[i+1] = 0
                if digits[i] >=10:
                    i -=1
                else:
                    break
        if i == -1:
            digits.insert(0,1)
            digits[1] = 0
        return digits

中心思想就是模拟进位，列表中插入数据的方法是l.insert(i,n),i是插入位置，n是插入数据。看到一个较快方法是把列表中元素*10+i变成一个整数，加一后再写除10求余变成列表。

69、x的平方根

class Solution:
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        l,r = 0,x
        while l<=r:
            mid = l + (r-l)//2
            if mid*mid <= x <(mid+1)*(mid +1):
                return int(mid)
            elif mid*mid >x:
                r = mid
            else:
                l = mid +1

问题1：直接使用i*i<x必然超时。问题2：用快排时注意边界。问题 3：python中，/表示浮点数除法，而//表示整数除法。问题4：排名在前面的一段代码：return int(x ** 1/2) （算你狠。果然还是编译器自己的代码最6么）。求平方根还可用牛顿迭代法，速度更快。

104、二叉树最大深度

class Solution:
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """ 
        if root is None: 
            return 0 
        else: 
            left_height = self.maxDepth(root.left) 
            right_height = self.maxDepth(root.right) 
            return max(left_height, right_height) + 1 

125、验证回文串

class Solution:
    def isPalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        s2 = list(filter(str.isalnum,s.lower()))
        s1 = s2[::-1]
        if s1 == s2:
            return True
        else:
            return False

filter,过滤器，接收一个函数和一个序列，如果序列不符合函数，则去掉其中元素。

141、环形链表

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        fast = slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if slow == fast:
                return True
        return False

主要分析如下链接所示：

https://blog.csdn.net/qq_34364995/article/details/80518191

206、反转链表

class Solution:
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head is None:
            return None
        p=head
        pre=None
        cur = None
        while p:
            cur = p.next
            p.next = pre
            pre = p
            p = cur
        return pre

217、存在重复元素

自己想的是先排序，然后从头遍历，但凡和下一个元素一样就有重复的。网上最快答案是len(nums)>len(set(nums))

237、删除链表中的节点

class Solution:
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        node.val=node.next.val
        node.next=node.next.next

242、有效的字母异位词

class Solution:
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        l1=list(s)
        l2=list(t)
        l1.sort()
        l2.sort()
        if l1==l2:
            return True
        else:
            return False

使用List可以将字符串转换为列表。最快的方式是转换成集合，然后使用s.count()函数挨个判断字符数是否相等。

290、单词模式

class Solution:
    def wordPattern(self, pattern, str):
        """
        :type pattern: str
        :type str: str
        :rtype: bool
        """
        str1 = str.split(" ")
        if len(str1) != len(pattern):
            return False
        return len(set(str1)) == len(set(pattern)) == len(set(zip(str1,pattern)))

这是一个查找是否为完全映射的问题。

387、字符串中的第一个唯一字符

class Solution:
    def firstUniqChar(self, s):
        """
        :type s: str
        :rtype: int
        """
        check = []
        for i in 'abcdefghijklmnopqrstuvwxyz':
            if s.find(i) != -1 and s.find(i) == s.rfind(i):
                check.append(s.find(i))
        return min(check) if len(check) >0 else -1

这是最快的方法，其中rfind的作用是从后往前找第一次出现的位置，即最后一次出现的位置。find是从左边开始找到第一次出现的位置

509. 斐波那契数

第一种方法是递归，第二种方法时间复杂度是O(N)

class Solution(object):
    def fib(self, N):
        """
        :type N: int
        :rtype: int
        """
        if N<2:
            return N
        return self.fib(N-1) + self.fib(N-2)

class Solution(object):
    def fib(self, N):
        """
        :type N: int
        :rtype: int
        """
        if N<2:
            return N
        first = 0
        second = 1
        for i in range(2,N+1):
            third = first + second
            first = second
            second = third
        return third

680、验证回文字符串 Ⅱ

class Solution:
    def validPalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        k = s[::-1]
        if k == s:
            return True
        for i in range(len(s)):
            if s[i] != k[i]:
                break
        if i == 0:
            news = s[i+1:]
            news2 = k[i+1:]
        else:
            news = k[:i] + k[i+1:]
            news2 = s[:i] + s[i+1:]
        news3 = news[::-1]
        news4 = news2[::-1]
        if news == news3 or news2 == news4:
            return True
        else:
            return False

首先思路是先反转，如果遇到不一样，就删掉，看剩下的是否能凑成回文。主要遇到问题是不一致字符串是删源字符串还是删反转后的k，再有就是不一致字符出现在首尾的问题。有个问题是看到别人可以直接写成return True if s == s[::-1] else False这种形式，但是我一写就会报错，只能添加很多无用变量。大概好像是因为==的问题？

709、转换成小写字母

class Solution:
    def toLowerCase(self, str):
        """
        :type str: str
        :rtype: str
        """
        return str.lower()

一开始想的是和C语言一样，遍历字符串，然后遇到大写字母就加32，但python会提示字符和数字不能相加，然后直接用了Python自带函数。但奇怪的是所有提交答案都一样，却有执行效率不一样的问题。

884、两句话中的不常见单词

class Solution:
    def uncommonFromSentences(self, A, B):
        """
        :type A: str
        :type B: str
        :rtype: List[str]
        """
        LA = A.split(" ")
        LB = B.split(" ")
        L = []
        for i in LA:
            LC = LA[:]
            LC.remove(i)
            if (i not in LC) and (i not in LB):
                L.append(i)
        for i in LB:
            LD = LB[:]
            LD.remove(i)
            if (i not in LD) and (i not in LA):
                L.append(i)
        return L

这里主要用到了一个函数remove()它可以删除首个符合条件的元素，因此想法是遍历列表LA，把元素提取出来，然后复制列表LC再删除当前元素，如果当前元素还在LC中，则代表此元素出现不止一次，因此选取不在LC也不在LB中的元素即为符合条件。然后对LB进行同样操作。

注意复制列表时要用LC = LA[:]，仅用LC = LA会指向同一个地址。使用 a[:], list(a), a*1, copy.copy(a)四种方式复制列表结果都可以得到一个新的列表。

867、转置矩阵

看到一个十分有意思的答案

return map(list, zip(*array))

map是一个映射函数，把后面的每一项用前面的函数转化。list就是将zip(*array)转化成list得到题目要求输出。而zip的用法是

a = [1,2,3],b = [4,5,6] zip(a,b) = [(1,4),(2,5),(3,6)],如果元素个数不一致，则按最短的输出，zip的本意是减少内存。而zip(*)是zip的逆操作，a = [[1,4],[2,5],[3,6]],zip(*a) = [(1,2,3)(4,5,6)]得到的是元组，需要转换成list输出.

896、单调数列

if A == sorted(A,reverse=True) or A == sorted(A,reverse=False):
    return True
else:
    return False

排序后考察是否和原列表一致。如果用list.sort()会排序原列表，用sorted()则是新列表

1128. 等价多米诺骨牌对的数量

class Solution:
    def numEquivDominoPairs(self, dominoes: List[List[int]]) -> int:
        res = 0
        dicto = {}
        for i,j in dominoes:
            nums = 10*i +j if i >j else (10*j +i)
            if (nums not in dicto):
                dicto[nums] = 0
            else:
                dicto[nums] += 1
                res += dicto[nums]
        return res

这个题遍历肯定行不通，于是用哈希表的方法来做，但是注意的是List是不可哈希的，不能直接作为key放到字典中，于是把原本的列表转换为二位数进行存储。并且不需要最后遍历values再算阶乘，可以直接相加