LeetCode个人笔记python篇（medium）
2. 两数相加
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
l3 = ListNode(0)
p3 = l3
tmpsum = 0
while True:
if l1:
tmpsum += l1.val
l1 = l1.next
if l2:
tmpsum += l2.val
l2 = l2.next
p3.val = tmpsum%10
tmpsum = tmpsum//10
if l1 == None and l2 == None and tmpsum == 0:
break
p3.next = ListNode(0)
p3 = p3.next
return l3主要思想和计算加法的思想一样，先看l1是否有数字，有就加，再看l2，直到l1,l2和进位都为空的时候就停止循环。往新链表里插入节点时，要先初始化一个ListNode，再插入。
74. 搜索二维矩阵
这种有序矩阵，首先想到的是从右上角判断，先判断是否大于最后一个数，如果不大于就搜索本行，再没有就返回false。需要注意列表中没有数的情况。如[[]]，[[1]]这种情况。
class Solution:
def searchMatrix(self, matrix, target):
"""
:type matrix: List[List[int]]
:type target: int
:rtype: bool
"""
l1 = len(matrix)
if l1 == 0:
return False
l2 = len(matrix[0])
if l2 == 0:
return False
for i in range(l1):
if target > matrix[i][l2-1]:
continue
else:
for j in range(l2):
if target == matrix[i][j]:
return True
elif target > matrix[i][j]:
continue
else:
return False
return False
return False还有一份代码是这样写的：
lst = []
for i in range(len(matrix)):
lst += matrix[i]
return target in set(lst)list直接用+，比如a = [1,2,3]，b = [4,5,6]，c = a+b，c的结果：[1,2,3,4,5,6]
用extend,a = [1,2,3],b = [4,5,6],a.extend(b),a的结果：[1,2,3,4,5,6]。不同的是+是生成一个新的，extend是在原数组a上进行改动
144. 二叉树的前序遍历
class Solution:
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
if not root:
return []
result=[root.val]
return result+self.preorderTraversal(root.left)+self.preorderTraversal(root.right)如果不用列表相加，可以重写一个函数进行递归调用，把列表拿出来
153. 寻找旋转排序数组中的最小值
这道题是二分查找的变形。令first=0,last=len(nums)-1，因为是升序数组，当中间的值大于first的时候，代表它在前面的升序数组中；如果小于first代表是后面的部分。last所指即为最小。
class Solution(object):
def findMin(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
first = 0
last = len(nums) - 1
flag = 0
while nums[first] > nums[last]:
flag = 1
if last - first == 1:
mid = last
break
mid = (first + last)//2
if nums[mid] > nums[first]:
first = mid
else:
last = mid
if flag == 0:
return nums[0]
else:
return nums[last]其中flag是保证数组无需旋转的情况正确。
442. 数组中重复的数据
首先想到的是排序，然后遍历一遍。
class Solution:
def findDuplicates(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
two_list = []
nums2 = sorted(nums)
for i in range(1,len(nums2)):
if nums2[i-1] ==nums2[i]:
two_list.append(nums2[i-1])
return two_list但是很显然，这样的方法效率不高，不如用字典，类似哈希表。还有一种更快的方法是用集合：
class Solution:
def findDuplicates(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
a = []
b = set()
for num in nums:
if num in b:
a.append(num)
else:
b.add(num)
return a450. 删除二叉搜索树中的节点
1、结点有左子树无右子树，结点等于左子树
2、结点有右子树无左子树，结点等于右子树
3、左右子树均存在，用右子树最左结点或者左子树最右结点替代
#非递归
class Solution(object):
def deleteNode(self, root, key):
"""
:type root: TreeNode
:type key: int
:rtype: TreeNode
"""
# 找到该节点 并保存其父亲节点
pre, q = None, root
while q and q.val != key:
pre = q
if q.val < key:
q = q.right
else:
q = q.left
if not q: # 如果没有该key
return root
if not q.left: # 如果没有左子树 （或 左右子树都没有）
if not pre: # 说明要删的是根节点
return q.right
if pre.left == q:#连在父节点的左子树上
pre.left = q.right
else:
pre.right = q.right
else: # 如果有左子树 提左子树的最右叶子 或 提右子树的最左叶子
# 找到左子树的最右叶子
tmp = q.left
while tmp.right:
tmp = tmp.right
tmp.right = q.right
if not pre: # 说明要删的是根节点
return q.left
if pre.left == q:
pre.left = q.left
else:
pre.right = q.left
return root
#递归
class Solution(object):
def deleteNode(self, root, key):
"""
:type root: TreeNode
:type key: int
:rtype: TreeNode
"""
if not root:
return None
#到左子树里搜索
if root.val > key:
root.left = self.deleteNode(root.left, key)
#到右子树里搜索
elif root.val < key:
root.right = self.deleteNode(root.right, key)
else:
# 存在的子树代替根节点
if not root.left or not root.right:
root = root.left if root.left else root.right
else:
temp = root.right
# 找到右子树的最小（最左）节点
while temp.left:
temp = temp.left
root.val = temp.val
# 继续在右子树里递归
root.right = self.deleteNode(root.right, temp.val)
return root701. 二叉搜索树中的插入操作
class Solution(object):
def insertIntoBST(self, root, val):
"""
:type root: TreeNode
:type val: int
:rtype: TreeNode
"""
if not root:
root = TreeNode(val)
return root
search = root
while search:
insertParent = search
if val < search.val:
search = search.left
else:
search = search.right
insertNode = TreeNode(val)
if insertParent.val > val:
insertParent.left = insertNode
else:
insertParent.right = insertNode
return root不考虑平衡性，二叉搜索树插入就是简单的小于往右大于往左，设置一个父节点，然后到空时插入父节点下面。