python链表合并去重_LeetCode个人笔记python篇（easy）

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()则是新列表