池化整数的更简单方法

本文关键字：更简单 方法 整数 | 更新日期: 2023-09-27 18:36:13

我希望能够根据数组的可用性从数组中获取整数。 当选择可用整数时，它将变得不可用，直到它被返回。

虽然这遵循一个简单的池想法，但我认为我的方法过于复杂，并希望得到一些建议。

我正在实现许多关键的类似池的功能，包括：

  • 获取第一个可用的最低整数
  • 按升序获取所有可用整数
  • 从数组中获取特定整数
  • 将特定整数返回给数组以使其再次可用

对于第一种方法，我通过在每次成功调用整数请求时递增一个值来记录可用整数。 然后，此值可用于确定可用整数的起始索引（如果可用整数按其 .可用布尔值。

    public static int GetInteger()
    {
        // Get the next available integer
        int startIndex = integers.Length - numAvailableIntegers;
        var c = integers[startIndex];
        c.IsAvailable = false;
        // Sort the integers by availability
        Array.Sort(integers, SortIntegerAvailability.Comparer);
        numAvailableIntegers--;
        return c.Value;
    }

这里的问题是，按布尔值排序还需要在之后按整数值升序排序。

class SortIntegerAvailability : IComparer<Integer>
{
    static IComparer<Integer> comparer = new SortIntegerAvailability();
    public int Compare(Integer a, Integer b)
    {
        if (a.IsAvailable == b.IsAvailable)
        {
            return 0;
        }
        else return (a.IsAvailable == true) ? 1 : -1;
    }
    public static IComparer<Integer> Comparer
    {
        get { return comparer; }
    }
}

这让我觉得我把这个问题弄得太复杂了，有一种更优雅的方式来解决这个问题。 有什么建议吗？

池化整数的更简单方法

class IntegersGame
{
    private List<int> _sourceintegers;
    private List<int> _integers;
    public void Add(List<int> integers)
    {
        _sourceintegers = integers;
        Reset();
    }
    public void Reset()
    {
        _integers = _sourceintegers.Select(p => p).ToList();
        _integers.Sort();
    }
    public int GetFirst()
    {
        int ret = _integers.First();
        _integers.Remove(ret);
        return ret;
    }
    public List<int> GetAll()
    {
        return _integers;
    }
    public void Release(int des)
    {
        if (_sourceintegers.Contains(des))
        {
            _integers.Add(des);
            _integers.Sort();
        }
    }
    public int? Get(int source)
    {
        if(_sourceintegers.Contains(source) && (_integers.Contains(source))){
            _integers.Remove(source);
            return source;
        }else{
            return null;
        }
    }
}

为什么不克隆一个简单的整数数组并拉取第一项并每个周期重新调整克隆的数组呢？

我会从这样的东西开始，然后如果你发现性能是一个问题，请优化它。 根据整数集合的大小，这可能是一个非常快速的解决方案（对于相对较小的集合大小）或非常慢的解决方案（对于非常大的集合大小）。

private class MyInteger
{
    public int Value;
    public bool Available;
    public void MyInteger(int value, bool available)
    {
        Value = value;
        Available = available;
    }
}
public class IntegerPool
{
    private IList<MyInteger> _integers = new List<MyInteger>();
    public void IntegerPool(List<int> startingCollection)
    {
        startingCollection.Sort();
        foreach (var integer in startingCollection)
        {
            _integers.Add(new MyInteger(integer, true));
        }
    }
    public int GetFirstAvailable()
    {
        foreach (var integer in _integers)
        {
            if (integer.Available)
            {
                integer.Available = false;
                return integer.Value;
            }
        }
        throw new Exception("No more integers available.");
    }
    public IList<int> GetAllAvailable()
    {
        var list = new List<int>();
        foreach (var integer in _integers)
        {
            if (integer.Available)
                list.Add(integer.Value);
        }
        return list;
    }
    public int? TryGetSpecific(int specific)
    {
        foreach (var integer in _integers)
        {
            if (integer.Value == specific)
            {
                if (!integer.Available)
                    return null;
                integer.Available = false;
                return integer.Value;
            }
        }
        throw new Exception("Integer not in collection.");
    }
    public void ReleaseInteger(int integerToBeReleased)
    {
        foreach (var integer in _integers)
        {
            if (integer.Value == integerToBeReleased)
            {
                integer.Available = true;
                return;
            }
        }
    }
}
相关文章：