题解 | 验证IP地址

1、解题思路

1. 区分 IPv4 和 IPv6：如果字符串包含 .，则可能是 IPv4。如果字符串包含 :，则可能是 IPv6。
2. 验证 IPv4：分割字符串为 4 部分，检查每组是否为有效数字（0-255，无前导零）。
3. 验证 IPv6：分割字符串为 8 部分，检查每组是否为有效的 16 进制数（1-4 位，允许大小写字母）。
4. 返回结果：根据验证结果返回 "IPv4"、"IPv6" 或 "Neither"。

2、代码实现

C++

class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 验证IP地址
     * @param IP string字符串 一个IP地址字符串
     * @return string字符串
     */
    string solve(string IP) {
        // write code here
        if (isIPv4(IP)) return "IPv4";
        if (isIPv6(IP)) return "IPv6";
        return "Neither";
    }

  private:
    bool isIPv4(string IP) {
        vector<string> parts = split(IP, '.');
        if (parts.size() != 4) return false;
        for (string part : parts) {
            if (part.empty() || part.size() > 3) return false;
            if (part.size() > 1 && part[0] == '0') return false; // 前导零
            for (char c : part) {
                if (!isdigit(c)) return false;
            }
            int num = stoi(part);
            if (num < 0 || num > 255) return false;
        }
        return true;
    }

    bool isIPv6(string IP) {
        vector<string> parts = split(IP, ':');
        if (parts.size() != 8) return false;
        for (string part : parts) {
            if (part.empty() || part.size() > 4) return false;
            for (char c : part) {
                if (!isxdigit(c)) return false; // 不是16进制字符
            }
        }
        return true;
    }

    vector<string> split(string s, char delimiter) {
        vector<string> res;
        string temp;
        for (char c : s) {
            if (c == delimiter) {
                res.push_back(temp);
                temp.clear();
            } else {
                temp += c;
            }
        }
        res.push_back(temp);
        return res;
    }
};

Java

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 验证IP地址
     * @param IP string字符串 一个IP地址字符串
     * @return string字符串
     */
    public String solve (String IP) {
        // write code here
        if (isIPv4(IP)) return "IPv4";
        if (isIPv6(IP)) return "IPv6";
        return "Neither";
    }

    private boolean isIPv4(String IP) {
        String[] parts = IP.split("\\.", -1);
        if (parts.length != 4) return false;
        for (String part : parts) {
            if (part.isEmpty() || part.length() > 3) return false;
            if (part.length() > 1 && part.charAt(0) == '0') return false;
            for (char c : part.toCharArray()) {
                if (!Character.isDigit(c)) return false;
            }
            int num = Integer.parseInt(part);
            if (num < 0 || num > 255) return false;
        }
        return true;
    }

    private boolean isIPv6(String IP) {
        String[] parts = IP.split(":", -1);
        if (parts.length != 8) return false;
        for (String part : parts) {
            if (part.isEmpty() || part.length() > 4) return false;
            for (char c : part.toCharArray()) {
                if (!Character.isDigit(c) && !(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F')) {
                    return false;
                }
            }
        }
        return true;
    }
}

Python

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 验证IP地址
# @param IP string字符串 一个IP地址字符串
# @return string字符串
#
class Solution:
    def solve(self , IP: str) -> str:
        # write code here
        if self.isIPv4(IP):
            return "IPv4"
        if self.isIPv6(IP):
            return "IPv6"
        return "Neither"
    
    def isIPv4(self, IP: str) -> bool:
        parts = IP.split('.')
        if len(parts) != 4:
            return False
        for part in parts:
            if not part or len(part) > 3:
                return False
            if len(part) > 1 and part[0] == '0':
                return False
            if not part.isdigit():
                return False
            num = int(part)
            if num < 0 or num > 255:
                return False
        return True
    
    def isIPv6(self, IP: str) -> bool:
        parts = IP.split(':')
        if len(parts) != 8:
            return False
        for part in parts:
            if not part or len(part) > 4:
                return False
            for c in part:
                if not (c.isdigit() or c.lower() in 'abcdef'):
                    return False
        return True

3、复杂度分析

• 时间复杂度：O(n)，其中 n 是字符串长度。每个字符最多被处理一次。
• 空间复杂度：O(n)，用于存储分割后的部分。