leetcode 468 验证IP地址是否有效（竟然花费了两个小时）

468. 验证IP地址

中等

222

相关企业

给定一个字符串 queryIP。如果是有效的 IPv4 地址，返回 "IPv4" ；如果是有效的 IPv6 地址，返回 "IPv6" ；如果不是上述类型的 IP 地址，返回 "Neither" 。

有效的IPv4地址 是 “x1.x2.x3.x4” 形式的IP地址。 其中 0 <= xi <= 255 且 xi 不能包含 前导零。例如: “192.168.1.1” 、 “192.168.1.0” 为有效IPv4地址， “192.168.01.1” 为无效IPv4地址; “192.168.1.00” 、 “192.168@1.1” 为无效IPv4地址。

一个有效的IPv6地址 是一个格式为“x1:x2:x3:x4:x5:x6:x7:x8” 的IP地址，其中:

• 1 <= xi.length <= 4
• xi 是一个 十六进制字符串 ，可以包含数字、小写英文字母( 'a' 到 'f' )和大写英文字母( 'A' 到 'F' )。
• 在 xi 中允许前导零。

例如 "2001:0db8:85a3:0000:0000:8a2e:0370:7334" 和 "2001:db8:85a3:0:0:8A2E:0370:7334" 是有效的 IPv6 地址，而 "2001:0db8:85a3::8A2E:037j:7334" 和 "02001:0db8:85a3:0000:0000:8a2e:0370:7334" 是无效的 IPv6 地址。

示例 1：

输入：queryIP = "172.16.254.1"
输出："IPv4"
解释：有效的 IPv4 地址，返回 "IPv4"

示例 2：

输入：queryIP = "2001:0db8:85a3:0:0:8A2E:0370:7334"
输出："IPv6"
解释：有效的 IPv6 地址，返回 "IPv6"

示例 3：

输入：queryIP = "256.256.256.256"
输出："Neither"
解释：既不是 IPv4 地址，又不是 IPv6 地址

提示：

• queryIP 仅由英文字母，数字，字符 '.' 和 ':' 组成。

思路很简单，按照规则进行字符串检测就行了，但是总有想不到的异常，所以就一直在调试。

直接上解答：

class Solution {
    vector<string> split(const string& str, const string& delim) {  
        vector<string> res;  
        if("" == str) return res;  
        //先将要切割的字符串从string类型转换为char*类型  
        char * strs = new char[str.length() + 1] ; //不要忘了  
        strcpy(strs, str.c_str());   
    
        char * d = new char[delim.length() + 1];  
        strcpy(d, delim.c_str());  
    
        char *p = strtok(strs, d);  
        while(p) {  
            string s = p; //分割得到的字符串转换为string类型  
            res.push_back(s); //存入结果数组  
            p = strtok(NULL, d);  
        }  
        delete[] d;
        delete[] strs;
        return res;  
    } 
    bool isValid(char ch)
    {
        if(ch>='0' && ch<='9')
        {
            return true;
        }
        else if(ch>='a' && ch<='f')
        {
            return true;
        }
        else if(ch>='A' && ch<='F')
        {
            return true;
        }
        else
            return false;
    }
public:
    string validIPAddress(string queryIP) {
        int len4=0;
        int len6=0;
        for(auto i:queryIP)
        {
            if(i=='.')
            {
                len4++;
            }
            if(i==':')
            {
                len6++;
            }
        }
        if(len4>0 && len4!=3)
        {
            return "Neither";
        }
        if(len6>0 && len6!=7)
        {
            return "Neither";
        }
        vector<string> ipv4Str=split(queryIP,".");
        if(ipv4Str.size()==4)
        {
            if(queryIP[0]=='.' ||  queryIP[queryIP.size()-1]=='.')
            {
                return "Neither";
            }
            bool ipv4Flag=true;
            for(auto i:ipv4Str)
            {
                 int a=atoi(i.c_str());
                 if(a>255)
                 {
                     ipv4Flag=false;
                     break;
                 }
                 else 
                 {
                     string tem=to_string(a);
                     if(tem!=i)
                     {
                        ipv4Flag=false;
                        break;
                     }
                 }
            }
            if(ipv4Flag)
            {
                return "IPv4";
            }
            else
            {
                return "Neither";
            }
        }
        else
        {
            vector<string> ipv6Str=split(queryIP,":");
            if(ipv6Str.size()==8)
            {
                if(queryIP[0]!=':' && queryIP[queryIP.size()-1]!=':')
                {
                    bool ipv6Flag=true;
                    for(auto i:ipv6Str)
                    {
                        if(i.size()>4)
                        {
                            ipv6Flag=false;
                            break;
                        }
                        else
                        {
                            for(auto j:i)
                            {
                                if(!isValid(j))
                                {
                                    ipv6Flag=false;
                                    break;
                                }
                            }
                        }
                    }
                    if(ipv6Flag)
                    {
                        return "IPv6";
                    }
                    else
                    {
                        return "Neither";
                    }
                }
                else
                {
                    return "Neither";
                }
            }
            else
            {
                return "Neither";
            }
        }
    }
};

虽然代码比较不怎么样，但是时间上100%，验证字符串是否有前导0，使用了转为int之后，再转为字符串，如果两个字符串相等就是没有，否则就是有。同时使用了字符串分割函数，这个分割函数的bug就是如果两个分隔符之间什么都没有，就不会返回数据，这点也需要后续改进。