局域网员工电脑监控软件的 C++ 哈希表进程追踪算法

#include <iostream>
#include <string>
#include <vector>
#include <cstdint>
using namespace std;
// 进程数据结构体（存储单进程信息）
struct ProcessData {
    uint32_t pid;          // 进程ID
    string name;            // 进程名称
    float cpuUsage;         // CPU占用率(%)
    uint64_t memoryUsage;   // 内存占用(KB)
};
// 哈希表节点（存储终端IP对应的进程列表）
struct HashNode {
    string ip;                      // 终端IP（键）
    vector<ProcessData> processes;  // 进程列表（值）
    HashNode* next;                 // 链表指针（解决冲突）
    HashNode(string ipAddr) : ip(ipAddr), next(nullptr) {}
};
// 哈希表类（适配局域网员工电脑监控软件）
class ProcessHashTable {
private:
    vector<HashNode*> table;    // 哈希表数组
    uint32_t capacity;           // 哈希表容量
    uint32_t size;               // 当前存储的终端数量
    const float loadFactor = 0.7;// 负载因子阈值
    // 哈希函数：将IP转换为哈希地址
    uint32_t hashFunction(const string& ip) {
        // IP转32位整数（如192.168.1.101 → 0xC0A80165）
        uint32_t ipInt = 0;
        uint32_t segment = 0;
        int shift = 24;
        for (char c : ip) {
            if (c == '.') {
                ipInt |= (segment << shift);
                segment = 0;
                shift -= 8;
            } else {
                segment = segment * 10 + (c - '0');
            }
        }
        ipInt |= segment;
        // 分段取余+异或运算
        uint32_t addr = ipInt % capacity;
        return addr ^ (ipInt & 0xFF); // 与IP后8位异或
    }
    // 扩容函数
    void resize() {
        uint32_t newCapacity = capacity * 2;
        vector<HashNode*> newTable(newCapacity, nullptr);
        // 重新映射所有节点
        for (uint32_t i = 0; i < capacity; i++) {
            HashNode* node = table[i];
            while (node != nullptr) {
                HashNode* nextNode = node->next;
                uint32_t newAddr = hashFunction(node->ip) % newCapacity;
                // 插入新表
                node->next = newTable[newAddr];
                newTable[newAddr] = node;
                node = nextNode;
            }
        }
        table.swap(newTable);
        capacity = newCapacity;
    }
public:
    // 构造函数（初始容量128）
    ProcessHashTable() : capacity(128), size(0) {
        table.resize(capacity, nullptr);
    }
    // 插入/更新终端进程数据
    void insertOrUpdate(const string& ip, const vector<ProcessData>& processes) {
        // 检查是否需要扩容
        if ((float)size / capacity >= loadFactor) {
            resize();
        }
        uint32_t addr = hashFunction(ip);
        HashNode* node = table[addr];
        // 查找IP是否已存在，存在则更新进程数据
        while (node != nullptr) {
            if (node->ip == ip) {
                node->processes = processes;
                return;
            }
            node = node->next;
        }
        // 不存在则新建节点（头插法）
        HashNode* newNode = new HashNode(ip);
        newNode->processes = processes;
        newNode->next = table[addr];
        table[addr] = newNode;
        size++;
    }
    // 查询终端进程数据
    vector<ProcessData>* query(const string& ip) {
        uint32_t addr = hashFunction(ip);
        HashNode* node = table[addr];
        while (node != nullptr) {
            if (node->ip == ip) {
                return &(node->processes); // 返回进程列表指针
            }
            node = node->next;
        }
        return nullptr; // 未找到该终端
    }
    // 析构函数（释放内存）
    ~ProcessHashTable() {
        for (uint32_t i = 0; i < capacity; i++) {
            HashNode* node = table[i];
            while (node != nullptr) {
                HashNode* temp = node;
                node = node->next;
                delete temp;
            }
        }
    }
};
// 测试：模拟局域网员工电脑监控软件的进程追踪
int main() {
    ProcessHashTable hashTable;
    // 模拟192.168.1.101终端的进程数据
    vector<ProcessData> processes1 = {
        {1001, "chrome.exe", 8.5, 1200000},
        {2002, "code.exe", 3.2, 800000},
        {3003, "illegal.exe", 15.8, 2000000} // 违规进程
    };
    // 模拟192.168.1.102终端的进程数据
    vector<ProcessData> processes2 = {
        {1004, "edge.exe", 5.1, 900000},
        {2005, "excel.exe", 2.8, 600000}
    };
    // 插入进程数据到哈希表（局域网员工电脑监控软件数据采集）
    hashTable.insertOrUpdate("192.168.1.101", processes1);
    hashTable.insertOrUpdate("192.168.1.102", processes2);
    // 查询192.168.1.101的进程（局域网员工电脑监控软件违规检测）
    vector<ProcessData>* result = hashTable.query("192.168.1.101");
    if (result != nullptr) {
        cout << "【192.168.1.101终端进程列表】" << endl;
        for (auto& p : *result) {
            cout << "PID:" << p.pid << " 名称:" << p.name 
                 << " CPU:" << p.cpuUsage << "% 内存:" << p.memoryUsage << "KB" << endl;
            // 模拟违规进程检测（局域网员工电脑监控软件核心逻辑）
            if (p.name == "illegal.exe") {
                cout << "⚠️  检测到违规进程：" << p.name << endl;
            }
        }
    }
    return 0;
}