比较版本号

LeetCode题目链接：165. 比较版本号 - 力扣（LeetCode）

难度：中等

分析

思路

直接通过.切分字符串，遍历数组，直接使用内置函数将字符串转为数字进行比较，如果相等就继续比较，如果不等就直接返回结果

对于版本号长度不等的情况，只需将缺少的项视为0然后正常进行比较就行

点我展开
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Solution {
    public int compareVersion(String version1, String version2) {
        String[] arr1 = version1.split("\\.");
        String[] arr2 = version2.split("\\.");
        int ret = 0;
        for (int i = 0;i < Math.max(arr1.length, arr2.length);i++) {
            // 默认为0
            int x = 0;
            int y = 0;
            // 没有指定版本号的话就不会走这段逻辑，所以就会用0做默认值参与比较
            if (i < arr1.length) {
                x = Integer.parseInt(arr1[i]);
            }
            if (i < arr2.length) {
                y = Integer.parseInt(arr2[i]);
            }
            if (x != y) {
                ret = x > y ? 1 : -1;
                break;
            }
        }

        return ret;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
func compareVersion(version1 string, version2 string) int {
    var (
        slice1 = strings.Split(version1, ".")
        slice2 = strings.Split(version2, ".")
    )
    
    for i := 0;i < len(slice1) || i < len(slice2);i++ {
        x := 0
        y := 0

        if i < len(slice1) {
            // 这里的err需要根据实际情况做异常处理
            x, _ = strconv.Atoi(slice1[i])
        }

        if i < len(slice2) {
            // 这里的err需要根据实际情况做异常处理
            y, _ = strconv.Atoi(slice2[i])
        }

        if x > y {
            return 1
        }
        if x < y {
            return -1
        }
    }

    return 0
}

优化

采用.切分字符串需要使用数组来保存切分的结果来遍历

可以使用双指针直接遍历字符串进行比较

点我展开
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class Solution {
    public int compareVersion(String version1, String version2) {
        int i = 0;
        int j = 0;
        while (i < version1.length() || j < version2.length()) {
            int x = 0;
            int y = 0;

            while(i < version1.length()) {
                if (version1.charAt(i) == '.') {
                    i++;
                    break;
                }
                // 其实也是转成数字进行比较
                x = 10 * x + version1.charAt(i) - '0';
                i++;
            }

            while(j < version2.length()) {
                if (version2.charAt(j) == '.') {
                    j++;
                    break;
                }
                y = 10 * y + version2.charAt(j) - '0';
                j++;
            }

            if (x > y) {
                return 1;
            }
            if (x < y) {
                return -1;
            }
        }

        return 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
func compareVersion(version1 string, version2 string) int {
    var (
        i = 0
        j = 0
    )

    for ;i < len(version1) || j < len(version2); {
        var (
            x = 0
            y = 0
        )
        for ;i < len(version1) && version1[i] != '.';i++ {
            x = 10 * x + int(version1[i] - '0')
        }
        i++;
        for ;j < len(version2) && version2[j] != '.';j++ {
            y = 10 * y + int(version2[j] - '0')
        }
        j++;

        if x > y {
            return 1
        }
        if x < y {
            return -1
        }
    }
    return 0
}

拓展

根据国际主流的惯例，我们使用「语义化版本（Semantic Versioning）」的命名方式，有时简称 SemVer。语义化版本号（以下简称「版本号」）的格式是：<major>.<minor>.<patch>。即使用三位非负整数，以点号.连接。

  • <major>即主版本号，俗称大版本升级。改动到主版本号时，标志着 API 发生了巨大变化，包括但不限于新增特性、修改机制、删除功能， 一般不兼容上一个主版本号。
  • <minor>即次版本号，俗称小版本升级。当我们进行常规的新增或修改功能时，改动次版本号，但是必须是向前兼容的。这也意味着我们不能直接删除某个功能。如若必要，我们可以在修改日志中标记某项功能为「即将删除（Deprecated）」，然后在下一个大版本中将其彻底删除。
  • <patch>即修订号，俗称 bug 修复。顾名思义，如果仅仅为了修复或调整一些小问题，我们就只改动修订号。

参考文章：https://blog.csdn.net/qq_35246620/article/details/78443169

实际开发中，有时也会给版本号后添加-<6位commitID>唯一标识某个版本的提交