电脑监控管理中的 C# 哈希表进程资源索引算法

using System;
// 进程资源数据类：封装电脑监控管理中的进程资源信息
public class ProcessResource
{
    public int ProcessId { get; set; }          // 进程ID
    public float CpuUsage { get; set; }         // CPU占用率（%）
    public long MemoryUsage { get; set; }       // 内存使用量（字节）
    public DateTime UpdateTime { get; set; }    // 数据更新时间
}
// 哈希表节点类：存储键值对与冲突链表指针
public class HashTableNode
{
    public int Key { get; set; }                // 键（进程ID）
    public ProcessResource Value { get; set; }  // 值（进程资源数据）
    public HashTableNode Next { get; set; }     // 冲突链表下一个节点
    public HashTableNode(int key, ProcessResource value)
    {
        Key = key;
        Value = value;
        Next = null;
    }
}
// 哈希表类：实现电脑监控管理的进程资源索引
public class ProcessResourceHashTable
{
    private HashTableNode[] _table;             // 哈希表数组
    private int _count;                         // 当前节点数量
    private const int InitialCapacity = 128;    // 初始容量
    private const float LoadFactor = 0.7f;      // 负载因子阈值
    // 构造函数：初始化哈希表
    public ProcessResourceHashTable()
    {
        _table = new HashTableNode[InitialCapacity];
        _count = 0;
    }
    // 哈希函数：计算进程ID的哈希值
    private int GetHash(int key)
    {
        int capacity = _table.Length;
        return (key % capacity) ^ (key >> 4);    // 除留余数+移位运算
    }
    // 扩容机制：容量翻倍并重新哈希
    private void Resize()
    {
        int newCapacity = _table.Length * 2;
        HashTableNode[] newTable = new HashTableNode[newCapacity];
        foreach (HashTableNode node in _table)
        {
            HashTableNode current = node;
            while (current != null)
            {
                int newHash = (current.Key % newCapacity) ^ (current.Key >> 4);
                if (newTable[newHash] == null)
                {
                    newTable[newHash] = new HashTableNode(current.Key, current.Value);
                }
                else
                {
                    HashTableNode temp = newTable[newHash];
                    while (temp.Next != null)
                    {
                        temp = temp.Next;
                    }
                    temp.Next = new HashTableNode(current.Key, current.Value);
                }
                current = current.Next;
            }
        }
        _table = newTable;
    }
    // 插入进程资源数据
    public void Insert(int processId, ProcessResource resource)
    {
        // 检查是否需要扩容
        if ((float)_count / _table.Length >= LoadFactor)
        {
            Resize();
        }
        int hash = GetHash(processId);
        HashTableNode newNode = new HashTableNode(processId, resource);
        if (_table[hash] == null)
        {
            _table[hash] = newNode;
        }
        else
        {
            // 处理冲突：添加到链表末尾
            HashTableNode current = _table[hash];
            while (current.Next != null)
            {
                // 若进程ID已存在，更新数据
                if (current.Key == processId)
                {
                    current.Value = resource;
                    return;
                }
                current = current.Next;
            }
            if (current.Key == processId)
            {
                current.Value = resource;
                return;
            }
            current.Next = newNode;
        }
        _count++;
    }
    // 查询指定进程ID的资源数据
    public ProcessResource Search(int processId)
    {
        int hash = GetHash(processId);
        HashTableNode current = _table[hash];
        while (current != null)
        {
            if (current.Key == processId)
            {
                return current.Value;
            }
            current = current.Next;
        }
        return null; // 未找到指定进程
    }
    // 删除指定进程ID的资源数据
    public bool Delete(int processId)
    {
        int hash = GetHash(processId);
        HashTableNode current = _table[hash];
        HashTableNode prev = null;
        while (current != null)
        {
            if (current.Key == processId)
            {
                if (prev == null)
                {
                    _table[hash] = current.Next; // 移除链表头节点
                }
                else
                {
                    prev.Next = current.Next;    // 移除链表中间节点
                }
                _count--;
                return true;
            }
            prev = current;
            current = current.Next;
        }
        return false; // 未找到指定进程
    }
    // 模拟电脑监控管理系统的进程资源数据操作
    public static void Main(string[] args)
    {
        ProcessResourceHashTable hashTable = new ProcessResourceHashTable();
        Console.WriteLine("电脑监控管理进程资源哈希表初始化完成");
        // 模拟插入500个进程的资源数据
        Random random = new Random();
        for (int i = 1; i <= 500; i++)
        {
            ProcessResource resource = new ProcessResource
            {
                ProcessId = i,
                CpuUsage = (float)Math.Round(random.NextDouble() * 100, 2), // CPU占用0-100%
                MemoryUsage = random.Next(1024 * 1024, 1024 * 1024 * 1024), // 内存1MB-1GB
                UpdateTime = DateTime.Now
            };
            hashTable.Insert(i, resource);
        }
        Console.WriteLine("电脑监控管理已插入500个进程的资源数据");
        // 模拟查询进程ID=250的资源数据
        int targetProcessId = 250;
        ProcessResource result = hashTable.Search(targetProcessId);
        if (result != null)
        {
            Console.WriteLine($"电脑监控管理查询结果：进程ID={result.ProcessId}, " +
                $"CPU占用率={result.CpuUsage}%, 内存使用量={result.MemoryUsage / (1024 * 1024)}MB, " +
                $"更新时间={result.UpdateTime:yyyy-MM-dd HH:mm:ss}");
        }
        else
        {
            Console.WriteLine($"电脑监控管理未查询到进程ID={targetProcessId}的资源数据");
        }
        // 模拟删除进程ID=250的资源数据
        bool deleteSuccess = hashTable.Delete(targetProcessId);
        Console.WriteLine(deleteSuccess ? 
            $"电脑监控管理已删除进程ID={targetProcessId}的资源数据" : 
            $"电脑监控管理删除进程ID={targetProcessId}失败");
    }
}