leetcode-165. 比较版本号
解题思路
-
方法一：先按【点】进行切割版本号，得到一个数组，这里要考虑数组不等长的问题，所以短的要进行补
0操作，然后依次多数组中元素进行比较，当然字符串要转换为整数在进行比较 -
方法二：不切割，使用双指针逐步进行比较，根据点做为前置条件，每个字符转为 ASCII 码，并用
*10来避免前导零和后置零的问题， 双指针步进法 直接对字符串进行操作，这也是处理大数运算的时候的方法。
python版
# 方法一
class Solution:
def compareVersion(self, version1: str, version2: str) -> int:
ver1 = version1.split('.')
ver2 = version2.split('.')
n1, n2 = len(ver1), len(ver2)
# compare versions
for i in range(max(n1, n2)):
i1 = int(ver1[i]) if i < n1 else 0
i2 = int(ver2[i]) if i < n2 else 0
if i1 != i2:
return 1 if i1 > i2 else -1
# the versions are equal
return 0
复杂度：
- 时间复杂度： O(N + M + Max（N+M）) N, M表示字符串长度
- 空间复杂度：O(N + M)，使用了两个数组
ver1和ver2存储两个字符串的块
# 方法二
class Solution:
def compareVersion(self, version1: str, version2: str) -> int:
p1, p2 = 0, 0
len1, len2 = len(version1), len(version2)
end = max(len1, len2)
while (p1 < end or p2 < end):
v1, v2 = 0, 0
while (p1 < len1 and version1[p1] != '.'):
v1 = v1 * 10 + ord(version1[p1]) - 48 # '0' Asiico = 48
p1 += 1
while (p2 < len2 and version2[p2] != '.'):
v2 = v2 * 10 + ord(version2[p2]) - 48
p2 += 1
if v1 != v2:
return 1 if v1 > v2 else -1
p1 += 1
p2 += 1
return 0
复杂度：
- 时间复杂度： O(Max（N+M）) N, M表示字符串长度
- 空间复杂度：O(1)，没有使用额外的数据结构
golang版本
// If (a > b ? a : b).(type)
func If(condition bool, trueVal, falseVal interface{}) interface{} {
if condition {
return trueVal
}
return falseVal
}
func compareVersion(version1 string, version2 string) int {
p1, p2 := 0, 0
len1, len2 := len(version1), len(version2)
end := If(len1 > len2, len1, len2).(int)
for p1 < end || p2 < end {
var v1, v2 int
for p1 < len1 && version1[p1] != '.' {
v1 = v1*10 + int(version1[p1]-'0')
p1++
}
for p2 < len2 && version2[p2] != '.' {
v2 = v2*10 + int(version2[p2]-'0')
p2++
}
if v1 > v2 {
return 1
} else if v1 < v2 {
return -1
}
p1++
p2++
}
return 0
}
go中用到的相关知识点复习
字符转数字
组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（’）包裹起来
Go语言的字符有两种形式
- uint8类型， 或者叫byte型，代表ASCII码对应的字符
- rune类型，表示一个UTF-8字符，rune实际是一个int32， Go 使用了特殊的 rune 类型来处理 Unicode
字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。
var c rune='a'
var i int =98
i1:=int(c)
fmt.Println("'a' convert to",i1)
c1:=rune(i)
fmt.Println("98 convert to",string(c1))
//string to rune
for _, char := range []rune("世界你好") {
fmt.Println(string(char))
}
字符串的修改
要修改字符串，需要先将其转换成[]rune或者[]byte，修改完成后再转换为string,无论哪种转换，都会重新分配内存，并复制字节数组。
func changeString() {
s1 := "big"
// 强制类型转换
byteS1 := []byte(s1)
byteS1[0] = 'p'
fmt.Println(string(byteS1))
s2 := "中文"
runeS2 := []rune(s2)
runeS2[1] = "国"
fmt.Println(string(runeS2))
}
go实现三元运算符
go语言没有三元运算符的表达式，为什么要去写这个三元运算符，也是因为go中没有min\max这个常用的函数，golang中有math.Max(float64, float64) float64是对float64类型的比较，由于float64类型要处理infinity和not-a-number这种值，而他们的处理非常复杂，一般用户没有能力，所有go需要为用户提供系统级别的解决办法。
- 因为Go不支持运算符重载，因此需要先将
a<b在函数外转换为bool条件 - Go不支持泛型，只能用
interface{}模拟 - 返回的类型安全需要用户自己保证，
.(type)的类型必须匹配 interface{}是运行时泛型，性能没有编译时泛型高
golang还是有优势呀
