监控上网行为软件：基于C++跳表算法的日志检索优化

#include <iostream>
#include <vector>
#include <string>
#include <random>
#include <mutex>
#include <ctime>
// 监控上网行为软件的日志数据结构体
struct NetLog {
    std::string UserID;     // 用户唯一标识
    int64_t Timestamp;      // 访问时间戳（毫秒）
    std::string AccessAddr; // 目标访问地址
    std::string TransDir;   // 传输方向：in/out
    int64_t DataSize;       // 传输字节数（KB）
    // 重载比较运算符，按时间戳排序
    bool operator<(const NetLog& other) const {
        return Timestamp < other.Timestamp;
    }
    bool operator==(const NetLog& other) const {
        // 时间戳与用户ID共同唯一标识一条日志
        return Timestamp == other.Timestamp && UserID == other.UserID;
    }
};
// 跳表节点类
class SkipListNode {
public:
    NetLog logData;
    std::vector<SkipListNode*> forward; // 各层前驱节点指针
    SkipListNode(const NetLog& data, int level) : logData(data), forward(level, nullptr) {}
};
// 跳表类（适配监控上网行为软件日志管理）
class NetLogSkipList {
private:
    int maxLevel;          // 跳表最大层数
    int currentLevel;      // 跳表当前层数
    SkipListNode* head;    // 跳表头节点
    std::mt19937 rng;      // 随机数生成器（确定新节点层数）
    std::mutex slMutex;    // 互斥锁（保证线程安全）
    const double probability = 0.5; // 节点晋升概率
    // 生成新节点的随机层数
    int randomLevel() {
        int level = 1;
        while (rng() % 100 < probability * 100 && level < maxLevel) {
            level++;
        }
        return level;
    }
public:
    // 构造函数
    NetLogSkipList(int maxLvl = 16) : maxLevel(maxLvl), currentLevel(1) {
        // 初始化头节点（日志数据为空）
        NetLog emptyLog = {"", 0, "", "", 0};
        head = new SkipListNode(emptyLog, maxLevel);
        // 初始化随机数生成器
        std::random_device rd;
        rng.seed(rd());
    }
    // 析构函数（释放所有节点）
    ~NetLogSkipList() {
        SkipListNode* current = head;
        while (current != nullptr) {
            SkipListNode* next = current->forward[0];
            delete current;
            current = next;
        }
    }
    // 插入日志数据
    void insert(const NetLog& log) {
        std::lock_guard<std::mutex> lock(slMutex); // 加锁保证线程安全
        std::vector<SkipListNode*> update(maxLevel, nullptr);
        SkipListNode* current = head;
        // 从最上层索引向下查找，记录各层待更新的节点
        for (int i = currentLevel - 1; i >= 0; --i) {
            while (current->forward[i] != nullptr && current->forward[i]->logData < log) {
                current = current->forward[i];
            }
            update[i] = current;
        }
        // 若日志已存在，直接返回
        current = current->forward[0];
        if (current != nullptr && current->logData == log) {
            return;
        }
        // 生成新节点的随机层数
        int newLevel = randomLevel();
        // 若新节点层数超过当前层数，更新上层索引的头节点指针
        if (newLevel > currentLevel) {
            for (int i = currentLevel; i < newLevel; ++i) {
                update[i] = head;
            }
            currentLevel = newLevel;
        }
        // 创建新节点并插入跳表
        SkipListNode* newNode = new SkipListNode(log, newLevel);
        for (int i = 0; i < newLevel; ++i) {
            newNode->forward[i] = update[i]->forward[i];
            update[i]->forward[i] = newNode;
        }
    }
    // 按时间范围查询日志
    std::vector<NetLog> queryByTimeRange(int64_t start, int64_t end) {
        std::lock_guard<std::mutex> lock(slMutex);
        std::vector<NetLog> result;
        SkipListNode* current = head;
        // 定位到起始时间所在的底层节点
        for (int i = currentLevel - 1; i >= 0; --i) {
            while (current->forward[i] != nullptr && current->forward[i]->logData.Timestamp < start) {
                current = current->forward[i];
            }
        }
        // 遍历底层节点，收集时间范围内的日志
        current = current->forward[0];
        while (current != nullptr && current->logData.Timestamp <= end) {
            result.push_back(current->logData);
            current = current->forward[0];
        }
        return result;
    }
    // 获取跳表中日志总数
    int getCount() {
        std::lock_guard<std::mutex> lock(slMutex);
        int count = 0;
        SkipListNode* current = head->forward[0];
        while (current != nullptr) {
            count++;
            current = current->forward[0];
        }
        return count;
    }
};
// 测试主函数
int main() {
    // 初始化监控上网行为软件的日志跳表
    NetLogSkipList logSkipList;
    // 模拟插入6条上网日志
    std::vector<NetLog> testLogs = {
        {"EMP001", 1734249600000, "192.168.1.101:8080", "out", 10240},
        {"EMP002", 1734249900000, "192.168.1.102:9090", "in", 20480},
        {"EMP001", 1734250200000, "192.168.1.103:80", "out", 5120},
        {"EMP003", 1734250500000, "192.168.1.104:443", "in", 15360},
        {"EMP002", 1734250800000, "192.168.1.105:3306", "out", 8192},
        {"EMP004", 1734251100000, "192.168.1.106:8080", "in", 12288}
    };
    for (const auto& log : testLogs) {
        logSkipList.insert(log);
    }
    std::cout << "监控上网行为软件日志总数：" << logSkipList.getCount() << std::endl;
    // 定义查询时间范围：2025-12-15 10:00:00 至 2025-12-15 10:15:00
    int64_t startTime = 1734249600000;
    int64_t endTime = 1734250500000;
    auto queryResult = logSkipList.queryByTimeRange(startTime, endTime);
    std::cout << "\n2025-12-15 10:00:00 至 10:15:00 期间的上网日志：" << std::endl;
    for (const auto& log : queryResult) {
        std::cout << "用户：" << log.UserID 
                  << " | 时间戳：" << log.Timestamp 
                  << " | 地址：" << log.AccessAddr 
                  << " | 方向：" << log.TransDir 
                  << " | 流量：" << log.DataSize << "KB" << std::endl;
    }
    return 0;
}