【学习笔记】在刷题前--刷题中常见事项
刷题中常见事项
目录
java
字符和字符串
//String的常用方法：
//1.将字符串转为字符数组；
char[] strArr = s.toCharArray();
//2.如果有分隔符，可以将其分割转化为字符串数组；
String[] strArr = s.spilt(",") //根据逗号分割；注意这个是String数组；
String[] strArr = s.split("\\s+"); //根据空格分割，正则表达式，可以使一个或多个空格；
//3.获取第i个位置的字符；
char c = s.charAt(i);
//4.将字符数组转化为字符串；
String str = String.valueOf(char[] ch);
//5.连接字符串（数组或集合）；
String str = String.join("-", arr); //以-连接数组或者是集合；
//6.去掉首尾空格；
String str = s.trim(); //新建了一个字符串；
//7.指定子串；
String str = s.substring(start,end); //指定开始和结束的子串，前开后闭；
//将字符数组转化为字符串：
//1.直接在构造时转换；
char[] data = {'a','b','c'};
String str = new String(data); //"abc";
String str = new String(data, 0, 1) //"a",从0开始读，读一个字符；
//2.方法转换
String.valueOf(char[] ch);
//将字符串转为字符数组：
char[] ch = str.toCharArray();
//将整形转为字符串；
String str = Integer.toString(n);
//将字符串转为整形；
int n = Integer.parseInt(str);
//StringBuilder常用方法：
//字符串经常会用到拼接，但是拼接很繁琐，
//而且每次拼接都会创建一个String，既耗时，又浪费空间；
//所以可以用StringBuffer和StringBuilder来做：
StringBuilder strB = new StringBuilder();
strB.append("hello"); //字符串拼接；
strB.chatAt(index); //获取index处的字符；注意千万不能用StrB[index]不是数组！
strB.setCharAt(index,str); //将第i个字符串替换为str；
strB.deleteChatAt(index); //删除指定位置的元素；
strB.toString(); //返回String类型；
java中关于for循环；
//普通for循环：
for（int i = 0； i < nums.length; i++){
//多用于知道长度而且需要知道索引的时候；
}
//增强for循环；
for(int i : nums){
//多用于不知道有多长的时候，比如set，list等，或者不关心索引的时候；
}
python
python中正确的创建二维数组：
matrix = [[None]*m for _ in range(n)] # 这才是正确的创建方法
matrix[0][1] = 1
python中链表和list的相互转化
在做链表的题时，可以将链表转为list进行处理，这样就可以利用list的各种方法，比如排序啊什么的，然后最后再把list转为链表就可以了
def list2linkedlist(l):
head = None #防止是空列表
if l:
head = ListNode(l[0])
cur = head
for i in range(1, len(l)):
cur.next = ListNode(l[i])
cur = cur.next
return head
------------------
def linkedlist2list(head):
ret = []
while head:
ret.append(head.val)
head = head.next
return ret
python中数学的常用操作
2/3 #正常除法：0.66666667，所得结果都为float，即使整除也一样
8//3 #取整(地板除）： 2，所得结果为int
round(4.2) #四舍五入 4
round(4.222,1) #第二个参数是保留小数位数：4.2
> 实际上，round并不总是能够完全的四舍五入，为什么呢？，因为在python里，数值并不总是精确存储的
例如，1.115，if使用decimal(1.115)来表示一下的话，是1.1149999999999999911182158029987476766109466552734375,所以在四舍五入保留两位的时候肯定就是1.11了；
所以round在执行的时候，比如要保留两位小数，那就看第三位，假设为c
if c < 5:那直接舍去；
if c > 5:那直接进位；
if c = 5: 这时候要看整个数字是不是精确存储(可以使用decimal(num)打印看一下是不是精确存储；
if 精确存储-》奇进偶舍（c的前1位也就是第2位小数是奇数，那直接进位，if是偶数，那就舍去c）
if 不精确存储 -》直接截断，所以值肯定会变小
# decimal模块
# decimal模块传入的参数尽量是整型和字符串，这样才能保证精确
from decimal import Decimal
print(1.2+2.1 == 3.3) # 这是不一定相等的，原因就是不精确表示，答案可能是3.300000001
print(Decimal('1.2')+Decimal('2.1') == Decimal('3.3')) # True
import decimal
decimal.getcontext().rounding=decimal.ROUND_HALF_UP # 四舍五入
c = decimal.Decimal('2.135').quantize(decimal.Decimal('0.00') # 2.14 保留两位小数；
decimal.getcontext().rounding=decimal.ROUND_HALF_DOWN # 四舍五不入
c = decimal.Decimal('2.135').quantize(decimal.Decimal('0.00') # 2.13 保留两位小数；
# math模块
math.ceil(4.2) #向上取整 5
math.floor(4.2) #向下取整 4
math.trunc(4.4) #截取整数位 4
a = math.gcd(6, 8) #最大公约数 2
6*8/a #最小公倍数 24.0
python中的排序
对一个可迭代序列进行排序有两种方法，一个是sort方法，一个是sorted函数
lst.sort() # lst可以是列表，元祖，字典，字符串等，默认按照升序排序，可以设置reverse = True来进行降序排列；
# 还有一个关键参数key，其可以指定按照什么规则进行排序，例如
lst.sort(key = len) #按照列表中元素的长度进行排序
lst.sort(key = lambda x : x[0]） #比如lst的元素还是列表，这就是按照元素的第一个升序进行排序
lst.sort(key = lambda x : (-x[0],x[1])) # lst的元素还是列表，按照元素的第一个降序排序，if第一个相等，再按照第二个升序排序
lst1 = sorted(lst) #和sort方法基本一致，唯一区别是有返回值，对原始序列不做修改
# 例如字典是这种类型：
hashtable = {'a': [2,2,3,4], 'b':[0,1,3,4], 'c':[3,2,3,4]}
print(hashtable.items()) #这里返回的是列表，列表里是元祖： [('a', [2, 2, 3, 4]), ('b', [0, 1, 3, 4]), ('c', [3, 2, 3, 4])]
sort_list = sorted(hashtable.items(), key = lambda x : (x[1][1],x[1][0])) #按value值的索引1位置排序，if相等再按索引0位置排序，注意最后返回的是列表
print(sort_list) # [('b', [0, 1, 3, 4]), ('a', [2, 2, 3, 4]), ('c', [3, 2, 3, 4])]
#对字符串列表使用sort进行排序时，默认是按照ascii码进行排序，所以if是字母，则大写字母是在小写字母前面。
spam = ['a', 'z', 'A', 'Z']
spam.sort() #['A','Z','a','z']
所以可以指定sort函数后面的关键字key，这个key的值是一个函数
spam.sort(key=str.lower) #['a','A','z','Z']
这个就是用这个函数执行这个list的所有元素，然后进行排序；再比如，if想要按照每个元素的长度进行排序
spam.sort(key=len) #按照元素长度进行排序
s1 = ['1','12','21',2]
s1.sort() #['1','12','2','21'] 并不是从大到小，所以可以
s1.sort(key=int) #转换为整数进行排序，if再指定reverse=True则可以降序排序
python中字符串的常用操作
#字符串和数字的转换：
num = int('123') #字符串转为数字
s1 = str(123) #数字转为字符串‘123’
在python中不能对字符直接进行减操作：例如 'a'-'b'
而是需要将其用ascii码进行相减： ord('a')-ord('b') #ord为将制定字符转为ascii码
#字符串常用方法
name = "xiao ming"
i_count = name.count("i") #统计某字符出现的次数：2
name = ['aa','bb','cc','dd']
'--'.join(name) #连接元素，以'--'进行连接，name必须为字符串序列！
aa--bb--cc--dd
name.replace(old, new[,max]) #用new字符来代替old字符，最多不超max次，max不指定就是全部替换，返回新的字符串
name.rjust(12,'0') #右对齐，向左填充0至12个字符 '000xiao ming'
name.ljust(11,'1') #左对齐，向右填充1至11个字符 'xiao ming11'； 都是返回新字符串，原字符串不发生改变；默认是以空格填充
name.zfill(11) #右对齐，向左填充0至11个字符 '00xiao ming'
name.split('i') #以字符i进行分割,返回字符串数组，默认是所有的空字符，例如空格等
# ['x','ao m','ng']
name.splitlines() #以换行(\n)进行分割
python自带的split只能指定一个分隔符，需要使用多个分隔符时，要用re.split
print(re.split(r'i|o|g', name) #['x','a',' m','n','']
ming_index = name.find("ming") #查找字符串在原始字符串中的位置，返回索引：5
#其后可以指定参数，分别为start和end，在指定范围内[start,end)查找，默认为0和原始字符串的长度，if没找到返回-1
name.islower() #判断是否全部为小写
name.isupper() #判断是否全部为大写
name_upper = name.upper() #全部变为大写
name_lower = name.lower() #全部变为小写，但是原始字符串不变!!!
name.capitalize() #将字符串首字母变为大写
name.endswith("ming") #判断是否以某字符串结尾
name.isalnum() #判断是否只由字母和数字组成
name.isalpha() #判断是否只由纯字母组成
name.isdigit() #判断是否只由数字组成
name.strip() #默认去除头尾的字符(包括包括\n、\r、\t、' '，即：换行、回车、制表符、空格)
#相对应的就是lstrip()和rstrip()分别是去头和去尾，这都是返回副本，原始字符串本身不会发生变化
#当然也可以指定元素：
name.lstrip("ab") #这时候就是删除头部的ab，注意这时候是把ab当成了两个字符，和ab的顺序无关，并且这时候空格什么的都不会被删除了；
# if要删除字符串中间的空字符：
''.join(name.split())
#python中不允许直接修改字符串
name[2] = "h" #这是不对的，因为字符串是不可变类型，所以改变字符串需要新建一个新的字符串
1.可以将字符串转为列表进行修改
s1 = list(s) #转为列表
s1[2] = "h" #进行修改
s = ''.join(s1)#用空串进行连接生成新的字符串
2.使用上面的replace方法
#对字符串列表使用sort进行排序时，默认是按照ascii码进行排序，所以if是字母，则大写字母是在小写字母前面。
spam = ['a', 'z', 'A', 'Z']
spam.sort() #['A','Z','a','z']
所以可以指定sort函数后面的关键字key，这个key的值是一个函数
spam.sort(key=str.lower) #['a','A','z','Z']
这个就是用这个函数执行这个list的所有元素，然后进行排序；再比如，if想要按照每个元素的长度进行排序
spam.sort(key=len) #按照元素长度进行排序
s1 = ['1','12','21',2]
s1.sort() #['1','12','2','21'] 并不是从大到小，所以可以
s1.sort(key=int) #转换为整数进行排序，if再指定reverse=True则可以降序排序
python中collections中的计数器Counter
from collections import Counter
c = Counter("abcac") #参数是一个序列，例如list，string等，返回一个字典，key是元素，value是数值
c['a'] # 2
c['e'] # 不存在的返回0，而不是报错
python正则表达式
re.findall
import re
re.findall(规则，字符串) #返回一个字符串序列，if都没找到，返回一个空列表
下面是常用的一些语法规则：
\d :匹配0-9一个数字
\D :表示匹配非数字，等价于[^0-9]
\w :匹配字母和数字，等价于[a-zA-Z0-9]
\W :匹配非字母和数字，等价于[^a-zA-Z0-9]
\b :表示一个单词的边界，比如常见的空格
\s :匹配任何空白字符
s = 'abc abcde bc bcd'
re.findall(r'\bbc\b',s) #['bc']
re.findall(r'\sbc\s',s) #[' bc ']
+ :+号表示匹配前面的字符一次以上
* :*号表示匹配前面的字符0次以上
? :?号表示匹配前面字符0次或1次
$ :以前面的符号结尾
. ：.表示任意字符
{2} ：大括号表示匹配2次，{2,5}至少比配两次，最多匹配5次
[] :大括号表示一个字符集合：
[abc123]表示这里面任意一个字符都满足；
[a-zA-Z]表示匹配所有字母；
if在大括号里有^，则表示取非：[^a-zA-Z]表示不匹配所有英文字母
| :表示只要满足一个就可以
[a-zA-Z]|[0-9]表示字母和数字都可以，等价于[a-zA-Z0-9]
#要注意正则表达式中的括号
rel1 = r'\d{2}[a-z]{1}' #['24k', '43l'] 匹配整个表达式的值，返回字符串列表
rel2 = r'(\d{2})[a-z]{1}' #['24', '43'] 先整个表达式匹配，匹配完成后再匹配括号里的内容，返回字符串列表
rel3 = r'((\d{2})[a-z]{1})' #[('24k', '24'), ('43l', '43')] 先匹配，然后逐个括号再进行匹配。列表里放的是元祖，元祖的对象分别是第一个括号匹配到的内容，第二个括号匹配到的内容
str1 = 'sdjaksj12324kdjk43le1'
print(re.findall(rel, str1))
#其次要注意匹配过的东西就不会再次尝试匹配了，只会一直往后走：
import re
rel = r'[0-9]{2}-[0-9]{2}'
str = '01-02-03-04-05-06-07'
str1 = re.findall(rel, str)
print(str1) # ['01-02', '03-04', '05-06']，答案不会说是01-02,02-03，前面匹配上了，只会从后面再重新开始
re.match
import re
re.match(规则， 字符串）
# 它的特点是只从起始位置开始匹配，if起始就匹配不上就直接返回None，匹配成功则返回第一个匹配成功的；不会返回所有
m = re.match('(\w\w\w)-(\d?)', 'abc-123') # 这时候的m并不是要的结果，而是一个re.match的对象；
print(m.group()) # abc-1
print(m.groups()) # ('abc', '1') 返回的是各个组，括号是一个组，返回一个元祖；
print(m.group(0)) # 返回全部字符串 abc-1，0和group一样
print(m.group(1)) # 返回分组的第一个 abc，从1开始
print(m.group(2)) # 1
re.search
和re.match基本一样，唯一区别就是不再从起始位置开始匹配，而是扫描整个字符串，返回第一个匹配成功的；
python中range和random
range(start, stop, step) # 生成一个序列
range(x) # 生成[0,x)的整数序列
range(x, y) # 生成[x, y)的整数序列，注意x必须小于y
range(x, y, z) # 生成序列，按照x+z去生成，所以if步长是正的，那就是1,2,3,4； if是步长是负的，那就得是range(4, 1, -1)： # 4,3,2，
import random #必须引入模块
random.randint(1,10) #生成[1,10]范围内的整数，左闭右闭
random.random() #生成[0,1)范围内的实数
random.uniform(1.1, 5,4) #生成[1,1,5.4]内的实数
random.choice('xulie') #在序列中随机获取一个元素
random.randrange(1, 100, 2) #间隔为2，其实就是1到100的随机奇数
random.shuffle(xulie) #随机打乱
python中filter函数的用法
filter函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新的列表
filter(function, iterable)
序列中的每个元素作为参数传递给function，返回true或false，将返回true的元素放到新列表中。
#筛选出序列为奇数的元素
def is_odd(n):
return n%2 == 1
lst1 = filter(is_odd, [1,2,3,4])
python中二分查找函数bisect
import bisect #只适用于有序
arr = [2,2,3,4,5]
i = bisect.bisect_left(arr,2) #返回该插入的位置，if相等，返回最左边：0
i = bisect.bisect_right(arr,2.5) #2
# 注意上面并没有插入
arr.insert(i, 2.5) # 找到位置后再插入
bisect.insort_left(arr,2) # 直接真正插入，[2,2,2,3,4,5]
python中进制的转换
int('11', 16) #将16进制转为十进制，前面是十六进制字符串，后者指明是几进制，结果是int 17
int('0010', 2) #二进制转为十进制， 2；其他都一样
----------
hex(17) #十进制转为十六进制，结果为一个字符串“0x11”
bin(10) #十进制转为二进制，结果为一个字符串“0b1010”
oct(11) #十进制转为八进制，结果为一个字符串“0o13”
通用
常见的ascii值
- 空格：\n :32
- 数字0-9: 48-57
- A-Z：65-90
- a-z: 97-122
关于排序好的数组；
排序好的数组有以下几种常见的处理方法：
- 1.二分查找：二分查找的使用前提就是数组必须是有序的，这样才能每次取中间值去逼近；二分查找总结
- 2.首尾双指针：首尾双指针也常常用在排序数组上，尤其是涉及到两个数之和时，因为如果和大了或者小了可以去移动首或尾指针；
