合并整数的更简单方法

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