Question

我希望能够根据数据的可用性从数组中获取整数。当选择了一个可用的整数时，它将被释放，直到它被返回为止。

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

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

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

对于第一种方法，我通过在每次成功调用整数请求时递增一个值来保持可用整数的计数。然后，可以使用此值来确定可用整数的起始索引，如果它们按.IsAvailable布尔值排序。

    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; }
    }
}

这让我觉得我这太复杂了，并且有更优雅的方法来解决这个问题。有什么建议吗？

Answer 1

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;
        }
    }
}

Answer 2

为什么不克隆一个简单的整数数组并拉出第一个项目并在每个循环中使用克隆数组？

Answer 3

我会从这样的事情开始，然后在发现性能成为问题时对其进行优化。根据整数集合的大小，这可能是一个非常快速的解决方案（对于相对较小的集合大小）或非常慢（对于非常大的集合大小）。

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;
            }
        }
    }
}

用于汇总整数的更简单方法

3 个答案: