一种基于跳表结构的 Java 如何控制局域网上网算法探索

import java.util.Random;
// 访问权限枚举
enum AccessPermission {
    ALLOW, DENY
}
// 跳表节点类
class SkipListNode {
    Long ipKey; // 终端IP转换的键（如将IPv4转为32位整数）
    AccessPermission permission; // 访问权限
    SkipListNode[] forward; // 各层级的后继节点
    public SkipListNode(Long ipKey, AccessPermission permission, int level) {
        this.ipKey = ipKey;
        this.permission = permission;
        this.forward = new SkipListNode[level + 1]; // 层级从0开始
    }
}
// 适用于局域网访问控制的跳表实现
public class LanAccessSkipList {
    private static final int MAX_LEVEL = 16; // 最大索引层级
    private static final double P = 0.5; // 节点晋升概率
    private int level; // 当前跳表的最高层级
    private SkipListNode head; // 头节点（哨兵节点）
    private Random random; // 用于生成晋升概率的随机数
    // 初始化跳表
    public LanAccessSkipList() {
        level = 0;
        head = new SkipListNode(null, null, MAX_LEVEL);
        random = new Random();
    }
    // 生成节点的随机层级
    private int randomLevel() {
        int l = 0;
        while (random.nextDouble() < P && l < MAX_LEVEL) {
            l++;
        }
        return l;
    }
    // 插入局域网访问规则（IP-权限映射）
    public void insert(Long ipKey, AccessPermission permission) {
        SkipListNode[] update = new SkipListNode[MAX_LEVEL + 1]; // 记录各层级需更新的节点
        SkipListNode current = head;
        // 从最高层级向下查找，定位插入位置
        for (int i = level; i >= 0; i--) {
            while (current.forward[i] != null && current.forward[i].ipKey < ipKey) {
                current = current.forward[i];
            }
            update[i] = current;
        }
        // 若IP已存在，更新权限
        current = current.forward[0];
        if (current != null && current.ipKey.equals(ipKey)) {
            current.permission = permission;
            return;
        }
        // 生成新节点的层级
        int newLevel = randomLevel();
        // 若新层级高于当前最高层级，更新头节点的forward数组
        if (newLevel > level) {
            for (int i = level + 1; i <= newLevel; i++) {
                update[i] = head;
            }
            level = newLevel;
        }
        // 创建新节点并插入跳表
        SkipListNode newNode = new SkipListNode(ipKey, permission, newLevel);
        for (int i = 0; i <= newLevel; i++) {
            newNode.forward[i] = update[i].forward[i];
            update[i].forward[i] = newNode;
        }
    }
    // 查询指定IP的访问权限（核心方法，支撑如何控制局域网上网的规则匹配）
    public AccessPermission search(Long ipKey) {
        SkipListNode current = head;
        // 从最高层级向下查找
        for (int i = level; i >= 0; i--) {
            while (current.forward[i] != null && current.forward[i].ipKey < ipKey) {
                current = current.forward[i];
            }
        }
        // 定位到最底层，判断是否存在目标IP
        current = current.forward[0];
        if (current != null && current.ipKey.equals(ipKey)) {
            return current.permission;
        }
        // 未找到时默认返回允许（可根据实际需求调整为禁止）
        return AccessPermission.ALLOW;
    }
    // 测试跳表在局域网访问控制中的应用
    public static void main(String[] args) {
        LanAccessSkipList accessSkipList = new LanAccessSkipList();
        // 模拟插入局域网访问规则（IP转换为Long：如192.168.1.100 -> 3232235876）
        accessSkipList.insert(3232235876L, AccessPermission.DENY); // 禁止192.168.1.100上网
        accessSkipList.insert(3232235877L, AccessPermission.ALLOW); // 允许192.168.1.101上网
        accessSkipList.insert(3232235878L, AccessPermission.DENY); // 禁止192.168.1.102上网
        // 模拟查询终端IP的访问权限，支撑如何控制局域网上网的决策
        Long testIp1 = 3232235876L; // 192.168.1.100
        Long testIp2 = 3232235879L; // 192.168.1.103（未配置规则）
        System.out.println("IP " + testIp1 + " 访问权限：" + accessSkipList.search(testIp1));
        System.out.println("IP " + testIp2 + " 访问权限：" + accessSkipList.search(testIp2));
        // 模拟更新规则：允许192.168.1.100上网
        accessSkipList.insert(3232235876L, AccessPermission.ALLOW);
        System.out.println("更新后，IP " + testIp1 + " 访问权限：" + accessSkipList.search(testIp1));
    }
}