0

我希望能够根据数组的可用性从数组中获取整数。当一个可用的整数被选中时，它会变得不可用，直到它被归还。

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

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

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

对于第一种方法，我通过每次成功调用整数请求时递增一个值来记录可用整数。如果可用整数按其 .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; }
    }
}

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

4

3 回答 3

2 
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;
        }
    }
}
于 2013-10-20T20:12:50.513 回答
0

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

于 2013-10-20T19:30:31.783 回答
0

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

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;
            }
        }
    }
}
于 2013-10-20T19:42:45.147 回答