1.两数之和
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)):
for j in range(len(nums)):
if i != j:
if nums[i]+nums[j]==target:
return [i,j]改善
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
for i in range(len(nums)):
res= target-nums[i]
if res in nums[i+1:]:
j=nums[i+1:].index(res)
return[i,i+1+j]学习哈希表
哈希表时间复杂度O(1)
通过一个字符串得到一个数值
要求1.一致性 2.不同字符串映射为不同数值
Hash Table
子串和子序列的区别
2 子串-substring
关键词：连续
子串定义：子串，计算机术语，串中任意个连续的字符组成的子序列称为该串的子串。
下面举几个例子：
ab的子串：a、b、ab、/0(空串）共4个即（2+1+1）个，
abc的子串：a、 b、 c、 ab、 bc 、abc、/0共（3+2+1+1）个，
所以若字符串的长度为n, 则子串的个数就是[n(n+1)/2+1]个，*
3 子序列-subsequence
关键词：任意地选取，即不用连续
字符串
空格也是字符串
1.字符串索引和切片： 索引 正向递增序号和反向递减序号
s='hallo'
s[0] 输出 h
s[-3] 输出 l
切片
比如字符串
s='hallo world'
s[::-1] 输出dlrow ollah
s[0:5:1] 输出hallo
s[4:10:2] 输出 owrd
2.字符串的函数
-
len(x) #返回字符串x的长度
-
str(x) #将任意类型的x转化为字符串类型
-
chr(x) #返回Unicode编码为x的字符
-
ord(x) #返回字符x的Unicode编码
-
hex(x) #将整数x转化为十六进制数
-
oct(x) #将整数x转化为八进制数
find() #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中首次出现的位置，若不存在则返回-1
rfind() #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中最后一次出现的位置，若不存在则返回-1
index() #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中首次出现的位置，若不存在则抛出异常
rindex() #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中最后一次出现的位置，若不存在则抛出异常
count() #用来返回一个字符串在另一个字符串中出现的次数，若不存在则返回0
i = max(dic[s[j]], i) # 更新左指针 i
第2题无重复的最大子串
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
dic,res,i = {}, 0, -1
for j in range(len(s)):
if s[j] in dic:
i = max(dic[s[j]],i)
dic[s[j]] =j
res = max(res, j - i) # 更新结果
return res第88题
1.函数sort（）是对列表就地排序
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> x.sort()
>>> print(x)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2.函数sort()修改序列，不返回任何值
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> y=x.sort()
>>> print(y)
None
>>> print(x)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
3.sorted()函数会返回一个排序列表，不改变原有序列
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> y=sorted(x)
>>> print(y)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(x)
[8, 9, 0, 7, 4, 5, 1, 2, 3, 6]
4.函数sort（）是升序排序，如何降序排序，需要用到函数reverse（）
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> x.sort()
>>> x.reverse()
>>> print(x)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
5.函数sort（）排序的高级用法
方法sort（）可以接受两个参数sort（key,reverse）
(1) key参数
key接受的是一个只有一个形参的函数
key接受的函数返回值，表示此元素的权值，sort将按照权值大小进行排序
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> def size(a):
>>> x=10-int(a)
>>> return x
>>> x.sort(key=size)
>>> print(x)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
(2) reverse参数
reverse接受的是一个bool类型的值 (Ture or False),表示是否颠倒排列顺序,一般默认的是False，注意第一个字母是大写的
>>> x=[8,9,0,7,4,5,1,2,3,6]
>>> x.sort(reverse=True)
>>> print(x)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> x.sort(reverse=False)
>>> print(x)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
i =0
while i <= len(nums):
if val == nums[i]:
nums.pop(i)
i +=1
return len(nums)
第4题最长回文子串
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
i =0
while i <= len(nums):
if val == nums[i]:
nums.pop(i)
i +=1
return len(nums)
下面的a = [1,2,3,4,5]
[-1]： 列表最后一项
[:-1]： 从第一项到最后一项
原型是[n : m]，前闭后开，索引从零开始，第一个索引指定可以取到，即n可以取到，后一个索引不可取到，即m不可取到。
[::-1]： 代表从全列表倒序取
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
intervals.sort()
ans = [intervals[0]]
for s,e in intervals[1:]:
if ans[-1][1] < s:
ans.append([s,e])
else:
ans[-1][1] = max(ans[-1][1],e)
return ans链表node
链表是由一系列节点组成的元素集合。每个节点包含两部分，数据域item和指向下一个节点的指针next.
class Node(objiect):
def _init_(self,item)
self.item =item
self.next = None
创建链表
头插法在头节点插入head
尾插法tail
链表的插入删除
p.next = curNode.next
curNode.next=p
删除
curNode.next=p.next
del p
双链表;每个节点有两个指针
p.next = curNode.next
curNode.next.prior = p
p.prior =curNode
curNode.next=p
备注： 在 Python 中，and 和 or 都有提前截至运算的功能。
and：如果 and 前面的表达式已经为 False，那么 and 之后的表达式将被 跳过，返回左表达式结果
or：如果 or 前面的表达式已经为 True，那么 or 之后的表达式将被跳过，直接返回左表达式的结果
例子：[] and 7 等于 []
第合并两个有序列表
class Solution:
def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
if list1 is None or list2 is None:
return list1 or list2
if list1.val <= list2.val:
list1.next = self.mergeTwoLists(list1.next, list2)
return list1
else:
list2.next = self.mergeTwoLists(list1, list2.next)
return list2
双指针的快慢指针
第10题 两数相加 leetcode为第二题
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
i=0
head = l3 =ListNode(None)
while l1 or l2 or i :
i = (l1.val if l1 else 0) +(l2.val if l2 else 0) +i
l3.next =ListNode(i%10)
i=i//10
l1 = l1.next if l1 else None
l3 =l3.next
l2 = l2.next if l2 else None
return head.next
贪心算法
求解优化问题的一类算法
最（多，少，长，短）
步骤
遍历备选的元素
贪心策略确定选择一个元素
决策过程
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
Python 2.3. 以上版本可用，2.6 添加 start 参数。
语法
以下是 enumerate() 方法的语法:
enumerate(sequence, [start=0])
参数
- sequence -- 一个序列、迭代器或其他支持迭代对象。
- start -- 下标起始位置的值。
扫一扫
337
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
