比较版本号

public int compare (String version1, String version2) {
        String[] v1 = version1.split("\\.");
        String[] v2 = version2.split("\\.");
        int n1,n2;
        for(int i=0;i<v1.length || i<v2.length;i++){
            n1 = i >= v1.length ? 0 : Integer.parseInt(v1[i]);
            n2 = i >= v2.length ? 0 : Integer.parseInt(v2[i]);
            if(n1 == n2) continue;
            return n1 > n2 ? 1 : -1;
        }
        return 0;
    }

    public int[] trans(String version){
        String[] s = version.split("\\.");
        int[] ss = new int[1000];
        for(int i=0;i<s.length;i++){
            ss[i] = Integer.parseInt(s[i]);
        }
        return ss;
    }

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 比较版本号
     * @param version1 string字符串
     * @param version2 string字符串
     * @return int整型
     */
    public int compare (String version1, String version2) {
        // write code here

        // 算法的时间复杂度O(N)，空间复杂度O(N)

        // 1.先对两个版本字符串按照.分割成字符串数组
        // 注意！正则中应该填入"\\."而非"."
        String[] split1 = version1.split("\\.");
        String[] split2 = version2.split("\\.");

        // 2.针对split中的每个元素，将其转化成为int类型比较
        int max = Math.max(split1.length, split2.length);
        for (int i = 0; i < max; i++) {
            // 2.1 先给每个int赋值0，以防该字符串的下标已经越界
            int i1 = 0;
            int i2 = 0;
            // 2.2 若不越界，则赋对应的值
            if (i < split1.length) {
                i1 = Integer.parseInt(split1[i]);
            }
            if (i < split2.length) {
                i2 = Integer.parseInt(split2[i]);
            }
            // 2.3 若产生大小关系，则直接返回对应的结果值
            if (i1 > i2) {
                return 1;
            }
            if (i1 < i2) {
                return -1;
            }
            // 2.4 若相等，则继续下一轮
        }
        // 3.两个版本号相等，返回0
        return 0;
    }
}

public int compare (String version1, String version2) {
    // write code here
    if (version1 == null && version2 == null) return 0;
    else if (version1 != null && version2 == null) return 1;
    else if (version2 != null && version1 == null) return -1;  

    String[] arr1 = version1.split("\\.");
    String[] arr2 = version2.split("\\.");
    int cm = 0;
    int maxIdx = arr1.length > arr2.length ? arr1.length : arr2.length;
    for(int i=0;i < maxIdx;i++) {
        int a, b;
        if (i >= arr1.length) a = 0;
        else a = Integer.parseInt(arr1[i]);

        if (i >= arr2.length) b = 0;
        else b = Integer.parseInt(arr2[i]);

        cm = Integer.compare(a, b);
        if (cm != 0) return cm;
    }

    return cm;
}

public int compare (String version1, String version2) {
        // 用双指针遍历两个字符串
        //截取.之前的数字，  
        //比较数字大小，返回1、-1；如果全部比较完都没有结果，返回0
        //关键在于处理前导0：加在前面数字乘10的后面   010-->10   00010-->10
        int i=0;
        int j=0;
        while(i<version1.length()||j<version2.length()){
            long num1=0;
            long num2=0;
            //处理version1
            while(i<version1.length()&&version1.charAt(i)!='.'){//按.截取数字
                int tmp1=version1.charAt(i)-'0';
                num1=num1*10+tmp1;
                i++;
            }
            i++;//跳过.

            //处理version2
            while(j<version2.length()&&version2.charAt(j)!='.'){
                int tmp2=version2.charAt(j)-'0';
                num2=num2*10+tmp2;
                j++;
            }
            j++;//跳过.
            //比较数字
            if(num1>num2) return 1;
            if(num1<num2) return -1;
        }
        return 0;
    }

public int compare (String version1, String version2) {
    // write code here
    String[] v1 = version1.split("\\.");
    String[] v2 = version2.split("\\.");
    int v1val, v2val;
    int k = v1.length < v2.length ? v2.length : v1.length;
    for (int i = 0; i < k; i++) {
        v1val = v1.length <= i ? 0 : Integer.parseInt(v1[i]);
        v2val = v2.length <= i ? 0 : Integer.parseInt(v2[i]);
        if(v1val < v2val){
            return -1;
        }else if(v1val > v2val){
            return 1;
        }
    }
    return 0;
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 比较版本号
     * @param version1 string字符串
     * @param version2 string字符串
     * @return int整型
     */
    public int compare (String version1, String version2) {
        // write code here
        //保存每个版本号的数字
        ArrayList<String> ves1 = new ArrayList<>();
        ArrayList<String> ves2 = new ArrayList<>();
        String str = "";
        //保存version1的数字到ves1集合
        for (int i = 0; i < version1.length(); i++) {
            str += version1.charAt(i);
            if (version1.charAt(i) == '.') {
                ves1.add(str.substring(0, str.length()-1));
                str = "";
            }
            if (i == version1.length() - 1 && !str.isEmpty()) {
                ves1.add(str);
            }
        }
        //保存version2的数字到ves2集合
        str="";
        for (int i = 0; i < version2.length(); i++) {
            str += version2.charAt(i);
            if (version2.charAt(i) == '.') {
                ves2.add(str.substring(0, str.length()-1));
                str = "";
            }
            if (i == version2.length() - 1 && !str.isEmpty()) {
                ves2.add(str);
            }
        }
        //保证二者size相同
        if(ves1.size()>ves2.size()){
            getBalance(ves1,ves2);
        }else{
            getBalance(ves2,ves1);
        }
        //进行对前导零的优化
        optimize(ves1);
        optimize(ves2);
        //进行比较
        for(int i=0;i<ves1.size();i++){
            Integer num1=Integer.valueOf(ves1.get(i));
            Integer num2=Integer.valueOf(ves2.get(i));
            if(num1>num2){
                return 1;
            }else if(num1<num2){
                return -1;
            }
        }
        return 0;
    }
    //进行优化前导零
    public void optimize(ArrayList<String> ves){
        for(int i=0;i<ves.size();i++){
            String str=ves.get(i);
            //如果碰到前导零，将该前导零放到最后一位，保证ves1和ves2的size相等
            if(i!=0&&str.equals("0")){
                ves.remove(i);
                ves.add("0");
            }
        }
    }
    //默认左边size>右边size
    //进行size相等调整
    public void getBalance(ArrayList<String> ves1,ArrayList<String> ves2){
        while(ves1.size()!=ves2.size()){
            ves2.add("0");
        }
    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 比较版本号
     * @param version1 string字符串
     * @param version2 string字符串
     * @return int整型
     */
    public int compare (String version1, String version2) {
        // write code here
        int result = 0;
        String[] ver1Arr = version1.split("\\.");
        String[] ver2Arr = version2.split("\\.");
        int length = ver1Arr.length >= ver2Arr.length ? ver1Arr.length : ver2Arr.length;
        //应该从后往前比较
        for (int i = length-1; i >= 0; i--) {

            Integer ver1Num = ver1Arr.length-1 < i?0:Integer.valueOf(ver1Arr[i]);
            Integer ver2Num = ver2Arr.length-1 < i?0:Integer.valueOf(ver2Arr[i]);
            int compareResult = ver1Num.compareTo(ver2Num);
            if (compareResult != 0) {
                result = compareResult;
            }

        }
        return result;
    }
}

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 比较版本号
     * @param version1 string字符串 
     * @param version2 string字符串 
     * @return int整型
     */
    public int compare (String version1, String version2) {
        // write code here

        String[]arr1=version1.split("[.]");//数字小数点的正则表达式为 "[.]"
        String[]arr2=version2.split("[.]");
        int max=(arr1.length>arr2.length)?arr1.length:arr2.length;
        for(int i=0;i<max;i++){           
            int num1=(i>arr1.length-1)?0:Integer.parseInt(arr1[i]);
            int num2=(i>arr2.length-1)?0:Integer.parseInt(arr2[i]);
            if(num1>num2){
                return 1;
            }
            if(num1<num2){
                return -1;
            }
        }
        return 0;
    }
} 

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 比较版本号
     * @param version1 string字符串
     * @param version2 string字符串
     * @return int整型
     */
    public int compare (String version1, String version2) {
        // write code here
        if (isBlank(version1) || isBlank(version2)) {
            return -1;
        }
       String[] str1 = version1.split("\\.");
       String[] str2 = version2.split("\\.");
       int len1 = str1.length;
       int len2 = str2.length;
       int max = Integer.max(len1, len2);
       int i = 0;
       while(i < max) {
           int i1 = i < len1 ? Integer.parseInt(str1[i]) : 0;
           int i2 = i < len2 ? Integer.parseInt(str2[i]) : 0;
           if (i1 > i2) {
               return 1;
           }else if (i1 < i2) {
               return -1;
           }
           i++;
       }
       return 0;
    }

    private boolean isBlank(String str) {
        return str == null || str.length() == 0;
    }
}