leetcode刷题
python刷题常用数据结构
引用自：https://blog.csdn.net/afterlake/article/details/100054150
我总结了一下自己在刷leetcode时关于python这个语言的经常被使用的数据结构和内置方法。
基础
离开数据结构，算法就是空中楼阁，所以了解python内置的数据类型用法和其效率是非常有必要的
list
list作为最常见的内置数据结构，其不仅可以当作C语言的数组来使用，一些python特有的特性往往可以事半功倍
append 在list的结尾追加一个元素
sort 对list进行排序，在list长度小的时候使用插入排序，在长度大的时候使用快排，所以其时间复杂度可以视为O(nlgn)
pop 将最后一个元素重list内部弹出并返回
切片 python强大的语法糖之一，不仅可以用非负数索引，负数索引的合理使用可以节省不少代码量
set
set本质是哈希表，会对其内部元素去重，检查一个元素是否在set内部的时间复杂度是O(1)
常用的方法为
add 添加一个元素，就算是用一个元素多次添加，其内部也仅保留一份
pop 随机弹出一个元素并返回
dict
同set一样，dict本质也是哈希表，但是set是单个元素，dict是key-value的组合
setdefault 接受两个入参key、default， 如果dict存在key则不做任何操作，如果不存在key，则创建一个 key其value为default
get 同setdefault一样接受两个参数key、default，如果存在key，则返回其value，否则返回default
pop 同setdefault一样接受两个参数key、default，如果存在key，则删除key返回其value，否则返回default
str
字符串也是一个经常在算法中常用的数据结构，在python中str是不可变对象，支持”+“操作当时效率不高需要慎用
split 用指定的分隔符将str分割为list
strip 返回str去掉首尾的空白符后新的str，原来的str不受影响
join 用str作为连接符连接参数里面的每一个元素，常常用来替代”+“
进阶
这里介绍几个常用的内置函数
int 将一个参数转为int类型，在遇到字母等字符时会抛出错误
sum 返回参数的求和
min 返回多个参数的最小值
max 返回多个参数的最大值
abs 返回一个数字的绝对值
高级
这里对于数据结构的知识点要求就比较高了，仅仅介绍常用方法，如果不了解其特性的还请自己查阅资料
queue 队列
put 入队操作
get 出队操作
list 栈
这里又有list，是因为python没有单独的栈，在需要栈的时候往往使用list
append 入栈
pop 出栈
heapq 堆
仅支持最小堆，有个小技巧：如果最大堆，取反之后再放入堆，取出的时候再取反
heapfiy 将一个list转为最小堆
heappush 往一个最小堆添加元素
heappop 弹出堆中的最小值并返回
题目：
给定 matrix =
[
[1,2,3],
[4,5,6],
[7,8,9]
],
原地旋转输入矩阵，使其变为:
[
[7,4,1],
[8,5,2],
[9,6,3]
]
class Solution(object): def rotate(self, matrix): """ :type matrix: List[List[int]] :rtype: None Do not return anything, modify matrix in-place instead. """ length=len(matrix) ans=[] for i in range(length): row=[] for j in range(length): row.append(matrix[length-j-1][i]) ans.append(row) matrix[:]=ans return matrix
字符串轮转。
给定两个字符串s1和s2，请编写代码检查s2是否为s1旋转而成（比如，waterbottle是erbottlewat旋转后的字符串）。
示例1:
输入：s1 = "waterbottle", s2 = "erbottlewat"
输出：True
return len(s1) == len(s2) and s1 in s2*2
链表去重
编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。
示例1:
输入：[1, 2, 3, 3, 2, 1] 输出：[1, 2, 3]
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def removeDuplicateNodes(self, head): """ :type head: ListNode :rtype: ListNode """ if not head: return head history = set() # history = [] temp = head while temp: if temp.val not in history: # history.append(temp.val) history.add(temp.val) pre = temp temp = temp.next else: pre.next = temp.next temp = temp.next return head
输出链表的倒数k个元素
暴力破解
class Solution(object): def kthToLast(self, head, k): """ :type head: ListNode :type k: int :rtype: int """ cur = head n = 0 while cur.next: n += 1 cur = cur.next c,cur2 = 0,head while c <= n-k: c += 1 cur2 = cur2.next return cur2.val
机器人过关问题
输入:
[
[0,0,0],
[0,1,0],
[0,0,0]
]
输出: [[0,0],[0,1],[0,2],[1,2],[2,2]]
解释:
输入中标粗的位置即为输出表示的路径，即
0行0列（左上角） -> 0行1列 -> 0行2列 -> 1行2列 -> 2行2列（右下角）
思路：递归，注意边界条件
# 递归算法 class Solution: def move(self, path, now, grid, r, c): # 传入递归变量path(保存正确路径)，现在的位置，整个地图，以及地图大小(重复传入避免重复计算) print(now) if now==[r-1, c-1]: # 递归终止条件: 现在在终点 path.insert(0, now) # 把当前位置(终点)插入正确路径的首位(因为它是第一个完成的所以插在首位，后面的位置都插在他前面) return True, now else: # 递归: 若不在终点 if now[1]<=c-2 and grid[now[0]][now[1]+1]==0: # 若当前位置的右边可行进(注意与可完成的区别)，则 next_op = [now[0], now[1]+1] # 下一步向右 now_way = self.move(path, next_op, grid, r, c) # 接受向右的结果 if now_way[0]: # 向右可到达(则当前位置可到达) path.insert(0, now) # 把当前位置插在历史记录的可到达路径的首位 return True, path elif now[0]<=r-2 and grid[now[0]+1][now[1]]==0: # 若右方不可行进 next_op = [now[0]+1, now[1]] # 则尝试下方 now_way = self.move(path, next_op, grid, r, c) # 接受向下的结果 if now_way[0]: # 向下可到达(则当前位置可到达) path.insert(0, now) # 把当前位置插在历史记录的可到达路径的首位 return True, path else: # 若右方与下方均不可到达 return False, # 则当前位置不可到达终点 else: return False, elif now[0]<=r-2 and grid[now[0]+1][now[1]]==0: # 若右方不可行进(如有障碍物或者到地图边缘) next_op = [now[0]+1, now[1]] # 下一步向下 now_way = self.move(path, next_op, grid, r, c) if now_way[0]: path.insert(0, now) return True, path else: return False, else: # 若右方与下方均不可行进 return False, # 则当前位置不可到达 def pathWithObstacles(self, obstacleGrid: List[List[int]]) -> List[List[int]]: r = len(obstacleGrid) c = len(obstacleGrid[0]) # 记录下地图的大小 if r==1 and c==1: # 如果是1x1直接返回结果 if obstacleGrid[0][0]==0: return [[0, 0]] else: return [] if obstacleGrid[0][0]==1 or obstacleGrid[r-1][c-1]==1: # 如果起点或者终点有障碍物则判否 return [] way = self.move([], [0, 0], obstacleGrid, r, c) # 递归运算，返回值是元组，way[0]表示是否存在路径，way[1]给出路径 print(way) if way[0]: return way[1] else: return []
思路： 递归，从根开始
# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution(object): def pathSum(self, root, sum): """ :type root: TreeNode :type sum: int :rtype: int """ self.ans = 0 def f(node, vals): if node: vs = [i + node.val for i in vals] + [node.val] for i in range(len(vs)): if vs[i] == sum: self.ans += 1 f(node.left, vs) f(node.right, vs) f(root, []) return self.ans
照样普通二分可以做
两个等价
mid = (left + right) >> 1mid = (left + right) /2
把循环的归类
编写一种方法，对字符串数组进行排序，将所有变位词组合在一起。变位词是指字母相同，但排列不同的字符串。
对于这种去重、分类问题，用sorted()排序之后就可以放入dict了
括号匹配问题：
括号。设计一种算法，打印n对括号的所有合法的（例如，开闭一一对应）组合。
说明：解集不能包含重复的子集。
例如，给出 n = 3，生成结果为：
[
"((()))",
"(()())",
"(())()",
"()(())",
"()()()"
]
class Solution(object): def generateParenthesis(self, n): """ :type n: int :rtype: List[str] """ re = [] state = '' def dsp(state, p, q): #p,q分别表示(和)还剩的个数，有个隐含条件：就是(在组合时候比)用的多或相等 if p > q: #非法，剪枝 return if q == 0: #)用完之时 re.append(state) if p > 0: dsp(state+'(', p-1, q) if q > 0: dsp(state+')', p, q-1) dsp(state, n, n) return re
